forked from Ivasoft/DSView
v0.97 initial update, compile pass, run error
This commit is contained in:
DreamSourceLab
@@ -21,46 +21,63 @@
|
||||
#include "config.h"
|
||||
#include "libsigrokdecode-internal.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */
|
||||
#include "libsigrokdecode.h"
|
||||
#include "config.h"
|
||||
/**
|
||||
* Import a Python module by name.
|
||||
*
|
||||
* This function is implemented in terms of PyImport_Import() rather than
|
||||
* PyImport_ImportModule(), so that the import hooks are not bypassed.
|
||||
*
|
||||
* @param[in] name The name of the module to load as UTF-8 string.
|
||||
* @return The Python module object, or NULL if an exception occurred. The
|
||||
* caller is responsible for evaluating and clearing the Python error state.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
SRD_PRIV PyObject *py_import_by_name(const char *name)
|
||||
{
|
||||
PyObject *py_mod, *py_modname;
|
||||
|
||||
py_modname = PyUnicode_FromString(name);
|
||||
if (!py_modname)
|
||||
return NULL;
|
||||
|
||||
py_mod = PyImport_Import(py_modname);
|
||||
Py_DECREF(py_modname);
|
||||
|
||||
return py_mod;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the value of a Python object's attribute, returned as a newly
|
||||
* allocated char *.
|
||||
*
|
||||
* @param py_obj The object to probe.
|
||||
* @param attr Name of the attribute to retrieve.
|
||||
* @param outstr ptr to char * storage to be filled in.
|
||||
* @param[in] py_obj The object to probe.
|
||||
* @param[in] attr Name of the attribute to retrieve.
|
||||
* @param[out] outstr ptr to char * storage to be filled in.
|
||||
*
|
||||
* @return SRD_OK upon success, a (negative) error code otherwise.
|
||||
* The 'outstr' argument points to a malloc()ed string upon success.
|
||||
* The 'outstr' argument points to a g_malloc()ed string upon success.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
SRD_PRIV int py_attr_as_str(const PyObject *py_obj, const char *attr,
|
||||
char **outstr)
|
||||
SRD_PRIV int py_attr_as_str(PyObject *py_obj, const char *attr, char **outstr)
|
||||
{
|
||||
PyObject *py_str;
|
||||
int ret;
|
||||
|
||||
if (!PyObject_HasAttrString((PyObject *)py_obj, attr)) {
|
||||
srd_dbg("%s object has no attribute '%s'.",
|
||||
Py_TYPE(py_obj)->tp_name, attr);
|
||||
if (!PyObject_HasAttrString(py_obj, attr)) {
|
||||
srd_dbg("Object has no attribute '%s'.", attr);
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
|
||||
if (!(py_str = PyObject_GetAttrString((PyObject *)py_obj, attr))) {
|
||||
srd_exception_catch("", NULL);
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
|
||||
if (!PyUnicode_Check(py_str)) {
|
||||
srd_dbg("%s attribute should be a string, but is a %s.",
|
||||
attr, Py_TYPE(py_str)->tp_name);
|
||||
Py_DecRef(py_str);
|
||||
if (!(py_str = PyObject_GetAttrString(py_obj, attr))) {
|
||||
srd_exception_catch(NULL, "Failed to get attribute '%s'", attr);
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
|
||||
ret = py_str_as_str(py_str, outstr);
|
||||
Py_DecRef(py_str);
|
||||
Py_DECREF(py_str);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -69,136 +86,213 @@ SRD_PRIV int py_attr_as_str(const PyObject *py_obj, const char *attr,
|
||||
* Get the value of a Python dictionary item, returned as a newly
|
||||
* allocated char *.
|
||||
*
|
||||
* @param py_obj The dictionary to probe.
|
||||
* @param key Key of the item to retrieve.
|
||||
* @param outstr Pointer to char * storage to be filled in.
|
||||
* @param[in] py_obj The dictionary to probe.
|
||||
* @param[in] key Key of the item to retrieve.
|
||||
* @param[out] outstr Pointer to char * storage to be filled in.
|
||||
*
|
||||
* @return SRD_OK upon success, a (negative) error code otherwise.
|
||||
* The 'outstr' argument points to a malloc()ed string upon success.
|
||||
* The 'outstr' argument points to a g_malloc()ed string upon success.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
SRD_PRIV int py_dictitem_as_str(const PyObject *py_obj, const char *key,
|
||||
SRD_PRIV int py_dictitem_as_str(PyObject *py_obj, const char *key,
|
||||
char **outstr)
|
||||
{
|
||||
PyObject *py_value;
|
||||
int ret;
|
||||
|
||||
if (!PyDict_Check((PyObject *)py_obj)) {
|
||||
srd_dbg("Object is a %s, not a dictionary.",
|
||||
Py_TYPE((PyObject *)py_obj)->tp_name);
|
||||
if (!PyDict_Check(py_obj)) {
|
||||
srd_dbg("Object is not a dictionary.");
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
|
||||
if (!(py_value = PyDict_GetItemString((PyObject *)py_obj, key))) {
|
||||
if (!(py_value = PyDict_GetItemString(py_obj, key))) {
|
||||
srd_dbg("Dictionary has no attribute '%s'.", key);
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
|
||||
if (!PyUnicode_Check(py_value)) {
|
||||
srd_dbg("Dictionary value for %s should be a string, but is "
|
||||
"a %s.", key, Py_TYPE(py_value)->tp_name);
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
return py_str_as_str(py_value, outstr);
|
||||
}
|
||||
|
||||
ret = py_str_as_str(py_value, outstr);
|
||||
/**
|
||||
* Get the value of a Python dictionary item, returned as a int.
|
||||
*
|
||||
* @param[in] py_obj The dictionary to probe.
|
||||
* @param[in] key Key of the item to retrieve.
|
||||
*
|
||||
* @return -1 upon failed
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
SRD_PRIV int py_dictitem_to_int(PyObject *py_obj, const char *key)
|
||||
{
|
||||
PyObject *py_value;
|
||||
PyObject *py_long;
|
||||
|
||||
return ret;
|
||||
if (!PyDict_Check(py_obj)) {
|
||||
srd_dbg("Object is not a dictionary.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!(py_value = PyDict_GetItemString(py_obj, key))) {
|
||||
srd_dbg("Dictionary has no attribute '%s'.", key);
|
||||
return -1;
|
||||
}
|
||||
py_long = PyLong_FromUnicodeObject(py_value, 10);
|
||||
return PyLong_AsLong(py_long);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the value of a Python unicode string object, returned as a newly
|
||||
* allocated char *.
|
||||
*
|
||||
* @param py_str The unicode string object.
|
||||
* @param outstr ptr to char * storage to be filled in.
|
||||
* @param[in] py_str The unicode string object.
|
||||
* @param[out] outstr ptr to char * storage to be filled in.
|
||||
*
|
||||
* @return SRD_OK upon success, a (negative) error code otherwise.
|
||||
* The 'outstr' argument points to a malloc()ed string upon success.
|
||||
* The 'outstr' argument points to a g_malloc()ed string upon success.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
SRD_PRIV int py_str_as_str(const PyObject *py_str, char **outstr)
|
||||
SRD_PRIV int py_str_as_str(PyObject *py_str, char **outstr)
|
||||
{
|
||||
PyObject *py_encstr;
|
||||
int ret;
|
||||
PyObject *py_bytes;
|
||||
char *str;
|
||||
|
||||
py_encstr = NULL;
|
||||
str = NULL;
|
||||
ret = SRD_OK;
|
||||
|
||||
if (!PyUnicode_Check((PyObject *)py_str)) {
|
||||
srd_dbg("Object is a %s, not a string object.",
|
||||
Py_TYPE((PyObject *)py_str)->tp_name);
|
||||
ret = SRD_ERR_PYTHON;
|
||||
goto err_out;
|
||||
if (!PyUnicode_Check(py_str)) {
|
||||
srd_dbg("Object is not a string object.");
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
|
||||
if (!(py_encstr = PyUnicode_AsEncodedString((PyObject *)py_str,
|
||||
"utf-8", NULL))) {
|
||||
ret = SRD_ERR_PYTHON;
|
||||
goto err_out;
|
||||
}
|
||||
if (!(str = PyBytes_AS_STRING(py_encstr))) {
|
||||
ret = SRD_ERR_PYTHON;
|
||||
goto err_out;
|
||||
py_bytes = PyUnicode_AsUTF8String(py_str);
|
||||
if (py_bytes) {
|
||||
str = g_strdup(PyBytes_AsString(py_bytes));
|
||||
Py_DECREF(py_bytes);
|
||||
if (str) {
|
||||
*outstr = str;
|
||||
return SRD_OK;
|
||||
}
|
||||
}
|
||||
srd_exception_catch(NULL, "Failed to extract string");
|
||||
|
||||
*outstr = g_strdup(str);
|
||||
|
||||
err_out:
|
||||
if (py_encstr)
|
||||
Py_XDECREF(py_encstr);
|
||||
|
||||
if (PyErr_Occurred()) {
|
||||
srd_exception_catch("string conversion failed", NULL);
|
||||
}
|
||||
|
||||
return ret;
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a Python list of unicode strings to a NULL-terminated UTF8-encoded
|
||||
* char * array. The caller must g_free() each string when finished.
|
||||
* Convert a Python list of unicode strings to a C string vector.
|
||||
* On success, a pointer to a newly allocated NULL-terminated array of
|
||||
* allocated C strings is written to @a out_strv. The caller must g_free()
|
||||
* each string and the array itself.
|
||||
*
|
||||
* @param py_strlist The list object.
|
||||
* @param outstr ptr to char ** storage to be filled in.
|
||||
* @param[in] py_strseq The sequence object.
|
||||
* @param[out] out_strv Address of string vector to be filled in.
|
||||
*
|
||||
* @return SRD_OK upon success, a (negative) error code otherwise.
|
||||
* The 'outstr' argument points to a g_malloc()ed char** upon success.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
SRD_PRIV int py_strseq_to_char(const PyObject *py_strseq, char ***outstr)
|
||||
SRD_PRIV int py_strseq_to_char(PyObject *py_strseq, char ***out_strv)
|
||||
{
|
||||
PyObject *py_seq, *py_str;
|
||||
int list_len, i;
|
||||
char **out, *str;
|
||||
PyObject *py_item, *py_bytes;
|
||||
char **strv, *str;
|
||||
ssize_t seq_len, i;
|
||||
|
||||
list_len = PySequence_Size((PyObject *)py_strseq);
|
||||
if (!(out = g_try_malloc(sizeof(char *) * (list_len + 1)))) {
|
||||
srd_err("Failed to g_malloc() 'out'.");
|
||||
if (!PySequence_Check(py_strseq)) {
|
||||
srd_err("Object does not provide sequence protocol.");
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
|
||||
seq_len = PySequence_Size(py_strseq);
|
||||
if (seq_len < 0) {
|
||||
srd_exception_catch(NULL, "Failed to obtain sequence size");
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
|
||||
strv = g_try_new0(char *, seq_len + 1);
|
||||
if (!strv) {
|
||||
srd_err("Failed to allocate result string vector.");
|
||||
return SRD_ERR_MALLOC;
|
||||
}
|
||||
for (i = 0; i < list_len; i++) {
|
||||
// if (!(py_str = PyUnicode_AsEncodedString(
|
||||
// PySequence_GetItem((PyObject *)py_strseq, i), "utf-8", NULL)))
|
||||
// return SRD_ERR_PYTHON;
|
||||
// if (!(str = PyBytes_AS_STRING(py_str)))
|
||||
// return SRD_ERR_PYTHON;
|
||||
py_seq = PySequence_GetItem((PyObject *)py_strseq, i);
|
||||
if (!(py_str = PyUnicode_AsEncodedString(py_seq, "utf-8", NULL)))
|
||||
return SRD_ERR_PYTHON;
|
||||
if (!(str = PyBytes_AS_STRING(py_str)))
|
||||
return SRD_ERR_PYTHON;
|
||||
|
||||
out[i] = g_strdup(str);
|
||||
Py_XDECREF(py_seq);
|
||||
Py_XDECREF(py_str);
|
||||
for (i = 0; i < seq_len; i++) {
|
||||
py_item = PySequence_GetItem(py_strseq, i);
|
||||
if (!py_item)
|
||||
goto err_out;
|
||||
|
||||
if (!PyUnicode_Check(py_item)) {
|
||||
Py_DECREF(py_item);
|
||||
goto err_out;
|
||||
}
|
||||
py_bytes = PyUnicode_AsUTF8String(py_item);
|
||||
Py_DECREF(py_item);
|
||||
if (!py_bytes)
|
||||
goto err_out;
|
||||
|
||||
str = g_strdup(PyBytes_AsString(py_bytes));
|
||||
Py_DECREF(py_bytes);
|
||||
if (!str)
|
||||
goto err_out;
|
||||
|
||||
strv[i] = str;
|
||||
}
|
||||
out[i] = NULL;
|
||||
*outstr = out;
|
||||
*out_strv = strv;
|
||||
|
||||
return SRD_OK;
|
||||
|
||||
err_out:
|
||||
g_strfreev(strv);
|
||||
srd_exception_catch(NULL, "Failed to obtain string item");
|
||||
|
||||
return SRD_ERR_PYTHON;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a Python scalar object to a GLib variant.
|
||||
* Supported variant types are string, int64 and double.
|
||||
*
|
||||
* @param[in] py_obj The Python object. Must not be NULL.
|
||||
* @return A floating reference to a new variant, or NULL on failure.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
SRD_PRIV GVariant *py_obj_to_variant(PyObject *py_obj)
|
||||
{
|
||||
GVariant *var = NULL;
|
||||
|
||||
if (PyUnicode_Check(py_obj)) { /* string */
|
||||
PyObject *py_bytes;
|
||||
const char *str;
|
||||
|
||||
py_bytes = PyUnicode_AsUTF8String(py_obj);
|
||||
if (py_bytes) {
|
||||
str = PyBytes_AsString(py_bytes);
|
||||
if (str)
|
||||
var = g_variant_new_string(str);
|
||||
Py_DECREF(py_bytes);
|
||||
}
|
||||
if (!var)
|
||||
srd_exception_catch(NULL, "Failed to extract string value");
|
||||
|
||||
} else if (PyLong_Check(py_obj)) { /* integer */
|
||||
int64_t val;
|
||||
|
||||
val = PyLong_AsLongLong(py_obj);
|
||||
if (!PyErr_Occurred())
|
||||
var = g_variant_new_int64(val);
|
||||
else
|
||||
srd_exception_catch(NULL, "Failed to extract integer value");
|
||||
|
||||
} else if (PyFloat_Check(py_obj)) { /* float */
|
||||
double val;
|
||||
|
||||
val = PyFloat_AsDouble(py_obj);
|
||||
if (!PyErr_Occurred())
|
||||
var = g_variant_new_double(val);
|
||||
else
|
||||
srd_exception_catch(NULL, "Failed to extract float value");
|
||||
|
||||
} else {
|
||||
srd_err("Failed to extract value of unsupported type.");
|
||||
}
|
||||
|
||||
return var;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user