diff options
Diffstat (limited to 'guiletopy.c')
| -rw-r--r-- | guiletopy.c | 1141 |
1 files changed, 1141 insertions, 0 deletions
diff --git a/guiletopy.c b/guiletopy.c new file mode 100644 index 0000000..967dffc --- /dev/null +++ b/guiletopy.c @@ -0,0 +1,1141 @@ +// guiletopy functions +// Functions for conversion from Guile SCMs into PyObjects. +// +//////////////////////////////////////////////////////////////////////// +// +// Copyright (C) 2008 Omer Zak. +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this library, in a file named COPYING; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place, Suite 330, +// Boston, MA 02111-1307 USA +// +// For licensing issues, contact <w1@zak.co.il>. +// +//////////////////////////////////////////////////////////////////////// +//#include <Python.h> // included in guiletopy.h +//#include <libguile.h> // included in guiletopy.h +#include "guiletopy.h" +#include "pysmob.h" +#include <guile/gh.h> +#include "g2p2g_smob.h" // used in guiletopy.inc +#include "verbose.h" +#include "pyscm.h" + +//////////////////////////////////////////////////////////////////////// +// +// VERBOSITY HANDLING CONVENTIONS: +// +// PYGUILE_VERBOSE_G2P2G_SUCCESSFUL is tested whenever conversion in +// a primitive data type conversion function (g2p*) is successful. +// This condition is intended to capture all successful conversions +// of primitive values. +// +// PYGUILE_VERBOSE_G2P2G_ALWAYS is tested in all conversion failures +// and also when successfully converting aggregate data structures +// (such as Tuples, Lists and Dicts). It is intended to provide +// detailed trace of operation of the conversion functions. +// +//////////////////////////////////////////////////////////////////////// +// Convert data from Guile (SCM) representation into Python +// representation +//////////////////////////////////////////////////////////////////////// + +// The following functions convert each a single data type. +// They have to be efficient. +// The interface conventions are: +// 1. The function gets a single SCM argument, and upon +// success - returns a single PyObject, which has already +// been Py_INCREF()-ed. +// 2. The function is responsible for checking the data type of +// and whether the value of its argument is in range. +// If any of them fails, the function returns NULL. +// NOTE: no error is raised with the NULL return (unlike the +// usual convention in Python code). +// 3. If there is any error not associated with wrong data type +// of its argument, the function throws a scm exception. +// 4. Naming convention: +// g2p_{Guile datatype name}2{Python datatype name} +// The reason for (2),(3) above is that those functions are +// intended to be called one after one, until one of them +// succeeds in converting a data item. + +//////////////////////// general template handling ///////////////////// + +// Apply a template to sobj. +// The template consists of pair of g2p* token and data structure +// which serves as the stemplate argument when the token's function +// is invoked. +// Alternatively, the template may consist of a single g2p* token. +// In that case, the corresponding function gets SCM_UNSPECIFIED +// as its stemplate argument. +// The invoked function is responsible for ensuring that the stemplate +// which it received is appropriate to sobj. Inappropriateness +// means that NULL is returned, which allows g2p_leaf (see below) +// to backtrace and try another template. +PyObject * +g2p_apply(SCM sobj,SCM stemplate) +{ + PyObject *pobj; + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# Entered g2p_apply: sobj=~S stemplate=~S\n"),scm_list_2(sobj,stemplate)); + } + if (IS_G2P_SMOBP(stemplate)) { + pobj = (get_g2p_function(stemplate))(sobj,SCM_UNSPECIFIED); + } + else if (!SCM_EQ_P(SCM_BOOL_F,scm_pair_p(stemplate))) { + if (IS_G2P_SMOBP(SCM_CAR(stemplate))) { + pobj = (get_g2p_function(SCM_CAR(stemplate)))(sobj,SCM_CDR(stemplate)); + } + else { + scm_misc_error("g2p_apply","bad template CAR item ~S", + scm_list_1(SCM_CAR(stemplate))); + } + } + else { + scm_misc_error("g2p_apply","bad template item ~S", + scm_list_1(stemplate)); + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(), + scm_makfrom0str("# Leaving g2p_apply: with ~A result\n"), + scm_list_1(NULL == pobj ? scm_makfrom0str("null") + : scm_makfrom0str("non-null"))); + } + return(pobj); // is NULL if conversion failed, otherwise a new + // reference to a PyObject (Py_INCREF has been invoked on it). +} + +////////////////////////// leaf //////////////////////////////////////// + +// Perform 'leaf' data conversion. +// Normally, stemplate is a list of templates, to be tried one by one +// until one of them succeeds. +PyObject * +g2p_leaf(SCM sobj,SCM stemplate) +{ + PyObject *pobj; + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# Entered g2p_leaf: sobj=~S stemplate=~S\n"),scm_list_2(sobj,stemplate)); + } + if (IS_G2P_SMOBP(stemplate)) { + pobj = (get_g2p_function(stemplate))(sobj,SCM_UNSPECIFIED); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(), + scm_makfrom0str("# Leaving g2p_leaf, after G2P_SMOBP conversion, with ~A result\n"), + scm_list_1(NULL == pobj ? scm_makfrom0str("null") + : scm_makfrom0str("non-null"))); + } + return(pobj); // Will be NULL if the conversion failed. + } + if (!SCM_EQ_P(SCM_BOOL_F,scm_list_p(stemplate))) { + // Each template list item is examined. + // If the template list item is itself a list, then its CAR is invoked + // and gets its CDR as template, and the whole sobj (which is + // expected to be a list, too) as the argument. + // If the template list item is a G2P_SMOB, then it is invoked with + // sobj. + // + // At any case, template list items are invoked one by one until + // one of them succeeds. + SCM slist; + for (slist = stemplate; (!SCM_EQ_P(slist,SCM_EOL)); + slist = SCM_CDR(slist)) { + SCM scandidate = SCM_CAR(slist); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_leaf: trying another stemplate ~S on sobj\n"),scm_list_1(scandidate)); + } + pobj = g2p_apply(sobj,scandidate); + if (NULL != pobj) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_leaf: successful conversion\n"),SCM_EOL); + } + return(pobj); + } + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_leaf: unsuccessful conversion, no stemplate fit the sobj\n"),SCM_EOL); + } + return(NULL); // None of the templates in the list fit the sobj. + // NULL return supports backtracking if the template is so designed. + } + scm_wrong_type_arg("g2p_leaf",SCM_ARG2,stemplate); // Bad template +} + +////////////////////////// null //////////////////////////////////////// + +PyObject * +g2p_null2PyNone(SCM sobj,SCM stemplate) +{ + if (SCM_NULLP(sobj)) { //(SCM_BOOL_F != scm_null_p(sobj)) + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_null2PyNone: successful conversion of ~S into Python None\n"),scm_list_1(sobj)); + } + Py_INCREF(Py_None); + return(Py_None); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_null2PyNone: unsuccessful conversion: ~S is not null\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +PyObject * +g2p_null2Tuple0(SCM sobj,SCM stemplate) +{ + if (SCM_NULLP(sobj)) { //(SCM_BOOL_F != scm_null_p(sobj)) + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_null2Tuple0: successful conversion of ~S into Python ()\n"),scm_list_1(sobj)); + } + PyObject *pres = PyTuple_New(0); + if (NULL == pres) { + scm_memory_error("g2p-null2Tuple0"); // NOT COVERED BY TESTS + } + return(pres); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_null2Tuple0: unsuccessful conversion: ~S is not null\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +PyObject * +g2p_null2List0(SCM sobj,SCM stemplate) +{ + if (SCM_NULLP(sobj)) { //(SCM_BOOL_F != scm_null_p(sobj)) + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_null2List0: successful conversion of ~S into Python []\n"),scm_list_1(sobj)); + } + PyObject *pres = PyList_New(0); + if (NULL == pres) { + scm_memory_error("g2p-null2List0"); // NOT COVERED BY TESTS + } + return(pres); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_null2List0: unsuccessful conversion: ~S is not null\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +PyObject * +g2p_null2DictEmpty(SCM sobj,SCM stemplate) +{ + if (SCM_NULLP(sobj)) { //(SCM_BOOL_F != scm_null_p(sobj)) + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_null2DictEmpty: successful conversion of ~S into Python {}\n"),scm_list_1(sobj)); + } + PyObject *pres = PyDict_New(); + if (NULL == pres) { + scm_memory_error("g2p-null2DictEmpty"); // NOT COVERED BY TESTS + } + return(pres); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_null2DictEmpty: unsuccessful conversion: ~S is not null\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +// Python's None is different from Python's () or Python's [] +// !!! Also, check for token such as '*none* or '*None* for +// !!! conversion into Python None instead of Python string. + +///////////////////////// Numeric ////////////////////////////////////// + +PyObject * +g2p_bool2Bool(SCM sobj,SCM stemplate) +{ + if (SCM_BOOLP(sobj)) { //(SCM_BOOL_F != scm_boolean_p(sobj)) + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_bool2Bool: successful conversion of ~S into a Python Bool value\n"),scm_list_1(sobj)); + } + if (SCM_EQ_P(SCM_BOOL_T,sobj)) { + Py_INCREF(Py_True); + return(Py_True); + } + else { + Py_INCREF(Py_False); + return(Py_False); + } + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_bool2Bool: unsuccessful conversion: ~S is not a bool value\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +PyObject * +g2p_num2Int(SCM sobj,SCM stemplate) +{ + if (SCM_INUMP(sobj)) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_num2Int: successful conversion of ~S into a Python Int value\n"),scm_list_1(sobj)); + } + return(PyInt_FromLong(scm_num2long(sobj,0,"g2p_long2Int"))); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_num2Int: unsuccessful conversion: ~S is not a num value\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +PyObject * +g2p_real2Float(SCM sobj,SCM stemplate) +{ + if (SCM_INUMP(sobj) || SCM_REALP(sobj)) { //(SCM_BOOL_F != scm_real_p(sobj)) + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_real2Float: successful conversion of ~S into a Python Float value\n"),scm_list_1(sobj)); + } + return(PyFloat_FromDouble(scm_num2double(sobj,0,"g2p_real2Float"))); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_real2Float: unsuccessful conversion: ~S is not a real value\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +PyObject * +g2p_complex2Complex(SCM sobj,SCM stemplate) +{ + if (SCM_COMPLEXP(sobj)) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_complex2Complex: successful conversion of ~S into a Python Complex value\n"),scm_list_1(sobj)); + } + double re = SCM_COMPLEX_REAL(sobj); + double im = SCM_COMPLEX_IMAG(sobj); + return(PyComplex_FromDoubles(re,im)); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_complex2Complex: unsuccessful conversion: ~S is not a complex value\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +PyObject * +g2p_bignum2Long(SCM sobj,SCM stemplate) +{ + // Like schemepy, we accomplish this conversion by first + // converting into string and then evaluating the string. + if (SCM_BIGP(sobj)) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_bignum2Long: successful conversion of ~S into a Python Long value\n"),scm_list_1(sobj)); + } + SCM swrite_proc = scm_variable_ref(scm_c_lookup("write")); + SCM sbignumstr = scm_object_to_string(sobj,swrite_proc); + char *pstr = gh_scm2newstr(sbignumstr,NULL); + if (NULL == pstr) { + scm_memory_error("g2p_bignum2Long"); // NOT COVERED BY TESTS + } + + PyObject *pres = PyInt_FromString(pstr, NULL, 10); // Will return PyLong if the value does not fit into PyInt. + free(pstr); + PyObject *pexception = PyErr_Occurred(); + if (pexception) { + Py_XDECREF(pres); // NOT COVERED BY TESTS + PyErr_Clear(); // NOT COVERED BY TESTS + scm_misc_error("g2p_bignum2Long","internal conversion error of bignum ~S", // NOT COVERED BY TESTS + sobj); + } + return(pres); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_bignum2Long: unsuccessful conversion: ~S is not a bignum value\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +///////////////////// Pairs and Lists ////////////////////////////////// + +PyObject * +g2p_pair2Tuple(SCM sobj,SCM stemplate) +{ + // We expect the template to be a pair. + // SCM_CAR(stemplate) is used to convert SCM_CAR(sobj), and similarly + // for SCM_CDR. + if (SCM_EQ_P(SCM_BOOL_F,scm_pair_p(sobj))) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_pair2Tuple: unsuccessful conversion: ~S is not a pair\n"),scm_list_1(sobj)); + } + return(NULL); + } + if (SCM_EQ_P(SCM_BOOL_F,scm_pair_p(stemplate))) { + scm_misc_error("g2p_pair2Tuple","bad template ~S", + scm_list_1(stemplate)); + } + + // Transform it into Python tuple. + PyObject *ppair = PyTuple_New(2); + if (NULL == ppair) { + scm_memory_error("g2p_pair2Tuple"); // NOT COVERED BY TESTS + } + + // CAR + PyObject *pitem = g2p_apply(SCM_CAR(sobj),SCM_CAR(stemplate)); + if (NULL == pitem) { + Py_DECREF(ppair); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_pair2Tuple: unsuccessful conversion: CAR conversion failure\n"),SCM_EOL); + } + return(NULL); // Conversion failure. + } + if (-1 == PyTuple_SetItem(ppair, 0, pitem)) { + Py_DECREF(ppair); // NOT COVERED BY TESTS + // Py_DECREF(pitem); // already performed by PyTuple_SetItem + scm_misc_error("g2p_pair2Tuple","PyTuple_SetItem car failure (~S)", // NOT COVERED BY TESTS + scm_list_1(SCM_CAR(sobj))); + } + + // CDR + pitem = g2p_apply(SCM_CDR(sobj),SCM_CDR(stemplate)); + if (NULL == pitem) { + Py_DECREF(ppair); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_pair2Tuple: unsuccessful conversion: CDR conversion failure\n"),SCM_EOL); + } + return(NULL); // Conversion failure. + } + if (-1 == PyTuple_SetItem(ppair, 1, pitem)) { + Py_DECREF(ppair); // NOT COVERED BY TESTS + // Py_DECREF(pitem); // already performed by PyTuple_SetItem + scm_misc_error("g2p_pair2Tuple","PyTuple_SetItem cdr failure (~S)", // NOT COVERED BY TESTS + scm_list_1(SCM_CDR(sobj))); + } + + // Done + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_pair2Tuple: successful conversion of ~S into a Python 2-Tuple\n"),scm_list_1(sobj)); + } + return(ppair); +} + +// Very similar to g2p_pair2Tuple() above. +PyObject * +g2p_pair2List(SCM sobj,SCM stemplate) +{ + // We expect the template to be a pair. + // SCM_CAR(stemplate) is used to convert SCM_CAR(sobj), and similarly + // for SCM_CDR. + if (SCM_EQ_P(SCM_BOOL_F,scm_pair_p(sobj))) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_pair2List: unsuccessful conversion: ~S is not a pair\n"),scm_list_1(sobj)); + } + return(NULL); + } + if (SCM_EQ_P(SCM_BOOL_F,scm_pair_p(stemplate))) { + scm_misc_error("g2p_pair2List","bad template ~S", + scm_list_1(stemplate)); + } + + // Transform it into Python tuple. + PyObject *ppair = PyList_New(2); + if (NULL == ppair) { + scm_memory_error("g2p_pair2List"); // NOT COVERED BY TESTS + } + + // CAR + PyObject *pitem = g2p_apply(SCM_CAR(sobj),SCM_CAR(stemplate)); + if (NULL == pitem) { + Py_DECREF(ppair); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_pair2List: unsuccessful conversion: CAR conversion failure\n"),SCM_EOL); + } + return(NULL); + } + if (-1 == PyList_SetItem(ppair, 0, pitem)) { + Py_DECREF(ppair); // NOT COVERED BY TESTS + // Py_DECREF(pitem); // already performed by PyList_SetItem + scm_misc_error("g2p_pair2List","PyList_SetItem car failure (~S)", // NOT COVERED BY TESTS + scm_list_1(SCM_CAR(sobj))); + } + + // CDR + pitem = g2p_apply(SCM_CDR(sobj),SCM_CDR(stemplate)); + if (NULL == pitem) { + Py_DECREF(ppair); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_pair2List: unsuccessful conversion: CDR conversion failure\n"),SCM_EOL); + } + return(NULL); + } + if (-1 == PyList_SetItem(ppair, 1, pitem)) { + Py_DECREF(ppair); // NOT COVERED BY TESTS + // Py_DECREF(pitem); // already performed by PyList_SetItem + scm_misc_error("g2p_pair2List","PyList_SetItem cdr failure (~S)", // NOT COVERED BY TESTS + scm_list_1(SCM_CDR(sobj))); + } + + // Done + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_pair2List: successful conversion of ~S into a Python 2-List\n"),scm_list_1(sobj)); + } + return(ppair); +} + +PyObject * +g2p_list2Tuple(SCM sobj,SCM stemplate) +{ + // sobj is expected to be a list. + + if (SCM_EQ_P(SCM_BOOL_F,scm_list_p(sobj))) { + // sobj is not a list, so this is the wrong conversion function for it. + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2Tuple: unsuccessful conversion: ~S is not a list\n"),scm_list_1(sobj)); + } + return(NULL); + } + + // The template may be either a G2P_SMOB (to be used for converting + // all list items) or a list of templates. + long listlen = scm_num2long(scm_length(sobj),0,"g2p_list2Tuple"); + PyObject *plist = PyTuple_New(listlen); + if (NULL == plist) { + scm_memory_error("g2p_list2Tuple"); // NOT COVERED BY TESTS + } + + // Conversion loop for the case in which the template is a single G2P_SMOB + if (IS_G2P_SMOBP(stemplate)) { + long ind1; + for (ind1 = 0; ind1 < listlen; sobj = SCM_CDR(sobj),++ind1) { + SCM sitem = SCM_CAR(sobj); + PyObject *pobj1 = g2p_apply(sitem,stemplate); + if (NULL == pobj1) { + Py_DECREF(plist); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2Tuple: unsuccessful conversion of element ~A: ~S does not match template\n"),scm_list_2(scm_long2num(ind1),sitem)); + } + return(NULL); // Conversion failure. + } + if (-1 == PyTuple_SetItem(plist, ind1, pobj1)) { + Py_DECREF(plist); // NOT COVERED BY TESTS + //Py_DECREF(pobj1); + scm_misc_error("g2p_list2Tuple","PyTuple_SetItem ~S failure (~S)", // NOT COVERED BY TESTS + scm_list_2(scm_long2num(ind1),sitem)); + } + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2Tuple: successful conversion of list ~S\n"),scm_list_1(sobj)); + } + return(plist); + } + + if (SCM_EQ_P(SCM_BOOL_F,scm_list_p(stemplate))) { + // Bad template. + scm_wrong_type_arg("g2p_list2Tuple",SCM_ARG2,stemplate); + } + + // Conversion loop for the case in which the template is a list. + long ind2; + SCM stemp = SCM_EOL; // We loop over stemplate again and again as needed. + for (ind2 = 0; ind2 < listlen; + sobj = SCM_CDR(sobj), stemp=SCM_CDR(stemp), ++ind2) { + if (SCM_EQ_P(stemp,SCM_EOL)) { + stemp = stemplate; // Loop back to stemplate's beginning. + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2Tuple - processing item CAR(sobj)=~S CAR(stemp)=~S\n"),scm_list_2(SCM_CAR(sobj),SCM_CAR(stemp))); + } + PyObject *pobj2 = g2p_apply(SCM_CAR(sobj),SCM_CAR(stemp)); + if (NULL == pobj2) { + Py_DECREF(plist); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2Tuple: unsuccessful conversion of element ~A: ~S does not match personalized template\n"),scm_list_2(scm_long2num(ind2),SCM_CAR(sobj))); + } + return(NULL); // Conversion failure. + } + if (-1 == PyTuple_SetItem(plist, ind2, pobj2)) { + Py_DECREF(plist); // NOT COVERED BY TESTS + //Py_DECREF(pobj2); + scm_misc_error("g2p_list2Tuple","PyTuple_SetItem ~S failure (~S)", // NOT COVERED BY TESTS + scm_list_2(scm_long2num(ind2),SCM_CAR(stemp))); + } + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2Tuple: successful conversion of list ~S by template\n"),scm_list_1(sobj)); + } + return(plist); +} + +// Very similar to g2p_list2Tuple() above. +PyObject * +g2p_list2List(SCM sobj,SCM stemplate) +{ + // sobj is expected to be a list. + + if (SCM_EQ_P(SCM_BOOL_F,scm_list_p(sobj))) { + // sobj is not a list, so this is the wrong conversion function for it. + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2List: unsuccessful conversion: ~S is not a list\n"),scm_list_1(sobj)); + } + return(NULL); + } + + // The template may be either a G2P_SMOB (to be used for converting + // all list items) or a list of templates. + long listlen = scm_num2long(scm_length(sobj),0,"g2p_list2List"); + PyObject *plist = PyList_New(listlen); + if (NULL == plist) { + scm_memory_error("g2p_list2List"); // NOT COVERED BY TESTS + } + + // Conversion loop for the case in which the template is a single G2P_SMOB + if (IS_G2P_SMOBP(stemplate)) { + long ind1; + for (ind1 = 0; ind1 < listlen; sobj = SCM_CDR(sobj),++ind1) { + SCM sitem = SCM_CAR(sobj); + PyObject *pobj1 = g2p_apply(sitem,stemplate); + if (NULL == pobj1) { + Py_DECREF(plist); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2List: unsuccessful conversion of element ~A: ~S does not match template\n"),scm_list_2(scm_long2num(ind1),sitem)); + } + return(NULL); // Conversion failure. + } + if (-1 == PyList_SetItem(plist, ind1, pobj1)) { + Py_DECREF(plist); // NOT COVERED BY TESTS + //Py_DECREF(pobj1); + scm_misc_error("g2p_list2List","PyList_SetItem ~S failure (~S)", // NOT COVERED BY TESTS + scm_list_2(scm_long2num(ind1),sitem)); + } + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2List: successful conversion of list ~S\n"),scm_list_1(sobj)); + } + return(plist); + } + + if (SCM_EQ_P(SCM_BOOL_F,scm_list_p(stemplate))) { + // Bad template. + scm_wrong_type_arg("g2p_list2List",SCM_ARG2,stemplate); + } + + // Conversion loop for the case in which the template is a list. + long ind2; + SCM stemp = SCM_EOL; // We loop over stemplate again and again as needed. + for (ind2 = 0; ind2 < listlen; + sobj = SCM_CDR(sobj), stemp=SCM_CDR(stemp), ++ind2) { + if (SCM_EQ_P(stemp,SCM_EOL)) { + stemp = stemplate; // Loop back to stemplate's beginning. + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# DEBUG: g2p_list2List - processing item CAR(sobj)=~S CAR(stemp)=~S\n"),scm_list_2(SCM_CAR(sobj),SCM_CAR(stemp))); + } + PyObject *pobj2 = g2p_apply(SCM_CAR(sobj),SCM_CAR(stemp)); + if (NULL == pobj2) { + Py_DECREF(plist); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2List: unsuccessful conversion of element ~A: ~S does not match personalized template\n"),scm_list_2(scm_long2num(ind2),SCM_CAR(sobj))); + } + return(NULL); // Conversion failure + } + if (-1 == PyList_SetItem(plist, ind2, pobj2)) { + Py_DECREF(plist); // NOT COVERED BY TESTS + //Py_DECREF(pobj2); + scm_misc_error("g2p_list2List","PyList_SetItem ~S failure (~S)", // NOT COVERED BY TESTS + scm_list_2(scm_long2num(ind2),SCM_CAR(stemp))); + } + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_list2List: successful conversion of list ~S by template\n"),scm_list_1(sobj)); + } + return(plist); +} + +///////////////////////// strings and symbols ////////////////////////// + +PyObject * +g2p_char2String(SCM sobj,SCM stemplate) +{ + if (SCM_CHARP(sobj)) { + return(PyString_FromFormat("%c",(int) SCM_CHAR(sobj))); + } + else { + return(NULL); + } +} + +PyObject * +g2p_string2String(SCM sobj,SCM stemplate) +{ + if (SCM_STRINGP(sobj)) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_string2String: successful conversion of ~S into a Python String value\n"),scm_list_1(sobj)); + } + PyObject *pstr = PyString_FromStringAndSize(SCM_STRING_CHARS(sobj),SCM_STRING_LENGTH(sobj)); + if (NULL == pstr) { + scm_memory_error("g2p_string2String"); // NOT COVERED BY TESTS + } + return(pstr); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_string2String: unsuccessful conversion: ~S is not a string value\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +// Guile is case-sensitive by default, so we don't have to +// ensure that symbols always lowercase their characters. +PyObject * +g2p_symbol2String(SCM sobj,SCM stemplate) +{ + if (SCM_SYMBOLP(sobj)) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_symbol2String: successful conversion of ~S into a Python String value\n"),scm_list_1(sobj)); + } + PyObject *pstr = PyString_FromStringAndSize(SCM_SYMBOL_CHARS(sobj),SCM_SYMBOL_LENGTH(sobj)); + if (NULL == pstr) { + scm_memory_error("g2p_symbol2String"); // NOT COVERED BY TESTS + } + return(pstr); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_symbol2String: unsuccessful conversion: ~S is not a symbol value\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +PyObject * +g2p_keyword2String(SCM sobj,SCM stemplate) +{ + if (SCM_KEYWORDP(sobj)) { //(SCM_BOOL_F != scm_keyword_p(sobj)) + SCM symb = scm_keyword_dash_symbol(sobj); + // We want to remove the leading '-' from the keyword, so that + // it can be used in keyword function arguments in a natural way. + const char *symchars = SCM_SYMBOL_CHARS(symb); + int symlength = SCM_SYMBOL_LENGTH(symb); + if (symlength < 1) { + scm_out_of_range("g2p_keyword2String",sobj); // NOT COVERED BY TESTS + // The symbol is too short to have dash. + // We allow symbols like '#:', which are converted here into empty + // strings. Guile does not accept them for version 1.8.x and later, + // but this does not matter here. + } + PyObject *pstr = PyString_FromStringAndSize(symchars+1,symlength-1); + if (NULL == pstr) { + scm_memory_error("g2p_keyword2String"); // NOT COVERED BY TESTS + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_keyword2String: successful conversion of ~S into a Python String value\n"),scm_list_1(sobj)); + } + return(pstr); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_keyword2String: unsuccessful conversion: ~S is not a keyword value\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + +///////////////////////// opaque datatypes ///////////////////////////// + +// scm_procedure_p +// scm_procedure_with_setter_p - not implemented yet. + +// Reasonable default template for procedure objects +static SCM g2p_procedure2PySCMObject_template_default; +// The above variable is to be assigned the value: +// scm_permanent_object(scm_vector(scm_list_5(...))) +// where the arguments of scm_list_5() are: +// scm_variable_ref(scm_c_lookup("python2guile")) +// scm_variable_ref(scm_c_lookup("python2guile")) +// guile2python_smob +// scm_variable_ref(scm_c_lookup("apply")) +// SCM_BOOL_F +// +// To clone the above and set other templates, use +// Scheme procedure: (set! cloned (copy-tree obj)) +// and C function: SCM scopy = scm_copy_tree(SCM sobj) + +PyObject * +g2p_procedure2PySCMObject(SCM sobj,SCM stemplate) +{ + if (SCM_EQ_P(stemplate,SCM_UNSPECIFIED)) { + stemplate = g2p_procedure2PySCMObject_template_default; + } + if (SCM_EQ_P(SCM_BOOL_F,scm_vector_p(stemplate))) { + // Bad template + scm_wrong_type_arg("g2p_procedure2PySCMObject",SCM_ARG2,stemplate); + } + if (SCM_EQ_P(SCM_BOOL_F,scm_procedure_p(sobj))) { + // Not a procedure + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_procedure2PySCMObject: unsuccessful conversion: ~S is not a procedure\n"),scm_list_1(sobj)); + } + return(NULL); + } + PyObject *pobj = wrap_scm(sobj,stemplate); + if (NULL != pobj) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_procedure2PySCMObject: successful conversion: ~S has been wrapped\n"),scm_list_1(sobj)); + } + } + return(pobj); +} + + +PyObject * +g2p_opaque2Object(SCM sobj,SCM stemplate) +{ + if (IS_PYSMOBP(sobj)) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_SUCCESSFUL)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_opaque2Object: the Python object inside opaque pysmob ~S is unwrapped\n"),scm_list_1(sobj)); + } + PyObject *pobj = unwrap_pysmob(sobj); + Py_INCREF(pobj); + return(pobj); + } + else { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_opaque2Object: unsuccessful conversion: ~S is not an opaque pysmob value\n"),scm_list_1(sobj)); + } + return(NULL); + } +} + + +//////////////////////////////////////////////////////////////////////// +// Big default conversion function +//////////////////////////////////////////////////////////////////////// +// The guile2python function chooses reasonable defaults, whenever +// there is a possibility for ambiguity concerning the desired +// Python datatype. + +static SCM guile2python_smob; // Used when we need it as hash default value. +static SCM guile2python_template_default; // used by guile2python(). +static SCM guile2python_pair_template_default; // used by guile2python(). +static SCM guileassoc2pythondict_default; // used by guileassoc2pythondict. + // It is set to an empty hash table. +static SCM g2p_alist_template_default; // used by g2p_alist2Dict. + +// This function does Py_INCREF() to its return values. +PyObject * +guile2python(SCM sobj,SCM stemplate) +{ + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# guile2python: entry: seeking to convert sobj=~S; unused stemplate=~S\n"),scm_list_2(sobj,stemplate)); + } + PyObject *pres = NULL; + + //////////// Scheme sequences + + // SCM '() is converted into Python None. + pres = g2p_null2PyNone(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + // We check lists before pairs because every list in Scheme is + // also a pair. + //printf("# DEBUG: guile2python, before 1st call to g2p_list2List\n"); + pres = g2p_list2List(sobj,guile2python_template_default); + if (NULL != pres) return(pres); + + pres = g2p_pair2Tuple(sobj,guile2python_pair_template_default); + if (NULL != pres) return(pres); + + //////////// Scheme numbers + + pres = g2p_bool2Bool(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + pres = g2p_num2Int(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + pres = g2p_bignum2Long(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + pres = g2p_real2Float(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + // NOTE: in Guile 1.6, rational numbers and real numbers are + // internally represented the same way. + + pres = g2p_complex2Complex(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + //////////// Scheme strings + + pres = g2p_char2String(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + pres = g2p_string2String(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + pres = g2p_symbol2String(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + pres = g2p_keyword2String(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + //////////// Other Scheme data types + + pres = g2p_procedure2PySCMObject(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + pres = g2p_opaque2Object(sobj,SCM_UNSPECIFIED); + if (NULL != pres) return(pres); + + // !!! More simple data types: regexp + // !!! To wrap: procedures, macros(opaque), variables, + // !!! opaque: asyncs, dynamic roots, fluids, hooks, ports + + // !!! Scheme objects + + // !!! More complex data types: vectors,records,structures,arrays, + + + else { + scm_wrong_type_arg("guile2python",SCM_ARG1,sobj); + } +} + +//////////////////////////////////////////////////////////////////////// +// Quick conversion from alist into Dict +//////////////////////////////////////////////////////////////////////// +// Treat the SCM object as an association list and convert it into +// Python hash, whose keys are strings corresponding to the +// association list's keys (which must be keywords). +// +// This version is meant for quick conversion of keyword arguments, +// and it allows only keywords as keys. +// +// Checks: +// 1. Validity of keys. +// 2. No duplicate keys. +// +// The stemplate argument must be an hash table (keys are checked +// using eq?). + +PyObject * +guileassoc2pythondict(SCM sobj,SCM stemplate) +{ + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# guileassoc2pythondict: entry: seeking to convert sobj=~S using stemplate=~S\n"),scm_list_2(sobj,stemplate)); + } + + if (SCM_UNBNDP(stemplate)) { + stemplate = guileassoc2pythondict_default; + } + PyObject *pdict = NULL; + PyObject *pkey = NULL; + PyObject *pval = NULL; + + if (SCM_EQ_P(SCM_BOOL_F,scm_list_p(sobj))) { + scm_wrong_type_arg("guileassoc2pythondict",SCM_ARG1,sobj); + } + // TODO: add here a call to SCM_HASHP(stemplate) to validate that the + // template is hashtable. + + long listlen = scm_num2long(scm_length(sobj),0,"guileassoc2pythondict"); + pdict = PyDict_New(); + if (NULL == pdict) { + scm_memory_error("guileassoc2pythondict"); // NOT COVERED BY TESTS + } + long ind; + for (ind = 0,pkey = NULL,pval = NULL; ind < listlen; ++ind) { + SCM spair = SCM_CAR(sobj); + if (SCM_EQ_P(SCM_BOOL_F,scm_pair_p(spair))) { + // Not a pair. + Py_DECREF(pdict); + scm_wrong_type_arg("guileassoc2pythondict",ind+1,spair); + } + + pkey = g2p_keyword2String(SCM_CAR(spair),SCM_UNSPECIFIED); + if (NULL == pkey) { + // Illegal key - it must be a keyword. + scm_wrong_type_arg("guileassoc2pythondict",ind+1,SCM_CAR(spair)); + } + if (0 != PyDict_Contains(pdict,pkey)) { + // Duplicate key or some error + Py_DECREF(pdict); + Py_DECREF(pkey); + scm_misc_error("guileassoc2pythondict","duplicate key (~S)", + scm_list_1(SCM_CAR(spair))); + } + + SCM sitem_template = scm_hashq_ref(stemplate,SCM_CAR(spair),guile2python_smob); + pval = g2p_apply(SCM_CDR(spair),sitem_template); + if (NULL == pval) { + Py_DECREF(pdict); + Py_DECREF(pkey); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# guileassoc2pythondict: unsuccessful conversion of element ~A: ~S does not match template\n"),scm_list_2(SCM_CAR(spair),SCM_CDR(spair))); + } + return(NULL); // Conversion failure. + } + + if (-1 == PyDict_SetItem(pdict,pkey,pval)) { + Py_XDECREF(pdict); // NOT COVERED BY TESTS + //Py_XDECREF(pkey); + //Py_XDECREF(pval); + scm_misc_error("guileassoc2pythondict","PyDict_SetItem failure (~S : ~S)", // NOT COVERED BY TESTS + scm_list_2(SCM_CAR(spair),SCM_CDR(spair))); + } + sobj = SCM_CDR(sobj); + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# guileassoc2pythondict: successful conversion of ~S\n"),scm_list_1(sobj)); + } + return(pdict); +} + +//////////////////////////////////////////////////////////////////////// +// Generalized conversion from alist into Dict +//////////////////////////////////////////////////////////////////////// +// The following function is meant for conversion of alists into +// general Python Dicts. +// It allows any immutable object as key. +// NOTE: no check for immutability is made here! +// +// The stemplate argument must be a list of pairs (i.e. structured +// like an alist). + +PyObject * +g2p_alist2Dict(SCM sobj,SCM stemplate) +{ + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_alist2Dict sobj=~S stemplate=~S\n"),scm_list_2(sobj,stemplate)); + } + if (SCM_UNBNDP(stemplate) || SCM_EQ_P(stemplate,SCM_EOL)) { + stemplate = g2p_alist_template_default; + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_alist2Dict - default template was chosen: ~S\n"),scm_list_1(stemplate)); + } + } + + if (SCM_EQ_P(SCM_BOOL_F,scm_list_p(sobj))) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_alist2Dict: unsuccessful conversion: argument is not list, let alone alist\n"),SCM_EOL); + } + return(NULL); // Conversion failure. + } + if (SCM_EQ_P(SCM_BOOL_F,scm_list_p(stemplate))) { + scm_wrong_type_arg("g2p_alist2Dict",SCM_ARG2,sobj); // Bad template. + } + + long listlen = scm_num2long(scm_length(sobj),0,"g2p_alist2Dict"); + PyObject *pdict = PyDict_New(); + if (NULL == pdict) { + scm_memory_error("g2p_alist2Dict"); // NOT COVERED BY TESTS + } + + long ind; + SCM stemp = SCM_EOL; // We loop over stemplate again and again as needed. + for (ind = 0; ind < listlen; + sobj = SCM_CDR(sobj),stemp=SCM_CDR(stemp), ++ind) { + if (SCM_EQ_P(stemp,SCM_EOL)) { + stemp = stemplate; // Loop back to stemplate's beginning. + } + + if (SCM_EQ_P(SCM_BOOL_F,scm_pair_p(SCM_CAR(stemp)))) { + // Not a template pair - bad template. + Py_DECREF(pdict); + scm_wrong_type_arg("g2p_alist2Dict",SCM_ARG2,SCM_CAR(stemp)); + } + SCM spair = SCM_CAR(sobj); + if (SCM_EQ_P(SCM_BOOL_F,scm_pair_p(spair))) { + // Not a data pair - conversion failure. + Py_DECREF(pdict); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_alist2Dict: unsuccessful conversion: alist item is not pair: ~S\n"),scm_list_1(spair)); + } + return(NULL); + } + + PyObject *pkey = g2p_apply(SCM_CAR(spair),SCM_CAAR(stemp)); + if (NULL == pkey) { + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_alist2Dict: unsuccessful conversion: key ~S, template ~S\n"),scm_list_2(SCM_CAR(spair),SCM_CAAR(stemp))); + } + return(NULL); // Conversion failure. + } + if (0 != PyDict_Contains(pdict,pkey)) { + // Duplicate key or some error. + Py_DECREF(pdict); + Py_DECREF(pkey); + scm_misc_error("g2p_alist2Dict","duplicate key (~S)", + scm_list_1(SCM_CAR(spair))); + } + + PyObject *pval = g2p_apply(SCM_CDR(spair),SCM_CDAR(stemp)); + if (NULL == pval) { + Py_DECREF(pdict); + Py_DECREF(pkey); + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_alist2Dict: unsuccessful conversion: value ~S, template ~S\n"),scm_list_2(SCM_CDR(spair),SCM_CDAR(stemp))); + } + return(NULL); // Conversion failure. + } + + if (-1 == PyDict_SetItem(pdict,pkey,pval)) { + Py_XDECREF(pdict); // NOT COVERED BY TESTS + //Py_XDECREF(pkey); + //Py_XDECREF(pval); + scm_misc_error("g2p_alist2Dict","PyDict_SetItem failure (~S : ~S)", // NOT COVERED BY TESTS + scm_list_2(SCM_CAR(spair),SCM_CDR(spair))); + } + } + if (pyguile_verbosity_test(PYGUILE_VERBOSE_G2P2G_ALWAYS)) { + scm_simple_format(scm_current_output_port(),scm_makfrom0str("# g2p_alist2Dict: successful conversion\n"),SCM_EOL); + } + return(pdict); +} + +// NOTE: +// After all, we'll not support hash tables. +// This is because I found no function to identify an hash table. +// Hash table can be converted into alist using: +// (hash-fold acons '() hashtable) + +//////////////////////////////////////////////////////////////////////// +// Register all g2p_* functions + +#include "guiletopy.inc" + +// The following must happen after registration of all g2p_* and p2g_* +// functions. +void +init_default_guiletopy_templates(void) +{ + SCM s_python2guile = scm_variable_ref(scm_c_lookup("python2guile")); + g2p_procedure2PySCMObject_template_default + = scm_permanent_object(scm_vector(scm_list_5( + s_python2guile, + s_python2guile, + guile2python_smob, + scm_variable_ref(scm_c_lookup("apply")), + SCM_BOOL_F))); + scm_c_define("pyscm-default-template",g2p_procedure2PySCMObject_template_default); +} + +//////////////////////////////////////////////////////////////////////// +// End of guiletopy.c |