From 4cd70e68cec3f4fce59c08f76519fda422d008ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Tue, 18 Aug 2015 15:03:21 -0500 Subject: [PATCH] imrove python support make syntax as Python-like as possible get close to real. --- .gitignore | 2 + library/clp/CMakeFiles/progress.marks | 1 + packages/python/python.c | 1884 +++++++++++++------------ packages/python/python.pl | 223 ++- 4 files changed, 1142 insertions(+), 968 deletions(-) create mode 100644 library/clp/CMakeFiles/progress.marks diff --git a/.gitignore b/.gitignore index 611da148b..e16a93af7 100644 --- a/.gitignore +++ b/.gitignore @@ -80,3 +80,5 @@ C/new_iop.c *.log *.orig + +JIT/HPP/#JIT_In# diff --git a/library/clp/CMakeFiles/progress.marks b/library/clp/CMakeFiles/progress.marks new file mode 100644 index 000000000..573541ac9 --- /dev/null +++ b/library/clp/CMakeFiles/progress.marks @@ -0,0 +1 @@ +0 diff --git a/packages/python/python.c b/packages/python/python.c index ffb764cce..5e098990d 100644 --- a/packages/python/python.c +++ b/packages/python/python.c @@ -5,53 +5,41 @@ #include #include #ifdef HAVE_STAT -#undef HAVE_STAT +#undef HAVE_STATa #endif #include -static atom_t ATOM_true, - ATOM_colon, - ATOM_false, - ATOM_t; +//@{ -static functor_t FUNCTOR_dollar1, - FUNCTOR_abs1, - FUNCTOR_all1, - FUNCTOR_any1, - FUNCTOR_bin1, - FUNCTOR_dir1, - FUNCTOR_float1, - FUNCTOR_int1, - FUNCTOR_iter1, - FUNCTOR_iter2, - FUNCTOR_long1, - FUNCTOR_len1, - FUNCTOR_curly1, - FUNCTOR_ord1, - FUNCTOR_range1, - FUNCTOR_range2, - FUNCTOR_range3, - FUNCTOR_sum1, - FUNCTOR_pointer1, - FUNCTOR_complex2, - FUNCTOR_plus2, - FUNCTOR_sub2, - FUNCTOR_mul2, - FUNCTOR_div2, - FUNCTOR_hat2, - FUNCTOR_colon2, - FUNCTOR_comma2, - FUNCTOR_equal2; +/** @brief Prolog to Python library +* +* This is a C-library to call Python from Prolog. Although developed +* within YAP, it should work in SWI-Prolog with little work. +* +* Please look at python.pl for more information, and to real.pl and real.c +* for related work. +*/ + +static atom_t ATOM_true, ATOM_false, ATOM_colon, ATOM_dot, ATOM_none, ATOM_t; + +static functor_t FUNCTOR_dollar1, FUNCTOR_abs1, FUNCTOR_all1, FUNCTOR_any1, + FUNCTOR_bin1, FUNCTOR_brackets1, FUNCTOR_comma2, FUNCTOR_dir1, + FUNCTOR_float1, FUNCTOR_int1, FUNCTOR_iter1, FUNCTOR_iter2, FUNCTOR_long1, + FUNCTOR_len1, FUNCTOR_curly1, FUNCTOR_ord1, FUNCTOR_range1, FUNCTOR_range2, + FUNCTOR_range3, FUNCTOR_sum1, FUNCTOR_pointer1, FUNCTOR_complex2, + FUNCTOR_plus2, FUNCTOR_sub2, FUNCTOR_mul2, FUNCTOR_div2, FUNCTOR_hat2, + FUNCTOR_colon2, FUNCTOR_comma2, FUNCTOR_equal2, FUNCTOR_sqbrackets2, + FUNCTOR_dot2; static PyObject *py_Main; static PyObject *term_to_python(term_t t); +static foreign_t python_to_ptr(PyObject *pVal, term_t t); +static PyObject *atom_to_python_string(term_t t); static PyObject *ActiveModules[32]; static int active_modules = 0; -static inline int -proper_ascii_string(char *s) -{ +static inline int proper_ascii_string(char *s) { unsigned char c; while ((c = *s++)) { @@ -61,8 +49,7 @@ proper_ascii_string(char *s) return TRUE; } -static Py_ssize_t -get_p_int(PyObject *o, Py_ssize_t def) { +static Py_ssize_t get_p_int(PyObject *o, Py_ssize_t def) { if (o == NULL) return def; if (PyLong_Check(o)) { @@ -75,17 +62,15 @@ get_p_int(PyObject *o, Py_ssize_t def) { return def; } -static PyObject * -find_obj(PyObject *ob, term_t lhs) -{ +static PyObject *find_obj(PyObject *ob, term_t lhs) { char *s; PyObject *out, *pName; int arity = 0; if (!PL_get_atom_chars(lhs, &s)) { atom_t name; - if (!PL_get_name_arity(lhs, &name, &arity) ) - return NULL; + if (!PL_get_name_arity(lhs, &name, &arity)) + return NULL; s = PL_atom_chars(name); } if (ob) { @@ -93,65 +78,116 @@ find_obj(PyObject *ob, term_t lhs) return out; } if (!ob && !arity) { -#if PY_MAJOR_VERSION<3 - pName = PyString_FromString(s); +#if PY_MAJOR_VERSION < 3 + pName = PyString_FromString(s); #else pName = PyUnicode_FromString(s); #endif if (pName == NULL) { return NULL; } - if (( out = PyImport_Import(pName))) { + if ((out = PyImport_Import(pName))) { return out; } } - if (!ob && py_Main && (out = PyObject_GetAttrString(py_Main, s) ) ) + if (!ob && py_Main && (out = PyObject_GetAttrString(py_Main, s))) return out; return NULL; } -static int -copy_to_dictionary(PyObject *dict, term_t targ, term_t taux) -{ +static int copy_to_dictionary(PyObject *dict, term_t targ, term_t taux) { PyObject *lhs, *rhs; - term_t tleft = taux, tright = tleft; + term_t tleft = PL_new_term_ref(), tright = PL_new_term_ref(); - if (!PL_get_arg(1, targ, tleft)) { - return FALSE; + while (true) { + functor_t fun; + + if (!PL_get_functor(targ, &fun)) + return false; + if (fun == FUNCTOR_comma2) { + if (!PL_get_arg(1, targ, taux)) { + return false; + } + if (!PL_get_arg(1, taux, tleft)) { + return FALSE; + } + lhs = term_to_python(tleft); + if (!PL_get_arg(2, taux, tright)) { + return FALSE; + } + rhs = term_to_python(tright); + if (PyDict_SetItem(dict, lhs, rhs) < 0) { + return FALSE; + } + // PyObject_Print(dict, stderr, 0); fprintf(stderr,"\n"); + Py_DECREF(lhs); + Py_DECREF(rhs); + + if (!PL_get_arg(1, targ, targ)) { + return FALSE; + } + } else { + if (!PL_get_arg(1, targ, tleft)) { + return FALSE; + } + lhs = atom_to_python_string(tleft); + if (!PL_get_arg(2, targ, tright)) { + return FALSE; + } + rhs = term_to_python(tright); + if (PyDict_SetItem(dict, lhs, rhs) < 0) { + return FALSE; + } + // PyObject_Print(dict, stderr, 0); fprintf(stderr,"\n"); + Py_DECREF(lhs); + Py_DECREF(rhs); + break; + } } - lhs = term_to_python(tleft); - if (!PL_get_arg(2, targ, tright)) { - return FALSE; - } - rhs = term_to_python(tright); - if (PyDict_SetItem(dict, lhs, rhs) < 0 ) { - return FALSE; - } - //PyObject_Print(dict, stderr, 0); fprintf(stderr,"\n"); - Py_DECREF(lhs); - Py_DECREF(rhs); return TRUE; } -static PyObject * -bip_abs(term_t t) -{ +/** +* +* @section Python Built-Ins +* +* The Python engine includes a large number of Python built-ins. Some +* of them are interfaced here. +*/ + +//@{ + +/** +* Python abs +* +* @param t Prolog term with a number +* +* @return a Python object with the number's absolute value +*/ + +static PyObject *bip_abs(term_t t) { PyObject *pVal; - if (! PL_get_arg(1, t, t) ) + if (!PL_get_arg(1, t, t)) return NULL; pVal = term_to_python(t); return PyNumber_Absolute(pVal); } -static PyObject * -bip_all(term_t t) -{ +/** +* Python all +* +* @param t Prolog term with a previously constructed Python iterator +* +* @return the Python boolean `True` if all elements of the iterator are `True`, +* `False` otherwise. +*/ +static PyObject *bip_all(term_t t) { PyObject *it, *item, *v; PyObject *(*iternext)(PyObject *); int cmp; - if (! PL_get_arg(1, t, t) ) + if (!PL_get_arg(1, t, t)) return NULL; v = term_to_python(t); it = PyObject_GetIter(v); @@ -185,14 +221,20 @@ bip_all(term_t t) return Py_True; } -static PyObject * -bip_any(term_t t) -{ +/** +* Python any +* +* @param t Prolog term with a previously constructed Python iterator +* +* @return the Python boolean `True` if any element of the iterator is `True`, +* `False` if all of them are false. +*/ +static PyObject *bip_any(term_t t) { PyObject *it, *item, *v; PyObject *(*iternext)(PyObject *); int cmp; - if (! PL_get_arg(1, t, t) ) + if (!PL_get_arg(1, t, t)) return NULL; v = term_to_python(t); it = PyObject_GetIter(v); @@ -225,31 +267,26 @@ bip_any(term_t t) Py_RETURN_FALSE; } -static PyObject * -bip_bin(term_t t) -{ +static PyObject *bip_bin(term_t t) { PyObject *v; - if (! PL_get_arg(1, t, t) ) + if (!PL_get_arg(1, t, t)) return NULL; v = term_to_python(t); return PyNumber_ToBase(v, 2); } - -static PyObject * -bip_float(term_t t) -{ +static PyObject *bip_float(term_t t) { PyObject *pVal, *o; - if (! PL_get_arg(1, t, t) ) + if (!PL_get_arg(1, t, t)) return NULL; pVal = term_to_python(t); if (PyLong_Check(pVal)) { - o = PyFloat_FromDouble( PyLong_AsLong(pVal) ); -#if PY_MAJOR_VERSION<3 + o = PyFloat_FromDouble(PyLong_AsLong(pVal)); +#if PY_MAJOR_VERSION < 3 } else if (PyInt_Check(pVal)) { - o = PyFloat_FromDouble( PyInt_AsLong(pVal) ); + o = PyFloat_FromDouble(PyInt_AsLong(pVal)); #endif } else if (PyFloat_Check(pVal)) { return pVal; @@ -259,17 +296,15 @@ bip_float(term_t t) return o; } -static PyObject * -bip_int(term_t t) -{ +static PyObject *bip_int(term_t t) { PyObject *pVal, *o; - if (! PL_get_arg(1, t, t) ) + if (!PL_get_arg(1, t, t)) return NULL; pVal = term_to_python(t); -#if PY_MAJOR_VERSION<3 +#if PY_MAJOR_VERSION < 3 if (PyLong_Check(pVal)) { - o = PyInt_FromLong( PyLong_AsLong(pVal) ); + o = PyInt_FromLong(PyLong_AsLong(pVal)); } else if (PyInt_Check(pVal)) { return pVal; #else @@ -277,10 +312,10 @@ bip_int(term_t t) return pVal; #endif } else if (PyFloat_Check(pVal)) { -#if PY_MAJOR_VERSION<3 - o = PyInt_FromLong( PyFloat_AsDouble(pVal) ); +#if PY_MAJOR_VERSION < 3 + o = PyInt_FromLong(PyFloat_AsDouble(pVal)); #else - o = PyLong_FromDouble( PyFloat_AsDouble(pVal) ); + o = PyLong_FromDouble(PyFloat_AsDouble(pVal)); #endif } else return NULL; @@ -288,47 +323,40 @@ bip_int(term_t t) return o; } -static PyObject * -bip_long(term_t t) -{ +static PyObject *bip_long(term_t t) { PyObject *pVal, *o; - if (! PL_get_arg(1, t, t) ) + if (!PL_get_arg(1, t, t)) return NULL; pVal = term_to_python(t); if (PyLong_Check(pVal)) { return pVal; -#if PY_MAJOR_VERSION<3 +#if PY_MAJOR_VERSION < 3 } else if (PyInt_Check(pVal)) { - o = PyLong_FromLong( PyInt_AsLong(pVal) ); + o = PyLong_FromLong(PyInt_AsLong(pVal)); #endif } else if (PyFloat_Check(pVal)) { - o = PyLong_FromLong( PyFloat_AsDouble(pVal) ); + o = PyLong_FromLong(PyFloat_AsDouble(pVal)); } else return NULL; Py_DECREF(pVal); return o; } -static PyObject * -bip_iter(term_t t) -{ +static PyObject *bip_iter(term_t t) { PyObject *v; - if (! PL_get_arg(1, t, t) ) + if (!PL_get_arg(1, t, t)) return NULL; v = term_to_python(t); return PyObject_GetIter(v); } - -static PyObject * -bip_ord(term_t t) -{ +static PyObject *bip_ord(term_t t) { PyObject *pVal; Py_ssize_t size; - if (! PL_get_arg(1, t, t) ) + if (!PL_get_arg(1, t, t)) return NULL; pVal = term_to_python(t); if (PyUnicode_Check(pVal)) { @@ -367,14 +395,12 @@ bip_ord(term_t t) return NULL; } -static PyObject* -bip_sum(term_t t) -{ +static PyObject *bip_sum(term_t t) { PyObject *seq; PyObject *result = NULL; PyObject *temp, *item, *iter; - if (! PL_get_arg(1, t, t) ) + if (!PL_get_arg(1, t, t)) return NULL; seq = term_to_python(t); iter = PyObject_GetIter(seq); @@ -396,19 +422,19 @@ bip_sum(term_t t) /* reject string values for 'start' parameter */ if (PyObject_TypeCheck(result, &PyBaseString_Type)) { PyErr_SetString(PyExc_TypeError, - "sum() can't sum strings [use ''.join(seq) instead]"); + "sum() can't sum strings [use ''.join(seq) instead]"); Py_DECREF(iter); return NULL; } Py_INCREF(result); -#endif } +#endif #ifndef SLOW_SUM - /* Fast addition by keeping temporary sums in C instead of new Python objects. - Assumes all inputs are the same type. If the assumption fails, default - to the more general routine. - */ +/* Fast addition by keeping temporary sums in C instead of new Python objects. +Assumes all inputs are the same type. If the assumption fails, default +to the more general routine. +*/ #if PY_MAJOR_VERSION < 3 if (PyInt_CheckExact(result)) { long i_result = PyInt_AS_LONG(result); @@ -418,33 +444,34 @@ bip_sum(term_t t) #endif Py_DECREF(result); result = NULL; - while(result == NULL) { + while (result == NULL) { item = PyIter_Next(iter); if (item == NULL) { - Py_DECREF(iter); - if (PyErr_Occurred()) - return NULL; + Py_DECREF(iter); + if (PyErr_Occurred()) + return NULL; #if PY_MAJOR_VERSION < 3 - return PyInt_FromLong(i_result); + return PyInt_FromLong(i_result); #else - return PyLong_FromLong(i_result); + return PyLong_FromLong(i_result); #endif } #if PY_MAJOR_VERSION < 3 if (PyInt_CheckExact(item)) { - long b = PyInt_AS_LONG(item); + long b = PyInt_AS_LONG(item); #else if (PyLong_CheckExact(item)) { - long b = PyLong_AS_LONG(item); + long b = PyLong_AS_LONG(item); #endif - long x = i_result + b; - if ((x^i_result) >= 0 || (x^b) >= 0) { - i_result = x; - Py_DECREF(item); - continue; - } + long x = i_result + b; + if ((x ^ i_result) >= 0 || (x ^ b) >= 0) { + i_result = x; + Py_DECREF(item); + continue; + } } - /* Either overflowed or is not an int. Restore real objects and process normally */ +/* Either overflowed or is not an int. Restore real objects and process normally + */ #if PY_MAJOR_VERSION < 3 result = PyInt_FromLong(i_result); #else @@ -455,8 +482,8 @@ bip_sum(term_t t) Py_DECREF(item); result = temp; if (result == NULL) { - Py_DECREF(iter); - return NULL; + Py_DECREF(iter); + return NULL; } } } @@ -465,33 +492,31 @@ bip_sum(term_t t) double f_result = PyFloat_AS_DOUBLE(result); Py_DECREF(result); result = NULL; - while(result == NULL) { + while (result == NULL) { item = PyIter_Next(iter); if (item == NULL) { - Py_DECREF(iter); - if (PyErr_Occurred()) - return NULL; - return PyFloat_FromDouble(f_result); + Py_DECREF(iter); + if (PyErr_Occurred()) + return NULL; + return PyFloat_FromDouble(f_result); } if (PyFloat_CheckExact(item)) { - PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0) - f_result += PyFloat_AS_DOUBLE(item); - PyFPE_END_PROTECT(f_result) - Py_DECREF(item); - continue; + PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0) + f_result += PyFloat_AS_DOUBLE(item); + PyFPE_END_PROTECT(f_result) Py_DECREF(item); + continue; } #if PY_MAJOR_VERSION < 3 if (PyInt_CheckExact(item)) { - PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0) - f_result += (double)PyInt_AS_LONG(item); + PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0) + f_result += (double)PyInt_AS_LONG(item); #else if (PyLong_CheckExact(item)) { - PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0) - f_result += PyLong_AsDouble(item); + PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0) + f_result += PyLong_AsDouble(item); #endif - PyFPE_END_PROTECT(f_result) - Py_DECREF(item); - continue; + PyFPE_END_PROTECT(f_result) Py_DECREF(item); + continue; } result = PyFloat_FromDouble(f_result); temp = PyNumber_Add(result, item); @@ -499,32 +524,32 @@ bip_sum(term_t t) Py_DECREF(item); result = temp; if (result == NULL) { - Py_DECREF(iter); - return NULL; + Py_DECREF(iter); + return NULL; } } } #endif - for(;;) { + for (;;) { item = PyIter_Next(iter); if (item == NULL) { /* error, or end-of-sequence */ if (PyErr_Occurred()) { - Py_DECREF(result); - result = NULL; + Py_DECREF(result); + result = NULL; } break; } /* It's tempting to use PyNumber_InPlaceAdd instead of - PyNumber_Add here, to avoid quadratic running time - when doing 'sum(list_of_lists, [])'. However, this - would produce a change in behaviour: a snippet like + PyNumber_Add here, to avoid quadratic running time + when doing 'sum(list_of_lists, [])'. However, this + would produce a change in behaviour: a snippet like - empty = [] - sum([[x] for x in range(10)], empty) + empty = [] + sum([[x] for x in range(10)], empty) - would change the value of empty. */ + would change the value of empty. */ temp = PyNumber_Add(result, item); Py_DECREF(result); Py_DECREF(item); @@ -536,9 +561,9 @@ bip_sum(term_t t) return result; } -static long -get_int(term_t arg) -{ +//@} + +static long get_int(term_t arg) { long ilow; if (!PL_get_long(arg, &ilow)) { @@ -547,7 +572,7 @@ get_int(term_t arg) return PyLong_AsLong(low); #if PY_MAJOR_VERSION < 3 } else if (PyInt_Check(low)) { - return PyInt_AsLong(low); + return PyInt_AsLong(low); #endif } else { return 0; @@ -556,161 +581,178 @@ get_int(term_t arg) return ilow; } - /* Return number of items in range/xrange (lo, hi, step). step > 0 - * required. Return a value < 0 if & only if the true value is too - * large to fit in a signed long. - */ -static long -get_len_of_range(long lo, long hi, long step) -{ - /* ------------------------------------------------------------- - If lo >= hi, the range is empty. - Else if n values are in the range, the last one is - lo + (n-1)*step, which must be <= hi-1. Rearranging, - n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives - the proper value. Since lo < hi in this case, hi-lo-1 >= 0, so - the RHS is non-negative and so truncation is the same as the - floor. Letting M be the largest positive long, the worst case - for the RHS numerator is hi=M, lo=-M-1, and then - hi-lo-1 = M-(-M-1)-1 = 2*M. Therefore unsigned long has enough - precision to compute the RHS exactly. - ---------------------------------------------------------------*/ - long n = 0; - if (lo < hi) { - unsigned long uhi = (unsigned long)hi; - unsigned long ulo = (unsigned long)lo; - unsigned long diff = uhi - ulo - 1; - n = (long)(diff / (unsigned long)step + 1); - } - return n; +* required. Return a value < 0 if & only if the true value is too +* large to fit in a signed long. +*/ +static long get_len_of_range(long lo, long hi, long step) { + /* ------------------------------------------------------------- + If lo >= hi, the range is empty. + Else if n values are in the range, the last one is + lo + (n-1)*step, which must be <= hi-1. Rearranging, + n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives + the proper value. Since lo < hi in this case, hi-lo-1 >= 0, so + the RHS is non-negative and so truncation is the same as the + floor. Letting M be the largest positive long, the worst case + for the RHS numerator is hi=M, lo=-M-1, and then + hi-lo-1 = M-(-M-1)-1 = 2*M. Therefore unsigned long has enough + precision to compute the RHS exactly. + ---------------------------------------------------------------*/ + long n = 0; + if (lo < hi) { + unsigned long uhi = (unsigned long)hi; + unsigned long ulo = (unsigned long)lo; + unsigned long diff = uhi - ulo - 1; + n = (long)(diff / (unsigned long)step + 1); + } + return n; } -static PyObject * -bip_range(term_t t) -{ - long ilow = 0, ihigh = 0, istep = 1; - long bign; - Py_ssize_t i, n; - int arity; - atom_t name; - term_t arg = PL_new_term_ref(); +static PyObject *bip_range(term_t t) { + long ilow = 0, ihigh = 0, istep = 1; + long bign; + Py_ssize_t i, n; + int arity; + atom_t name; + term_t arg = PL_new_term_ref(); - PyObject *v; + PyObject *v; - if (!PL_get_name_arity(t, &name, &arity) ) - return NULL; - if (! PL_get_arg(1, t, arg) ) + if (!PL_get_name_arity(t, &name, &arity)) + return NULL; + if (!PL_get_arg(1, t, arg)) + return NULL; + ilow = get_int(arg); + if (arity == 1) { + ihigh = ilow; + ilow = 0; + } else { + if (!PL_get_arg(2, t, arg)) return NULL; - ilow = get_int(arg); - if (arity == 1) { - ihigh = ilow; - ilow = 0; - } else { - if (! PL_get_arg(2, t, arg) ) - return NULL; - ihigh = get_int(arg); - if (arity == 3) { - if (! PL_get_arg(3, t, arg) ) - return NULL; - istep = get_int(arg); - } - } - if (istep == 0) { - PyErr_SetString(PyExc_ValueError, - "range() step argument must not be zero"); + ihigh = get_int(arg); + if (arity == 3) { + if (!PL_get_arg(3, t, arg)) return NULL; + istep = get_int(arg); } - if (istep > 0) - bign = get_len_of_range(ilow, ihigh, istep); - else - bign = get_len_of_range(ihigh, ilow, -istep); - n = (Py_ssize_t)bign; - if (bign < 0 || (long)n != bign) { - PyErr_SetString(PyExc_OverflowError, - "range() result has too many items"); - return NULL; - } - v = PyList_New(n); - if (v == NULL) - return NULL; - for (i = 0; i < n; i++) { + } + if (istep == 0) { + PyErr_SetString(PyExc_ValueError, "range() step argument must not be zero"); + return NULL; + } + if (istep > 0) + bign = get_len_of_range(ilow, ihigh, istep); + else + bign = get_len_of_range(ihigh, ilow, -istep); + n = (Py_ssize_t)bign; + if (bign < 0 || (long)n != bign) { + PyErr_SetString(PyExc_OverflowError, "range() result has too many items"); + return NULL; + } + v = PyList_New(n); + if (v == NULL) + return NULL; + for (i = 0; i < n; i++) { #if PY_MAJOR_VERSION < 3 - PyObject *w = PyInt_FromLong(ilow); + PyObject *w = PyInt_FromLong(ilow); #else - PyObject *w = PyLong_FromLong(ilow); + PyObject *w = PyLong_FromLong(ilow); #endif - if (w == NULL) { - Py_DECREF(v); - return NULL; - } - PyList_SET_ITEM(v, i, w); - ilow += istep; + if (w == NULL) { + Py_DECREF(v); + return NULL; } - return v; + PyList_SET_ITEM(v, i, w); + ilow += istep; + } + return v; } +static PyObject *atom_to_python_string(term_t t) { + // Yap_DebugPlWrite(YAP_GetFromSlot(t)); fprintf(stderr, " here I + // am\n"); + char *s; + if (!PL_get_atom_chars(t, &s)) + return NULL; +/* return __main__,s */ +#if PY_MAJOR_VERSION < 3 + if (proper_ascii_string(s)) { + return PyString_FromStringAndSize(s, strlen(s)); + } else +#endif + { + PyObject *pobj = PyUnicode_DecodeUTF8(s, strlen(s), NULL); + // fprintf(stderr, "%s\n", s); + return pobj; + } +} -static PyObject * -term_to_python(term_t t) -{ - // Yap_DebugPlWrite(YAP_GetFromSlot(t)); fprintf(stderr, " here I am\n"); +/** +* term_to_python translates and evaluates from Prolog to Python +* +* @param t handle to Prolog term +* +* @return a Python object descriptor or NULL if failed +*/ + +static PyObject *term_to_python(term_t t) { + // Yap_DebugPlWrite(YAP_GetFromSlot(t)); fprintf(stderr, " here I + // am\n"); switch (PL_term_type(t)) { case PL_VARIABLE: return NULL; - case PL_ATOM: - { - atom_t at; + case PL_ATOM: { + atom_t at; - if (PL_get_atom(t, &at)) { - if (at == ATOM_true) return Py_True; - if (at == ATOM_false) return Py_False; - } - { - char *s; - if (!PL_get_atom_chars(t, &s)) - return NULL; - /* return __main__,s */ - return PyObject_GetAttrString(py_Main, s); - } + if (PL_get_atom(t, &at)) { + if (at == ATOM_true) + return Py_True; + if (at == ATOM_false) + return Py_False; + if (at == ATOM_none) + return Py_None; } - break; - case PL_STRING: - { - char *s; - if (!PL_get_chars(t, &s, REP_UTF8|CVT_ATOM|CVT_STRING|BUF_DISCARDABLE) ) { - return NULL; - } -#if PY_MAJOR_VERSION < 3 - if (proper_ascii_string(s)) { - return PyString_FromStringAndSize(s, strlen(s) ); - } else -#endif - { - PyObject *pobj = PyUnicode_DecodeUTF8(s, strlen(s), NULL); - //fprintf(stderr, "%s\n", s); - return pobj; - } - } - break; - case PL_INTEGER: { - int64_t j; - if (!PL_get_int64_ex(t, &j)) - return NULL; + char *s; + if (!PL_get_atom_chars(t, &s)) + return NULL; + /* return __main__,s */ + return PyObject_GetAttrString(py_Main, s); + } + } break; + case PL_STRING: { + char *s; + if (!PL_get_chars(t, &s, + REP_UTF8 | CVT_ATOM | CVT_STRING | BUF_DISCARDABLE)) { + return NULL; + } #if PY_MAJOR_VERSION < 3 - return PyInt_FromLong(j); + if (proper_ascii_string(s)) { + return PyString_FromStringAndSize(s, strlen(s)); + } else +#endif + { + PyObject *pobj = PyUnicode_DecodeUTF8(s, strlen(s), NULL); + // fprintf(stderr, "%s\n", s); + return pobj; + } + } break; + case PL_INTEGER: { + int64_t j; + if (!PL_get_int64_ex(t, &j)) + return NULL; +#if PY_MAJOR_VERSION < 3 + return PyInt_FromLong(j); #else return PyLong_FromLong(j); #endif - } - case PL_FLOAT: - { - double fl; - if (!PL_get_float(t, &fl)) - return NULL; - return PyFloat_FromDouble( fl ); - } + } + case PL_FLOAT: { + double fl; + if (!PL_get_float(t, &fl)) + return NULL; + return PyFloat_FromDouble(fl); + } case PL_TERM: if (PL_is_list(t)) { size_t len, i; @@ -719,328 +761,330 @@ term_to_python(term_t t) PL_skip_list(t, tail, &len); if (!PL_get_nil(tail)) - return NULL; + return NULL; arg = tail; out = PyList_New(len); if (!out) - return NULL; + return NULL; - for (i=0; i< len; i++) { - if (!PL_get_list(t, arg, t)) { - return NULL; - } - if (PyList_SetItem(out, i, term_to_python(arg)) < 0) - return NULL; + for (i = 0; i < len; i++) { + if (!PL_get_list(t, arg, t)) { + return NULL; + } + if (PyList_SetItem(out, i, term_to_python(arg)) < 0) + return NULL; } return out; } else { functor_t fun; if (!PL_get_functor(t, &fun)) - return NULL; + return NULL; if (fun == FUNCTOR_dollar1) { - char *s; - term_t targ = PL_new_term_ref(); - if (! PL_get_arg(1, t, targ) ) - return NULL; - if (!PL_get_atom_chars(targ, &s)) - return NULL; - /* return __main__,s */ - return PyObject_GetAttrString(py_Main, s); + char *s; + term_t targ = PL_new_term_ref(); + if (!PL_get_arg(1, t, targ)) + return NULL; + if (!PL_get_atom_chars(targ, &s)) + return NULL; + /* return __main__,s */ + return PyObject_GetAttrString(py_Main, s); } else if (fun == FUNCTOR_pointer1) { - void *ptr; - term_t targ = PL_new_term_ref(); + void *ptr; + term_t targ = PL_new_term_ref(); - if (! PL_get_arg(1, t, targ) ) - return NULL; - if (!PL_get_pointer(targ, &ptr)) - return NULL; - Py_INCREF((PyObject *)ptr); - /* return __main__,s */ - return (PyObject *)ptr; + if (!PL_get_arg(1, t, targ)) + return NULL; + if (!PL_get_pointer(targ, &ptr)) + return NULL; + Py_INCREF((PyObject *)ptr); + /* return __main__,s */ + return (PyObject *)ptr; + } else if (fun == FUNCTOR_brackets1) { + if (!PL_get_arg(1, t, t)) + return NULL; + return term_to_python(t); } else if (fun == FUNCTOR_abs1) { - return bip_abs(t); + return bip_abs(t); } else if (fun == FUNCTOR_all1) { - return bip_all(t); + return bip_all(t); } else if (fun == FUNCTOR_any1) { - return bip_any(t); + return bip_any(t); } else if (fun == FUNCTOR_bin1) { - return bip_bin(t); + return bip_bin(t); } else if (fun == FUNCTOR_ord1) { - return bip_ord(t); + return bip_ord(t); } else if (fun == FUNCTOR_int1) { - return bip_int(t); + return bip_int(t); } else if (fun == FUNCTOR_long1) { - return bip_long(t); + return bip_long(t); } else if (fun == FUNCTOR_float1) { - return bip_float(t); + return bip_float(t); } else if (fun == FUNCTOR_iter1) { - return bip_iter(t); - } else if (fun == FUNCTOR_range1 || - fun == FUNCTOR_range2 || - fun == FUNCTOR_range3) { - return bip_range(t); + return bip_iter(t); + } else if (fun == FUNCTOR_range1 || fun == FUNCTOR_range2 || + fun == FUNCTOR_range3) { + return bip_range(t); } else if (fun == FUNCTOR_sum1) { - return bip_sum(t); + return bip_sum(t); } else if (fun == FUNCTOR_len1) { - term_t targ = PL_new_term_ref(); - PyObject *ptr; + term_t targ = PL_new_term_ref(); + PyObject *ptr; - if (! PL_get_arg(1, t, targ) ) - return NULL; - ptr = term_to_python(targ); - return PyLong_FromLong(PyObject_Length(ptr)); + if (!PL_get_arg(1, t, targ)) + return NULL; + ptr = term_to_python(targ); + return PyLong_FromLong(PyObject_Length(ptr)); } else if (fun == FUNCTOR_dir1) { - term_t targ = PL_new_term_ref(); - PyObject *ptr; + term_t targ = PL_new_term_ref(); + PyObject *ptr; - if (! PL_get_arg(1, t, targ) ) - return NULL; - ptr = term_to_python(targ); - return PyObject_Dir(ptr); + if (!PL_get_arg(1, t, targ)) + return NULL; + ptr = term_to_python(targ); + return PyObject_Dir(ptr); } else if (fun == FUNCTOR_complex2) { - term_t targ = PL_new_term_ref(); - PyObject *lhs, *rhs; - double d1, d2; + term_t targ = PL_new_term_ref(); + PyObject *lhs, *rhs; + double d1, d2; - if (! PL_get_arg(1, t, targ) ) - return NULL; - lhs = term_to_python(targ); - if (!PyNumber_Check(lhs)) - return NULL; - if (PyFloat_Check(lhs)) { - d1 = PyFloat_AsDouble(lhs); - } else if (PyLong_Check(lhs)) { - d1 = PyLong_AsLong(lhs); + if (!PL_get_arg(1, t, targ)) + return NULL; + lhs = term_to_python(targ); + if (!PyNumber_Check(lhs)) + return NULL; + if (PyFloat_Check(lhs)) { + d1 = PyFloat_AsDouble(lhs); + } else if (PyLong_Check(lhs)) { + d1 = PyLong_AsLong(lhs); #if PY_MAJOR_VERSION < 3 - } else if (PyInt_Check(lhs)) { - d1 = PyInt_AsLong(lhs); + } else if (PyInt_Check(lhs)) { + d1 = PyInt_AsLong(lhs); #endif - } else { - return NULL; - } - if (! PL_get_arg(2, t, targ) ) - return NULL; - rhs = term_to_python(targ); - if (!PyNumber_Check(rhs)) - return NULL; - if (PyFloat_Check(rhs)) { - d2 = PyFloat_AsDouble(rhs); - } else if (PyLong_Check(rhs)) { - d2 = PyLong_AsLong(rhs); + } else { + return NULL; + } + if (!PL_get_arg(2, t, targ)) + return NULL; + rhs = term_to_python(targ); + if (!PyNumber_Check(rhs)) + return NULL; + if (PyFloat_Check(rhs)) { + d2 = PyFloat_AsDouble(rhs); + } else if (PyLong_Check(rhs)) { + d2 = PyLong_AsLong(rhs); #if PY_MAJOR_VERSION < 3 - } else if (PyInt_Check(rhs)) { - d2 = PyInt_AsLong(rhs); + } else if (PyInt_Check(rhs)) { + d2 = PyInt_AsLong(rhs); #endif - } else { - return NULL; - } + } else { + return NULL; + } - return PyComplex_FromDoubles(d1, d2); + return PyComplex_FromDoubles(d1, d2); } else if (fun == FUNCTOR_curly1) { - term_t targ = PL_new_term_ref(), taux = PL_new_term_ref(); - PyObject *dict; + term_t targ = PL_new_term_ref(), taux = PL_new_term_ref(); + PyObject *dict; - if (! PL_get_arg(1, t, t) ) - return NULL; - if (! (dict = PyDict_New() ) ) - return NULL; - while (PL_is_functor(t, FUNCTOR_comma2)) { - if (! PL_get_arg(1, t, targ) ) - return NULL; - if (PL_is_functor(targ, FUNCTOR_colon2)) { - if ( !copy_to_dictionary(dict, targ, taux) ) - return NULL; - if (! PL_get_arg(2, t, t) ) - return NULL; - } else { - return NULL; - } - } - if (PL_is_functor(t, FUNCTOR_colon2)) { - if ( !copy_to_dictionary(dict, t, taux) ) - return NULL; - } else { - return NULL; - } - return dict; + if (!PL_get_arg(1, t, t)) + return NULL; + if (!(dict = PyDict_New())) + return NULL; + while (PL_is_functor(t, FUNCTOR_comma2)) { + if (!PL_get_arg(1, t, targ)) + return NULL; + if (PL_is_functor(targ, FUNCTOR_colon2)) { + if (!copy_to_dictionary(dict, targ, taux)) + return NULL; + if (!PL_get_arg(2, t, t)) + return NULL; + } else { + return NULL; + } + } + if (PL_is_functor(t, FUNCTOR_colon2)) { + if (!copy_to_dictionary(dict, t, taux)) + return NULL; + } else { + return NULL; + } + return dict; } else if (fun == FUNCTOR_plus2) { - term_t targ = PL_new_term_ref(); - PyObject *lhs, *rhs; + term_t targ = PL_new_term_ref(); + PyObject *lhs, *rhs; - if (! PL_get_arg(1, t, targ) ) - return NULL; - lhs = term_to_python(targ); - if (! PL_get_arg(2, t, targ) ) - return NULL; - rhs = term_to_python(targ); - if (PySequence_Check(lhs) && PySequence_Check(rhs)) { - return PySequence_Concat(lhs, rhs); - } - if (!PyNumber_Check(lhs)) - return NULL; - if (!PyNumber_Check(rhs)) - return NULL; - return PyNumber_Add(lhs, rhs); + if (!PL_get_arg(1, t, targ)) + return NULL; + lhs = term_to_python(targ); + if (!PL_get_arg(2, t, targ)) + return NULL; + rhs = term_to_python(targ); + if (PySequence_Check(lhs) && PySequence_Check(rhs)) { + return PySequence_Concat(lhs, rhs); + } + if (!PyNumber_Check(lhs)) + return NULL; + if (!PyNumber_Check(rhs)) + return NULL; + return PyNumber_Add(lhs, rhs); } else if (fun == FUNCTOR_sub2) { - term_t targ = PL_new_term_ref(); - PyObject *lhs, *rhs; + term_t targ = PL_new_term_ref(); + PyObject *lhs, *rhs; - if (! PL_get_arg(1, t, targ) ) - return NULL; - lhs = term_to_python(targ); - if (!PyNumber_Check(lhs)) - return NULL; - if (! PL_get_arg(2, t, targ) ) - return NULL; - rhs = term_to_python(targ); - if (!PyNumber_Check(rhs)) - return NULL; - return PyNumber_Subtract(lhs, rhs); + if (!PL_get_arg(1, t, targ)) + return NULL; + lhs = term_to_python(targ); + if (!PyNumber_Check(lhs)) + return NULL; + if (!PL_get_arg(2, t, targ)) + return NULL; + rhs = term_to_python(targ); + if (!PyNumber_Check(rhs)) + return NULL; + return PyNumber_Subtract(lhs, rhs); } else if (fun == FUNCTOR_mul2) { - term_t targ = PL_new_term_ref(); - PyObject *lhs, *rhs; + term_t targ = PL_new_term_ref(); + PyObject *lhs, *rhs; - if (! PL_get_arg(1, t, targ) ) - return NULL; - lhs = term_to_python(targ); - if (! PL_get_arg(2, t, targ) ) - return NULL; - rhs = term_to_python(targ); - if (PySequence_Check(lhs) && ( + if (!PL_get_arg(1, t, targ)) + return NULL; + lhs = term_to_python(targ); + if (!PL_get_arg(2, t, targ)) + return NULL; + rhs = term_to_python(targ); + if (PySequence_Check(lhs) && ( #if PY_MAJOR_VERSION < 3 - PyInt_Check(rhs) || + PyInt_Check(rhs) || #endif - PyLong_Check(rhs)) ){ - return PySequence_Repeat(lhs, get_p_int(rhs, 0)); - } - if (!PyNumber_Check(lhs)+!PyNumber_Check(rhs)) - return NULL; - return PyNumber_Multiply(lhs, rhs); + PyLong_Check(rhs))) { + return PySequence_Repeat(lhs, get_p_int(rhs, 0)); + } + if (!PyNumber_Check(lhs) + !PyNumber_Check(rhs)) + return NULL; + return PyNumber_Multiply(lhs, rhs); } else if (fun == FUNCTOR_div2) { - term_t targ = PL_new_term_ref(); - PyObject *lhs, *rhs; + term_t targ = PL_new_term_ref(); + PyObject *lhs, *rhs; - if (! PL_get_arg(1, t, targ) ) - return NULL; - lhs = term_to_python(targ); - if (!PyNumber_Check(lhs)) - return NULL; - if (! PL_get_arg(2, t, targ) ) - return NULL; - rhs = term_to_python(targ); - if (!PyNumber_Check(rhs)) - return NULL; + if (!PL_get_arg(1, t, targ)) + return NULL; + lhs = term_to_python(targ); + if (!PyNumber_Check(lhs)) + return NULL; + if (!PL_get_arg(2, t, targ)) + return NULL; + rhs = term_to_python(targ); + if (!PyNumber_Check(rhs)) + return NULL; #if PY_MAJOR_VERSION < 3 - return - PyNumber_Divide(lhs, rhs); + return PyNumber_Divide(lhs, rhs); #else - return - PyNumber_TrueDivide(lhs, rhs); + return PyNumber_TrueDivide(lhs, rhs); #endif - } else if (fun == FUNCTOR_hat2) { - term_t targ = PL_new_term_ref(), trhs = PL_new_term_ref(); - PyObject *lhs, *rhs; + } else if (fun == FUNCTOR_sqbrackets2) { + // + term_t targ = PL_new_term_ref(), trhs = PL_new_term_ref(); + PyObject *v; + Py_ssize_t min, max; - if (! PL_get_arg(1, t, targ)) - return NULL; - lhs = term_to_python(targ); - if (! PL_get_arg(2, t, targ) || !PL_is_list(targ) || !PL_get_list(targ, trhs, targ) ) - return NULL; - if (PL_is_functor(trhs, FUNCTOR_colon2) ) { - Py_ssize_t left, right; - if (!PL_get_arg(1, trhs, targ)) - return NULL; - left = get_p_int(term_to_python(targ), 0); - if (!PL_get_arg(2, trhs, targ)) - return NULL; - right = get_p_int(term_to_python(targ), PyObject_Size(lhs) ); - if (!PySequence_Check(lhs)) - return NULL; - return PySequence_GetSlice(lhs, left, right); - } else { - rhs = term_to_python(trhs); - return PyObject_GetItem(lhs, rhs); - } - } else if (fun == FUNCTOR_colon2) { - term_t tleft = PL_new_term_ref(); - PyObject *pArgs, *o; - long i; - int arity; - atom_t name; + if (!PL_get_arg(1, t, targ)) + return NULL; + v = term_to_python(targ); + if (!PL_get_arg(2, t, targ) || !PL_get_list(targ, trhs, targ)) + return NULL; + if (PL_is_functor(targ, FUNCTOR_colon2)) { + if (!PL_get_arg(1, trhs, targ)) + return NULL; + min = get_p_int(term_to_python(targ), 0); + if (!PL_get_arg(2, trhs, targ)) + return NULL; + if (PL_is_functor(targ, FUNCTOR_colon2)) { + return NULL; + } + max = get_p_int(term_to_python(targ), PyObject_Size(v)); + if (!PySequence_Check(v)) + return NULL; + return PySequence_GetSlice(v, min, max); + } + } else if (fun == FUNCTOR_dot2) { + term_t tleft = PL_new_term_ref(); + PyObject *pArgs, *o; + long i; + int arity; + atom_t name; - o = NULL; - while (fun == FUNCTOR_colon2) { - if (! PL_get_arg(1, t, tleft) ) - return FALSE; - o = find_obj(o, tleft); - if (!o) - return FALSE; - if (! PL_get_arg(2, t, t) ) - return FALSE; - if (!PL_get_functor(t, &fun)) - break; - } - if (! PL_get_name_arity( t, &name, &arity) ) { - return NULL; - } - if (!arity) { - char *s; - PyObject *pValue; + o = NULL; + while (fun == FUNCTOR_dot2) { + if (!PL_get_arg(1, t, tleft)) + return FALSE; + o = find_obj(o, tleft); + if (!o) + return FALSE; + if (!PL_get_arg(2, t, t)) + return FALSE; + if (!PL_get_functor(t, &fun)) + break; + } + if (!PL_get_name_arity(t, &name, &arity)) { + return NULL; + } + if (!arity) { + char *s; + PyObject *pValue; - if (!PL_get_atom_chars(t, &s)) - return NULL; - if ((pValue = PyObject_GetAttrString(o, s)) == NULL) { - PyErr_Print(); - return NULL; - } - return pValue; - } - o = PyObject_GetAttrString(o, PL_atom_chars(name)); - if (!o || ! PyCallable_Check(o)) { - return NULL; - } - pArgs = PyTuple_New(arity); - for (i = 0 ; i < arity; i++) { - PyObject *pArg; - if (! PL_get_arg(i+1, t, tleft) ) - return NULL; - /* ignore (_) */ - if (i == 0 && PL_is_variable(tleft)) { - Py_DECREF(pArgs); - pArgs = NULL; - } - pArg = term_to_python(tleft); - if (pArg == NULL) - return NULL; - /* pArg reference stolen here: */ - PyTuple_SetItem(pArgs, i, pArg); - } - return PyObject_CallObject(o, pArgs); + if (!PL_get_atom_chars(t, &s)) + return NULL; + if ((pValue = PyObject_GetAttrString(o, s)) == NULL) { + PyErr_Print(); + return NULL; + } + return pValue; + } + o = PyObject_GetAttrString(o, PL_atom_chars(name)); + if (!o || !PyCallable_Check(o)) { + return NULL; + } + pArgs = PyTuple_New(arity); + for (i = 0; i < arity; i++) { + PyObject *pArg; + if (!PL_get_arg(i + 1, t, tleft)) + return NULL; + /* ignore (_) */ + if (i == 0 && PL_is_variable(tleft)) { + Py_DECREF(pArgs); + pArgs = NULL; + } + pArg = term_to_python(tleft); + if (pArg == NULL) + return NULL; + /* pArg reference stolen here: */ + PyTuple_SetItem(pArgs, i, pArg); + } + return PyObject_CallObject(o, pArgs); } else { - atom_t name; - int len; + atom_t name; + int len; - if (! PL_get_name_arity( t, &name, &len) ) { - return NULL; - } - if (name == ATOM_t) { - term_t targ = PL_new_term_ref(); - PyObject *out; - int i; + if (!PL_get_name_arity(t, &name, &len)) { + return NULL; + } + if (name == ATOM_t) { + term_t targ = PL_new_term_ref(); + PyObject *out; + int i; - out = PyTuple_New(len); - if (!out) - return NULL; - for (i=0; i< len; i++) { - if (!PL_get_arg(i+1, t, targ)) { - return NULL; - } - if (PyTuple_SetItem(out, i, term_to_python(targ)) < 0) - return NULL; - } - return out; - } + out = PyTuple_New(len); + if (!out) + return NULL; + for (i = 0; i < len; i++) { + if (!PL_get_arg(i + 1, t, targ)) { + return NULL; + } + if (PyTuple_SetItem(out, i, term_to_python(targ)) < 0) + return NULL; + } + return out; + } } } return NULL; @@ -1048,66 +1092,78 @@ term_to_python(term_t t) return NULL; } -static int -assign_python(PyObject *root, term_t t, PyObject *e) -{ +/** + * assign_python assigns the Python RHS to a Prolog term LHS, ie LHS = RHS + * + * @param root Python environment + * @param t left hand side, in Prolog, may be + * - a Prolog variable, exports the term to Prolog, A <- RHS + * - Python variable A, A <- RHS + * - Python variable $A, A <- RHS + * - Python string "A", A <- RHS + * - Python array range + * @param e the right-hand side + * + * @return -1 on failure. + * + * Note that this is an auxiliary routine to the Prolog python_assign. + */ static int assign_python(PyObject *root, term_t t, PyObject *e) { switch (PL_term_type(t)) { case PL_VARIABLE: - return -1; - case PL_ATOM: - { - char *s; - if (!PL_get_atom_chars(t, &s)) { - wchar_t *w; - atom_t at; - size_t len; - PyObject *attr; + if (python_to_ptr(e, t)) + return 1; + else + return -1; + case PL_ATOM: { + char *s; + if (!PL_get_atom_chars(t, &s)) { + wchar_t *w; + atom_t at; + size_t len; + PyObject *attr; - if (!PL_get_atom(t, &at)) { - return -1; - } - if (!(w = PL_atom_wchars(at, &len))) - return -1; - attr = PyUnicode_FromWideChar(w, wcslen(w) ); - if (!attr) - return -1; - return PyObject_SetAttr(py_Main, attr, e); - } - if (proper_ascii_string(s)) { - return PyObject_SetAttrString(py_Main, s, e); - } else { - PyObject *attr= PyUnicode_DecodeLatin1(s, strlen(s), NULL); - if (!attr) - return -1; - return PyObject_SetAttr(py_Main, attr, e); - } - } - break; - case PL_STRING: - { - char *s; - - if (!PL_get_atom_chars(t, &s)) { - wchar_t *w; - atom_t at; - size_t len; - PyObject *wo; - - if (!PL_get_atom(t, &at)) - return -1; - if (!(w = PL_atom_wchars(at, &len))) - return -1; - wo = PyUnicode_FromWideChar(w, wcslen(w) ); - return PyObject_SetAttr(root, wo, e); - } - if (proper_ascii_string(s)) { - return PyObject_SetAttrString(root, s, e); - } else { - PyObject *wo= PyUnicode_DecodeLatin1(s, strlen(s), NULL); - return PyObject_SetAttr(root, wo, e); + if (!PL_get_atom(t, &at)) { + return -1; } + if (!(w = PL_atom_wchars(at, &len))) + return -1; + attr = PyUnicode_FromWideChar(w, wcslen(w)); + if (!attr) + return -1; + return PyObject_SetAttr(py_Main, attr, e); } - break; + if (proper_ascii_string(s)) { + return PyObject_SetAttrString(py_Main, s, e); + } else { + PyObject *attr = PyUnicode_DecodeLatin1(s, strlen(s), NULL); + if (!attr) + return -1; + return PyObject_SetAttr(py_Main, attr, e); + } + } break; + case PL_STRING: { + char *s; + + if (!PL_get_atom_chars(t, &s)) { + wchar_t *w; + atom_t at; + size_t len; + PyObject *wo; + + if (!PL_get_atom(t, &at)) + return -1; + if (!(w = PL_atom_wchars(at, &len))) + return -1; + wo = PyUnicode_FromWideChar(w, wcslen(w)); + return PyObject_SetAttr(root, wo, e); + } + if (proper_ascii_string(s)) { + return PyObject_SetAttrString(root, s, e); + } else { + PyObject *wo = PyUnicode_DecodeLatin1(s, strlen(s), NULL); + return PyObject_SetAttr(root, wo, e); + } + } break; case PL_INTEGER: case PL_FLOAT: return -1; @@ -1118,63 +1174,64 @@ assign_python(PyObject *root, term_t t, PyObject *e) functor_t fun; if (!PL_get_functor(t, &fun)) - return -1; + return -1; if (fun == FUNCTOR_dollar1) { - char *s; + char *s; + if (!PL_get_arg(1, t, t)) + return -1; + if (!PL_get_atom_chars(t, &s)) { + wchar_t *w; + atom_t at; + size_t len; + PyObject *attr; - if (! PL_get_arg(1, t, t) ) - return -1; - if (!PL_get_atom_chars(t, &s)) { - wchar_t *w; - atom_t at; - size_t len; - PyObject *attr; - - if (!PL_get_atom(t, &at)) { - return -1; - } - if (!(w = PL_atom_wchars(at, &len))) - return -1; - attr = PyUnicode_FromWideChar(w, wcslen(w) ); - if (!attr) - return -1; - return PyObject_SetAttr(py_Main, attr, e); - } - if (proper_ascii_string(s)) { - return PyObject_SetAttrString(py_Main, s, e); - } else { - PyObject *attr= PyUnicode_DecodeLatin1(s, strlen(s), NULL); - if (!attr) - return -1; - return PyObject_SetAttr(py_Main, attr, e); - } + if (!PL_get_atom(t, &at)) { + return -1; + } + if (!(w = PL_atom_wchars(at, &len))) + return -1; + attr = PyUnicode_FromWideChar(w, wcslen(w)); + if (!attr) + return -1; + return PyObject_SetAttr(py_Main, attr, e); + } + if (proper_ascii_string(s)) { + return PyObject_SetAttrString(py_Main, s, e); + } else { + PyObject *attr = PyUnicode_DecodeLatin1(s, strlen(s), NULL); + if (!attr) + return -1; + return PyObject_SetAttr(py_Main, attr, e); + } } else if (fun == FUNCTOR_pointer1) { - return -1; - } else if (fun == FUNCTOR_hat2) { - term_t targ = PL_new_term_ref(), trhs = PL_new_term_ref(); - PyObject *lhs, *rhs; + return -1; + } else if (fun == FUNCTOR_colon2) { + term_t targ = PL_new_term_ref(), trhs = PL_new_term_ref(); + PyObject *lhs, *rhs; - if (! PL_get_arg(1, t, targ) ) - return -1; - lhs = term_to_python(targ); - if (! PL_get_arg(2, t, targ) || !PL_is_list(targ) || !PL_get_list(targ, trhs, targ ) ) - return -1; - if (PL_is_functor(trhs, FUNCTOR_colon2) ) { - Py_ssize_t left, right; - if (!PL_get_arg(1, trhs, targ)) - return -1; - left = get_p_int(term_to_python(targ), 0); - if (!PL_get_arg(2, trhs, targ)) - return -1; - right = get_p_int(term_to_python(targ), PyObject_Size(lhs) ); - if (!PySequence_Check(lhs)) - return -1; - return PySequence_SetSlice(lhs, left, right, e); - } else { - rhs = term_to_python(trhs); - return PyObject_SetItem(lhs, rhs, e); - } + if (!PL_get_arg(1, t, targ)) + return -1; + lhs = term_to_python(targ); + if (!PL_get_arg(2, t, targ) || !PL_is_list(targ) || + !PL_get_list(targ, trhs, targ)) + return -1; + if (PL_is_functor(trhs, FUNCTOR_colon2)) { + Py_ssize_t left, right; + if (!PL_get_arg(1, trhs, targ)) + return -1; + left = get_p_int(term_to_python(targ), 0); + if (!PL_get_arg(2, trhs, targ)) + return -1; + right = get_p_int(term_to_python(targ), PyObject_Size(lhs)); + if (!PySequence_Check(lhs)) + return -1; + return PySequence_SetSlice(lhs, left, right, e); + } else { + rhs = term_to_python(trhs); + return PyObject_SetItem(lhs, rhs, e); + } + PL_reset_term_refs(targ); } } return -1; @@ -1182,19 +1239,33 @@ assign_python(PyObject *root, term_t t, PyObject *e) return -1; } -static foreign_t -address_to_term(PyObject *pVal, term_t t) -{ - term_t to = PL_new_term_ref(), t1 = PL_new_term_ref(); - PL_put_pointer(t1, (void *)pVal); - PL_cons_functor(to, FUNCTOR_pointer1, t1); - Py_INCREF(pVal); - return PL_unify(t, to); +static foreign_t address_to_term(PyObject *pVal, term_t t) { + term_t to = PL_new_term_ref(), t1 = PL_new_term_ref(); + PL_put_pointer(t1, (void *)pVal); + PL_cons_functor(to, FUNCTOR_pointer1, t1); + Py_INCREF(pVal); + PL_reset_term_refs(to); + return PL_unify(t, to); } -static foreign_t -python_to_term(PyObject *pVal, term_t t) -{ +static foreign_t repr_term(const char *pVal, size_t sz, term_t t) { + term_t to = PL_new_term_ref(), t1 = PL_new_term_ref(); + PL_put_string_nchars(t1, pVal, sz); + free(pVal); + PL_cons_functor(to, FUNCTOR_pointer1, t1); + Py_INCREF(pVal); + PL_reset_term_refs(to); + return PL_unify(t, to); +} + +static foreign_t python_to_ptr(PyObject *pVal, term_t t) { + return address_to_term(pVal, t); +} + +static foreign_t python_to_term(PyObject *pVal, term_t t) { + if (pVal == Py_None) { + return PL_unify_atom(t, ATOM_none); + } if (PyBool_Check(pVal)) { if (PyObject_IsTrue(pVal)) { return PL_unify_atom(t, ATOM_true); @@ -1210,23 +1281,29 @@ python_to_term(PyObject *pVal, term_t t) } else if (PyFloat_Check(pVal)) { return PL_unify_float(t, PyFloat_AsDouble(pVal)); } else if (PyComplex_Check(pVal)) { - term_t to = PL_new_term_ref(), t1= PL_new_term_ref(), t2 = PL_new_term_ref(); - if (!PL_put_float(t1, PyComplex_RealAsDouble(pVal) ) || - !PL_put_float(t2, PyComplex_ImagAsDouble(pVal) ) || - !PL_cons_functor(to, FUNCTOR_complex2, t1, t2) ) - return FALSE; - return PL_unify(t, to); + bool rc; + term_t to = PL_new_term_ref(), t1 = PL_new_term_ref(), + t2 = PL_new_term_ref(); + if (!PL_put_float(t1, PyComplex_RealAsDouble(pVal)) || + !PL_put_float(t2, PyComplex_ImagAsDouble(pVal)) || + !PL_cons_functor(to, FUNCTOR_complex2, t1, t2)) { + rc = FALSE; + } else { + rc = PL_unify(t, to); + } + PL_reset_term_refs(to); + return rc; } else if (PyUnicode_Check(pVal)) { atom_t tmp_atom; #if PY_MAJOR_VERSION < 3 - Py_ssize_t sz = PyUnicode_GetSize(pVal)+1; - wchar_t *ptr = malloc(sizeof(wchar_t)*sz); - sz = PyUnicode_AsWideChar((PyUnicodeObject *)pVal, ptr, sz-1); + Py_ssize_t sz = PyUnicode_GetSize(pVal) + 1; + wchar_t *ptr = malloc(sizeof(wchar_t) * sz); + sz = PyUnicode_AsWideChar((PyUnicodeObject *)pVal, ptr, sz - 1); #else - Py_ssize_t sz = PyUnicode_GetLength(pVal)+1; - wchar_t *ptr = malloc(sizeof(wchar_t)*sz); - sz = PyUnicode_AsWideChar(pVal, ptr, sz); + Py_ssize_t sz = PyUnicode_GetLength(pVal) + 1; + wchar_t *ptr = malloc(sizeof(wchar_t) * sz); + sz = PyUnicode_AsWideChar(pVal, ptr, sz); #endif tmp_atom = PL_new_atom_wchars(sz, ptr); free(ptr); @@ -1246,10 +1323,10 @@ python_to_term(PyObject *pVal, term_t t) return FALSE; for (i = 0; i < sz; i++) { term_t to = PL_new_term_ref(); - if (!PL_unify_arg(i+1, t, to)) - return FALSE; - if ( !python_to_term(PyTuple_GetItem(pVal, i), to) ) - return FALSE; + if (!PL_unify_arg(i + 1, t, to)) + return FALSE; + if (!python_to_ptr(PyTuple_GetItem(pVal, i), to)) + return FALSE; } return TRUE; } else if (PyList_Check(pVal)) { @@ -1258,8 +1335,8 @@ python_to_term(PyObject *pVal, term_t t) for (i = 0; i < sz; i++) { if (!PL_unify_list(t, to, t) || - !python_to_term(PyList_GetItem(pVal, i), to)) - return FALSE; + !python_to_term(PyList_GetItem(pVal, i), to)) + return FALSE; } return PL_unify_nil(t); } else if (PyDict_Check(pVal)) { @@ -1269,48 +1346,88 @@ python_to_term(PyObject *pVal, term_t t) PyObject *key, *value; while (PyDict_Next(pVal, &pos, &key, &value)) { - term_t tkey = PL_new_term_ref(), tval = PL_new_term_ref(), tint, tnew = PL_new_term_ref(); + term_t tkey = PL_new_term_ref(), tval = PL_new_term_ref(), tint, + tnew = PL_new_term_ref(); /* do something interesting with the values... */ if (!python_to_term(key, tkey)) { - return FALSE; + return FALSE; } if (!python_to_term(value, tval)) { - return FALSE; + return FALSE; } /* reuse */ tint = tkey; if (!PL_cons_functor(tint, FUNCTOR_colon2, tkey, tval)) { - return FALSE; + return FALSE; } if (--left) { - if (!PL_cons_functor(tint, FUNCTOR_comma2, tint, tnew)) - return FALSE; + if (!PL_cons_functor(tint, FUNCTOR_comma2, tint, tnew)) + return FALSE; } if (!PL_unify(ti, tint)) - return FALSE; + return FALSE; ti = tnew; } PL_cons_functor(to, FUNCTOR_curly1, to); return PL_unify(t, to); } else { - return address_to_term(pVal, t); + char *s; + PyObject *pValR = PyObject_Repr(pVal); + if (pValR == NULL) + return address_to_term(pVal, t); +#if PY_MAJOR_VERSION < 3 + Py_ssize_t sz = PyUnicode_GetSize(pValR) + 1; + PyObject *us = PyUnicode_EncodeUTF8((PyUnicodeObject *)pValR, s, NULL); +#else + Py_ssize_t sz = PyUnicode_GetLength(pVal) + 1; + s = malloc(sizeof(char) * sz); + PyObject *obj = PyUnicode_AsUTF8Char(pVal, ptr, sz); + PyString_AsStringAndSize(obj, &s & sz) +#endif + + return repr_term(s, sz, t); } } -static int -python_import(term_t mname, term_t mod) -{ +static foreign_t python_export(term_t t, term_t pl) { + if (PL_is_functor(t, FUNCTOR_pointer1)) { + void *ptr; + term_t targ = PL_new_term_ref(); + + if (!PL_get_arg(1, t, targ)) + return false; + if (!PL_get_pointer(targ, &ptr)) + return false; + Py_INCREF((PyObject *)ptr); + /* return __main__,s */ + return python_to_term((PyObject *)ptr, pl); + } + return false; +} +static int python_import(term_t mname, term_t mod) { char *s; size_t len; PyObject *pName, *pModule; - if ( !PL_get_nchars(mname, &len, &s, CVT_ALL|CVT_EXCEPTION) ) { + if (PL_is_list(mname)) { + char *s2; + char str[256]; + term_t arg = PL_new_term_ref(); + if (!PL_get_arg(1, mname, arg) || !PL_get_atom_chars(arg, &s) || + !PL_get_arg(2, mname, mname) || !PL_get_arg(1, mname, arg) || + !PL_get_atom_chars(arg, &s2)) + return FALSE; + strcpy(str, s); + strcat(str, "."); + strcat(str, s2); + s = str; + } else if (!PL_get_nchars(mname, &len, &s, CVT_ALL | CVT_EXCEPTION)) { return FALSE; } #if PY_MAJOR_VERSION < 3 pName = PyString_FromString(s); #else - pName = PyUnicode_FromString(s); + pName = PyUnicode_FromString(s); #endif if (pName == NULL) { return FALSE; @@ -1318,33 +1435,31 @@ python_import(term_t mname, term_t mod) pModule = PyImport_Import(pName); Py_DECREF(pName); if (pModule == NULL) { - if (PyErr_Occurred()) - PyErr_Print(); + // if (PyErr_Occurred()) + // PyErr_Print(); PyErr_Clear(); return FALSE; } ActiveModules[active_modules++] = pModule; - return python_to_term(pModule, mod); + return python_to_ptr(pModule, mod); } -static foreign_t -python_f(term_t tmod, term_t fname, term_t tf) -{ +static foreign_t python_f(term_t tmod, term_t fname, term_t tf) { char *s; size_t len; PyObject *pF, *pModule; /* if an atom, fetch again */ - if ( PL_is_atom(tmod) ) { + if (PL_is_atom(tmod)) { PyObject *pName; - if ( !PL_get_nchars(fname, &len, &s, CVT_ALL|CVT_EXCEPTION) ) { + if (!PL_get_nchars(fname, &len, &s, CVT_ALL | CVT_EXCEPTION)) { return FALSE; } #if PY_MAJOR_VERSION < 3 pName = PyString_FromString(s); #else - pName = PyUnicode_FromString(s); + pName = PyUnicode_FromString(s); #endif if (pName == NULL) { return FALSE; @@ -1352,39 +1467,35 @@ python_f(term_t tmod, term_t fname, term_t tf) pModule = PyImport_Import(pName); } else if (!(pModule = term_to_python(tmod))) return FALSE; - if ( !PL_get_nchars(fname, &len, &s, CVT_ALL|CVT_EXCEPTION) ) { + if (!PL_get_nchars(fname, &len, &s, CVT_ALL | CVT_EXCEPTION)) { return FALSE; } pF = PyObject_GetAttrString(pModule, s); PyErr_Print(); Py_DECREF(pModule); - if (pF == NULL || ! PyCallable_Check(pF)) { + if (pF == NULL || !PyCallable_Check(pF)) { return FALSE; } - return python_to_term(pF, tf); + return python_to_ptr(pF, tf); } -static foreign_t -python_o(term_t tmod, term_t fname, term_t tf) -{ +static foreign_t python_o(term_t tmod, term_t fname, term_t tf) { char *s; size_t len; PyObject *pO, *pModule; pModule = term_to_python(tmod); - if ( !PL_get_nchars(fname, &len, &s, CVT_ALL|CVT_EXCEPTION) ) { + if (!PL_get_nchars(fname, &len, &s, CVT_ALL | CVT_EXCEPTION)) { return FALSE; } pO = PyObject_GetAttrString(pModule, s); if (pO == NULL) { return FALSE; } - return python_to_term(pO, tf); + return python_to_ptr(pO, tf); } -static foreign_t -python_len(term_t tobj, term_t tf) -{ +static foreign_t python_len(term_t tobj, term_t tf) { Py_ssize_t len; PyObject *o; @@ -1395,9 +1506,7 @@ python_len(term_t tobj, term_t tf) return PL_unify_int64(tf, len); } -static foreign_t -python_dir(term_t tobj, term_t tf) -{ +static foreign_t python_dir(term_t tobj, term_t tf) { PyObject *dir; PyObject *o; @@ -1405,23 +1514,36 @@ python_dir(term_t tobj, term_t tf) if (o == NULL) return FALSE; dir = PyObject_Dir(o); - return python_to_term(dir, tf); + return python_to_ptr(dir, tf); } -static foreign_t -python_is(term_t tobj, term_t tf) -{ +static foreign_t python_index(term_t tobj, term_t tindex, term_t val) { + PyObject *i; + PyObject *o; + PyObject *f; + o = term_to_python(tobj); + if (o == NULL) + return false; + if (!PySequence_Check(o)) + return false; + i = term_to_python(tindex); + if (i == NULL) + return false; + f = PyObject_CallMethodObjArgs(o, PyString_FromString("getitem"), i); + return python_to_ptr(f, val); +} + +static foreign_t python_is(term_t tobj, term_t tf) { PyObject *o; o = term_to_python(tobj); if (!o) return FALSE; - return python_to_term(o, tf); + return python_to_ptr(o, tf); } -static foreign_t -python_apply(term_t tin, term_t targs, term_t keywds, term_t tf) -{ +static foreign_t python_apply(term_t tin, term_t targs, term_t keywds, + term_t tf) { PyObject *pF, *pValue; PyObject *pArgs, *pKeywords; int i, arity; @@ -1429,74 +1551,55 @@ python_apply(term_t tin, term_t targs, term_t keywds, term_t tf) foreign_t out; term_t targ = PL_new_term_ref(); - pF = term_t - - - - - - - - - - - - - - - - - - - 'o_python(tin); - if ( pF == NULL ) { - PYError() - return FALSE; + pF = term_to_python(tin); + if (pF == NULL) { + return false; } - if (PL_is_atom(keywds) ) - pKeywords = NULL; - else - pKeywords = term_to_python(keywds); - if (! PL_get_name_arity( targs, &aname, &arity) ) { - return FALSE; - } - if (aname == ATOM_t) { - if (arity == 0) - pArgs = NULL; - else - pArgs = term_to_python( targs ); + if (PL_is_atom(targs)) { + pArgs = NULL; } else { - pArgs = PyTuple_New(arity); - if (!pArgs) + + if (PL_is_atom(keywds)) { + pKeywords = NULL; + } else { + pKeywords = term_to_python(keywds); + } + if (!PL_get_name_arity(targs, &aname, &arity)) { return FALSE; - for (i = 0 ; i < arity; i++) { - PyObject *pArg; - if (! PL_get_arg(i+1, targs, targ) ) - return FALSE; - /* ignore (_) */ - if (i == 0 && PL_is_variable(targ)) { - Py_DECREF(pArgs); - pArgs = NULL; - break; + } + if (aname == ATOM_t) { + pArgs = term_to_python(targs); + } else { + pArgs = PyTuple_New(arity); + if (!pArgs) + return FALSE; + for (i = 0; i < arity; i++) { + PyObject *pArg; + if (!PL_get_arg(i + 1, targs, targ)) + return FALSE; + /* ignore (_) */ + if (i == 0 && PL_is_variable(targ)) { + Py_DECREF(pArgs); + pArgs = NULL; + break; + } + pArg = term_to_python(targ); + if (pArg == NULL) + return FALSE; + /* pArg reference stolen here: */ + PyTuple_SetItem(pArgs, i, pArg); } - pArg = term_to_python(targ); - if (pArg == NULL) - return FALSE; - /* pArg reference stolen here: */ - PyTuple_SetItem(pArgs, i, pArg); } } if (PyCallable_Check(pF)) { - if (!pKeywords) - pValue = PyObject_CallObject(pF, pArgs); - else { - pValue = PyObject_Call(pF, pArgs, pKeywords); - // PyObject_Print(pF,stderr,0);fprintf(stderr, "\n"); - //PyObject_Print(pArgs,stderr,0);fprintf(stderr, " "); - //PyObject_Print(pKeywords,stderr,0);fprintf(stderr, "\n"); - } + pValue = PyEval_CallObjectWithKeywords(pF, pArgs, pKeywords); + // PyObject_Print(pF,stderr,0);fprintf(stderr, "\n"); + // PyObject_Print(pArgs,stderr,0);fprintf(stderr, " "); + // PyObject_Print(pKeywords,stderr,0);fprintf(stderr, "\n"); if (!pValue) PyErr_Print(); + } else if (pArgs == NULL) { + pValue = pF; } else { PyErr_Print(); return FALSE; @@ -1505,15 +1608,13 @@ python_apply(term_t tin, term_t targs, term_t keywds, term_t tf) Py_DECREF(pArgs); Py_DECREF(pF); if (pValue == NULL) - return FALSE; - out = python_to_term(pValue, tf); + return FALSE; + out = python_to_ptr(pValue, tf); Py_DECREF(pValue); return out; } -static foreign_t -python_assign(term_t name, term_t exp) -{ +static foreign_t python_assign(term_t name, term_t exp) { PyObject *e = term_to_python(exp); if (e == NULL) @@ -1521,9 +1622,7 @@ python_assign(term_t name, term_t exp) return assign_python(py_Main, name, e) >= 0; } -static foreign_t -python_access(term_t obj, term_t f, term_t out) -{ +static foreign_t python_access(term_t obj, term_t f, term_t out) { PyObject *o = term_to_python(obj), *pValue, *pArgs, *pF; atom_t name; char *s; @@ -1531,17 +1630,17 @@ python_access(term_t obj, term_t f, term_t out) term_t targ = PL_new_term_ref(); if (o == NULL) - return FALSE; - if ( PL_is_atom(f) ) { + return false; + if (PL_is_atom(f)) { if (!PL_get_atom_chars(f, &s)) - return FALSE; + return false; if ((pValue = PyObject_GetAttrString(o, s)) == NULL) { PyErr_Print(); - return FALSE; + return false; } - return python_to_term(pValue, out); + return python_to_ptr(pValue, out); } - if (! PL_get_name_arity( f, &name, &arity) ) { + if (!PL_get_name_arity(f, &name, &arity)) { return FALSE; } /* follow chains of the form a.b.c.d.e() */ @@ -1549,16 +1648,16 @@ python_access(term_t obj, term_t f, term_t out) term_t tleft = PL_new_term_ref(); PyObject *lhs; - if (! PL_get_arg(1, f, tleft) ) + if (!PL_get_arg(1, f, tleft)) return FALSE; lhs = term_to_python(tleft); if ((o = PyObject_GetAttr(o, lhs)) == NULL) { PyErr_Print(); return FALSE; } - if (! PL_get_arg(2, f, f) ) + if (!PL_get_arg(2, f, f)) return FALSE; - if (! PL_get_name_arity( f, &name, &arity) ) { + if (!PL_get_name_arity(f, &name, &arity)) { return FALSE; } } @@ -1568,9 +1667,9 @@ python_access(term_t obj, term_t f, term_t out) return FALSE; } pArgs = PyTuple_New(arity); - for (i = 0 ; i < arity; i++) { + for (i = 0; i < arity; i++) { PyObject *pArg; - if (! PL_get_arg(i+1, f, targ) ) + if (!PL_get_arg(i + 1, f, targ)) return FALSE; /* ignore (_) */ if (i == 0 && PL_is_variable(targ)) { @@ -1581,7 +1680,7 @@ python_access(term_t obj, term_t f, term_t out) if (pArg == NULL) return FALSE; /* pArg reference stolen here: */ - PyTuple_SetItem(pArgs, i, pArg); + PyTuple_SetItem(pArgs, i, pArg); } pValue = PyObject_CallObject(pF, pArgs); if (pValue == NULL) { @@ -1591,76 +1690,61 @@ python_access(term_t obj, term_t f, term_t out) } Py_DECREF(pArgs); Py_DECREF(pF); - return python_to_term(pValue, out); + return python_to_ptr(pValue, out); } -static foreign_t -python_field(term_t f, term_t tobj, term_t tname, term_t tout) -{ - PyObject *o = NULL, *pF; +static foreign_t python_field(term_t parent, term_t att, term_t tobj) { + PyObject *pF; atom_t name; char *s; int arity; - if (! PL_get_name_arity( f, &name, &arity) ) { - return FALSE; - } - /* follow chains of the form a.b.c.d.e() */ - while (name == ATOM_colon && arity == 2) { - term_t tleft = PL_new_term_ref(); - PyObject *lhs; + if (!PL_get_name_arity(att, &name, &arity)) { + return false; + } else { + PyObject *p; - if (! PL_get_arg(1, f, tleft) ) - return FALSE; - lhs = term_to_python(tleft); - if (o == NULL) { - o = lhs; - } else if ((o = PyObject_GetAttr(o, lhs)) == NULL) { - // PyErr_Print(); + // got Scope.Exp + // get Scope ... + p = term_to_python(parent); + // Exp + if (!PL_get_name_arity(att, &name, &arity)) { + return false; + } + s = PL_atom_chars(name); + if (arity == 1 && !strcmp(s, "()")) { + if (!PL_get_arg(1, att, att)) + return false; + if (!PL_get_name_arity(att, &name, &arity)) { + return false; + } + s = PL_atom_chars(name); + } + if (!s || !p) { + return false; + } else if ((pF = PyObject_GetAttrString(p, s)) == NULL) { PyErr_Clear(); return FALSE; } - if (! PL_get_arg(2, f, f) ) - return FALSE; - if (! PL_get_name_arity( f, &name, &arity) ) { - return FALSE; - } } - s = PL_atom_chars(name); - if (!s || !o) { - return FALSE; - } else if ((pF = PyObject_GetAttrString(o, s)) == NULL) { - // PyErr_Print(); - PyErr_Clear(); - return FALSE; - } - return - address_to_term(pF, tobj) && - PL_unify_atom(tname, name) && - PL_unify(tout, f); + return address_to_term(pF, tobj); } -static foreign_t -python_main_module(term_t mod) -{ +static foreign_t python_main_module(term_t mod) { return address_to_term(py_Main, mod); } -static foreign_t -python_function(term_t tobj) -{ +static foreign_t python_function(term_t tobj) { PyObject *obj = term_to_python(tobj); return PyFunction_Check(obj); } -static foreign_t -python_run_command(term_t cmd) -{ +static foreign_t python_run_command(term_t cmd) { char *s; size_t len; - if ( PL_get_nchars(cmd, &len, &s, CVT_ALL|CVT_EXCEPTION) ) { + if (PL_get_nchars(cmd, &len, &s, CVT_ALL | CVT_EXCEPTION)) { PyRun_SimpleString(s); return TRUE; @@ -1668,18 +1752,14 @@ python_run_command(term_t cmd) return FALSE; } -static foreign_t -init_python(void) -{ +static foreign_t init_python(void) { Py_Initialize(); - py_Main = PyImport_AddModule("__main__"); + py_Main = PyImport_AddModule("__main__"); return TRUE; } -static foreign_t -end_python(void) -{ +static foreign_t end_python(void) { Py_Finalize(); return TRUE; @@ -1687,14 +1767,15 @@ end_python(void) install_t install_libpython(void); -install_t -install_libpython(void) -{ // FUNCTOR_dot2 = PL_new_functor(PL_new_atom("."), 2); +install_t install_libpython(void) { + FUNCTOR_dot2 = PL_new_functor(PL_new_atom("."), 2); // FUNCTOR_equal2 = PL_new_functor(PL_new_atom("="), 2); // FUNCTOR_boolop1 = PL_new_functor(PL_new_atom("@"), 1); ATOM_colon = PL_new_atom(":"); - ATOM_true = PL_new_atom("true"); + ATOM_true = PL_new_atom("true"); ATOM_false = PL_new_atom("false"); + ATOM_dot = PL_new_atom("."); + ATOM_none = PL_new_atom("none"); ATOM_t = PL_new_atom("t"); FUNCTOR_abs1 = PL_new_functor(PL_new_atom("abs"), 1); FUNCTOR_all1 = PL_new_functor(PL_new_atom("all"), 1); @@ -1724,20 +1805,23 @@ install_libpython(void) FUNCTOR_colon2 = 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_sqbrackets2 = PL_new_functor(PL_new_atom("[]"), 2); - PL_register_foreign("init_python", 0, init_python, 0); - PL_register_foreign("end_python", 0, end_python, 0); - PL_register_foreign("python_import", 2, python_import, 0); - PL_register_foreign("python_f", 3, python_f, 0); - PL_register_foreign("python_o", 3, python_o, 0); - PL_register_foreign("python_len", 2, python_len, 0); - PL_register_foreign("python_is", 2, python_is, 0); - PL_register_foreign("python_dir", 2, python_dir, 0); - PL_register_foreign("python_apply", 4, python_apply, 0); - PL_register_foreign("python_access", 3, python_access, 0); - PL_register_foreign("python_field", 4, python_field, 0); - PL_register_foreign("python_assign", 2, python_assign, 0); - PL_register_foreign("python_function", 1, python_function, 0); - PL_register_foreign("python_run_command", 1, python_run_command, 0); - PL_register_foreign("python_main_module", 1, python_main_module, 0); + PL_register_foreign("init_python", 0, init_python, 0); + PL_register_foreign("end_python", 0, end_python, 0); + PL_register_foreign("python_import", 2, python_import, 0); + PL_register_foreign("python_f", 3, python_f, 0); + PL_register_foreign("python_o", 3, python_o, 0); + PL_register_foreign("python_len", 2, python_len, 0); + PL_register_foreign("python_is", 2, python_is, 0); + PL_register_foreign("python_dir", 2, python_dir, 0); + PL_register_foreign("python_apply", 4, python_apply, 0); + PL_register_foreign("python_index", 3, python_index, 0); + PL_register_foreign("python_access", 3, python_access, 0); + PL_register_foreign("python_field", 3, python_field, 0); + PL_register_foreign("python_assign", 2, python_assign, 0); + PL_register_foreign("python_export", 2, python_export, 0); + PL_register_foreign("python_function", 1, python_function, 0); + PL_register_foreign("python_run_command", 1, python_run_command, 0); + PL_register_foreign("python_main_module", 1, python_main_module, 0); } diff --git a/packages/python/python.pl b/packages/python/python.pl index 06e35a2f6..e4badb5aa 100644 --- a/packages/python/python.pl +++ b/packages/python/python.pl @@ -1,4 +1,4 @@ -%%% -*- Mode: Prolog; -*- +% % % -* - Mode : Prolog; -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Author: Vitor Santos Costa % E-mail: vsc@dcc.fc.up.pt @@ -56,10 +56,25 @@ To best define the interface, one has to address two opposite goals: - make all embedded language interfaces (python, R, Java) as similar as possible. - Currently, YAP supports the following translation: + YAP supports the following translation between Prolog and Python: - - numbers -> identical - -> +| *Prolog* | *Pyhon* | *Prolog Examples* | +|:-------------:|:-------------:|---------------------------------------:| +| Numbers | Numbers | 2.3 +| | | 1545 +| | | +| Atom | Symbols | var +| $Atom | | $var [ = var] +| `string` | 'string' | \`hello\` +| "string" | ' | "hello" +| | | +| Atom(...) | Symb(...) | f( a, b, named=v) +| E.F(...) | E.F (...) | mod.f( a) [ = [mod\|f(a)] ] +| Atom() | | f() [ = '()'(f) ] +| Lists | Lists | [1,2,3] +| t(....) | Tuples | t(1,2,3) to (1,2,3) +| (..., ...) | | (1,2,3)[ = (1,(2,3))] +| {.=., .=.} | Dict | {\`one\`: 1, \`two\`: 2, \`three\`: 3} */ @@ -93,13 +108,20 @@ Data types are := F :- python(F,_). V := F :- var(V), !, python(F,V). -A := F :- python(F, F1), python_assign(A, F1). +A := F :- + python(F, F1), + python_lhs(A, A1), + python_assign(A1, F1, _). user:( V <- F ) :- - V := F. + var(V), !, + V0 := F, + python_export(V0,V). +user:( V <- F ) :- + V := F. user:((<- F)) :- - <- F. + python( F, _). python_import(Module) :- python_do_import(Module, _). @@ -107,54 +129,38 @@ python_import(Module) :- python_do_import(Module, MRef) :- python_mref_cache(Module, MRef), !. python_do_import(Module, MRef) :- - python_import(Module, MRef), + python_import(Module, MRef), assert( python_mref_cache(Module, MRef) ). -fetch_module(M:E, M1, E1, MRef) :- +fetch_module(M:E, _M1, E, MRef) :- atom(M), - python_import(M, MRef0), - module_extend(M, E, M1, E1, MRef0, MRef). - -% -% extend the module as much as we can. -% -module_extend(M0, M:E, MF, EF, _MRef0, MRef) :- - atom(M), - atom_concat([M0,'.',M], MM), - python_import(MM, MRef1), !, - module_extend(MM, E, MF, EF, MRef1, MRef). -module_extend(M0, M.E, MF, EF, _MRef0, MRef) :- - MM = M0.M, - python_import(MM, MRef1), !, - module_extend(MM, E, MF, EF, MRef1, MRef). -module_extend(M, E, M, E, MRef, MRef). - -object_prefix('__obj__'(_)). -object_prefix('$'(_)). -object_prefix('__obj__'(_):_). -object_prefix('$'(_):_). -object_prefix('__obj__'(_)._). -object_prefix('$'(_)._). + python_import(M, MRef). % from an exp take an object, and its corresponding Prolog representation -descend_exp(V, _Obj, _F, _S) :- +descend_exp(V, _Obj) :- var(V), !, throw(error(instantiation_error,_)). -descend_exp(Exp, Obj, F, S) :- - object_prefix(Exp), - !, - python_field(Exp, Obj, F, S). -descend_exp(Exp, Obj, F, S) :- - python_mref_cache(_, MObj), - python_field(MObj:Exp, Obj, F, S), !. -descend_exp(Mod:Exp, Obj, F, S) :- +descend_exp(Mod.Exp, Obj) :- atom(Mod), python_import(Mod, MObj), - python_field(MObj:Exp, Obj, F, S), !. -descend_exp(Mod.Exp, Obj, F, S) :- - atom(Mod), - python_import(Mod, MObj), - python_field(MObj:Exp, Obj, F, S), !. + !, + descend_exp(MObj.Exp, Obj). +descend_exp(C1.C2.E, Obj) :- !, + python_eval_term(C1, O1), + python_field(O1, C2, Obj0 ), + descend_exp(Obj0.E, Obj). +descend_exp(Exp, Obj) :- + fail, + python_mref_cache(_, MObj), + python_field(MObj, Exp, Obj), !. +descend_exp(C1.E, Obj) :- + !, + python_eval_term(C1, O1), + python_field(O1, E, Obj0 ), + python_check_args(E, NE, Dict), + python_apply(Obj0, NE, Dict, Obj). +descend_exp(C, O) :- + python_is(C, O). python_class(Obj) :- python_obj_cache(inspect:isclass(_), F), @@ -164,32 +170,81 @@ process_obj(Obj, _, S, Obj, NS, Dict) :- python_callable(Obj), !, python_check_args(S, NS, Dict). process_obj(Obj, _, S, FObj, NS, Dict) :- - python_class(Obj), + descend_object(Obj:'__init__', FObj, _, _), descend_object(Obj:'__init__', FObj, _, _), python_check_args(S, NS, Dict). +%% @pred python_eval_term( + Obj, -Obj) is semi-det +% It implements the Python interprter's evaluation loop. +% python_eval_term(Obj, Obj) :- - var(Obj), !. + var(Obj), !, + throw(error(instantiation_error, Obj) ). + %% atom use basic evaluation of an atom + %% check if a variable. +python_eval_term(Name, Obj) :- + atom(Name), + !, + python_is(Name, Obj). + %% numbers are evaluated +python_eval_term(N, N) :- number(N), !. +python_eval_term(N, N) :- string(N), !. +%% we assume objects are so yoo. python_eval_term('__obj__'(Obj), '__obj__'(Obj)) :- !. +%% constant functions are useful. +python_eval_term('()'(X), NX) :- !, + python_eval_term(X, NX). +%% $ -> compatibilty with older versions python_eval_term($Name, Obj) :- !, - python_is($Name, Obj). + python_is(Name, Obj). + %% lists are collections of individuals + %% that may need futrher processing python_eval_term([H|T], NL) :- is_list(T), !, maplist( python_eval_term, [H|T], NL). -python_eval_term(N, N) :- atomic(N), !. -python_eval_term(N, N) :- string(N), !. -python_eval_term(Exp, O) :- - descend_exp(Exp, Obj, _Old, S), !, - (functor(S, _, 0) -> - O = Obj - ; - python_check_args(S, NS, Dict), - python_apply(Obj, NS, Dict, O) - ). -python_eval_term(S, O) :- - python_check_args(S, NS, {}), - python_is(NS, O). + %% array access, Python understands numeric + % indices and slices. +python_eval_term(Exp[Min:Max:Step], NEl) :- !, + python_eval_term(slice(Min,Max,Step), Slice), python_eval_term(Exp.getitem(Slice), NEl). +python_eval_term(Exp[Min:Max], NEl) :- !, + python_eval_term(slice(Min,Max), Slice), + python_eval_term(Exp.getitem(Slice), NEl). +python_eval_term(Exp[Index], O) :- !, + python_eval_term(Exp.getitem(Index),O ). +python_eval_term(Tuple, O) :- + Tuple =.. [t|TupleL], !, + maplist(python_eval_term, TupleL, OL), + O =.. [t|OL]. +% function or method call of the form +% a.b.f(...) +python_eval_term(Inp.Exp, Obj) :- !, + %flatten_exp(Exp, Exp1, []), + descend_exp(Inp.Exp, Obj). +python_eval_term(Exp, Obj) :- + p_is(Exp, Obj). + +flatten_exp( V , V, V0) :- + V0 == [], + var( V ), + !. +flatten_exp( V1 ) --> + { var( V1 ) }, + !, + [V1]. +flatten_exp( (V1.V2) ) --> + !, + flatten_exp( V1 ), % propagte the RHS first. + flatten_exp( V2 ). +flatten_exp( V1() ) --> + !, + flatten_exp( V1 ). +flatten_exp( V1, V1, V0 ) :- V0 == [], !. +flatten_exp( V1 ) --> + [V1]. + +python_check_args(_Exp(), t, {}) :- + !. python_check_args(Exp, t, {}) :- Exp =.. [_,V], var(V), !. python_check_args(Exp, NExp, Dict) :- @@ -203,6 +258,14 @@ python_check_args(Exp, NExp, {}) :- maplist(python_eval_term, L, LF), NExp =.. [F|LF]. +python_build_tuple(V) --> + {var(V) }, !, + [V]. +python_build_tuple((X,Y)) --> !, + python_build_tuple(X), + python_build_tuple(Y). +python_build_tuple(X) --> [X]. + % in case it is __init__ from __new__ splice_class(Ref, Ref, ArgNames, ArgNames) :- !. splice_class(_FRef, _Ref, [_|ArgNames], ArgNames). @@ -244,6 +307,28 @@ python(Obj, Out) :- python_command(Cmd) :- python_run_command(Cmd). +python_lhs(Obj,Obj) :- + var(Obj), !. +python_lhs(Name,Name) :- + atom(Name), !. +python_lhs(N, N) :- + number(N), !, + throw(error(type(evaluable, N)), "in left-hand-side of s"). +python_lhs(N) :- + string(N), !, + throw(error(type(evaluable, N)), "in left-hand-side of s"). +python_lhs('__obj__'(Obj), '__obj__'(Obj)) :- !. +python_lhs($Name, Name) :- + !. +python_lhs([H|T], NL) :- + is_list(T), !, + maplist( python_lhs, [H|T], NL). +python_lhs((Exp1,Exp2), O) :- !, + python_build_tuple((Exp1,Exp2), TupleL, []), + Tuple =.. [t|TupleL], % <<< + python_lhs( Tuple, O). +python_lhs(F, F). + start_python :- init_python, python_main_module(MRef), @@ -251,9 +336,9 @@ start_python :- python_command('import sys'), python_import('inspect'), python_mref_cache(inspect, InspRef), - python_field(InspRef:isclass(_), IsClass, _, _), + python_field(InspRef, isclass(_), IsClass), assert(python_obj_cache(inspect:isclass(_), IsClass)), - python_field(InspRef:getargspec(_), GetArgSpec, _, _), + python_field(InspRef, getargspec(_), GetArgSpec), assert(python_obj_cache(inspect:getargspec(_), GetArgSpec)), at_halt(end_python). @@ -264,11 +349,13 @@ add_cwd_to_python :- python_command("sys.argv = [\"yap\"]"). % done -python_assign(Name, Exp, '$'(Name)) :- +python_assign(Name, Exp, N) :- + Name =.. [N,A|As], + Exp =.. [N,E|Es], !, + maplist( python_assign,[A|As], [E|Es]). +python_assign(Name, Exp, Name) :- python_assign(Name, Exp). :- initialization( use_foreign_library(foreign(libpython)), now ). -:- initialization(start_python, now). - -:- initialization(add_cwd_to_python). +:- initialization(start_python ).