Mario Fetka
601 lines
14 KiB
C
601 lines
14 KiB
C
#include <Python.h>
|
|
#include "structmember.h"
|
|
|
|
#include <bongojson.h>
|
|
#include <bongocal.h>
|
|
|
|
#include "libs.h"
|
|
|
|
XPL_BEGIN_C_LINKAGE
|
|
|
|
static PyMemberDef JsonObject_members[] = {
|
|
{ .name = NULL }
|
|
};
|
|
|
|
static PyMethodDef JsonObject_methods[] = {
|
|
{ .ml_name = NULL }
|
|
};
|
|
|
|
static PyMappingMethods JsonObject_mapping = {
|
|
.mp_length = JsonObject_length,
|
|
.mp_subscript = JsonObject_subscript,
|
|
.mp_ass_subscript = JsonObject_subscript_assign
|
|
};
|
|
|
|
PyTypeObject JsonObjectType = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
.tp_name = "libs.JsonObject",
|
|
.tp_basicsize = sizeof(JsonObject),
|
|
.tp_dealloc = (destructor)JsonObject_dealloc,
|
|
.tp_as_mapping = &JsonObject_mapping,
|
|
.tp_str = JsonObject_str,
|
|
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
|
|
.tp_doc = "Bongo Json Object",
|
|
.tp_methods = JsonObject_methods,
|
|
.tp_members = JsonObject_members,
|
|
.tp_init = (initproc)JsonObject_init,
|
|
.tp_new = JsonObject_new,
|
|
};
|
|
|
|
|
|
static PyMemberDef JsonArray_members[] = {
|
|
{ .name = NULL }
|
|
};
|
|
|
|
static PyMethodDef JsonArray_methods[] = {
|
|
{"append", JsonArray_append, METH_VARARGS, "Add a json object"},
|
|
{ .ml_name = NULL }
|
|
};
|
|
|
|
static PySequenceMethods JsonArray_sequence = {
|
|
.sq_length = JsonArray_length,
|
|
.sq_item = JsonArray_item,
|
|
};
|
|
|
|
#if 0
|
|
lenfunc sq_length;
|
|
binaryfunc sq_concat;
|
|
ssizeargfunc sq_repeat;
|
|
ssizeargfunc sq_item;
|
|
ssizessizeargfunc sq_slice;
|
|
ssizeobjargproc sq_ass_item;
|
|
ssizessizeobjargproc sq_ass_slice;
|
|
objobjproc sq_contains;
|
|
/* Added in release 2.0 */
|
|
binaryfunc sq_inplace_concat;
|
|
ssizeargfunc sq_inplace_repeat;
|
|
#endif
|
|
|
|
|
|
PyTypeObject JsonArrayType = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
.tp_name = "libs.JsonArray",
|
|
.tp_basicsize = sizeof(JsonArray),
|
|
.tp_dealloc = (destructor)JsonArray_dealloc,
|
|
.tp_as_sequence = &JsonArray_sequence,
|
|
.tp_str = JsonArray_str,
|
|
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
|
|
.tp_doc = "Bongo Json Array",
|
|
.tp_methods = JsonArray_methods,
|
|
.tp_members = JsonArray_members,
|
|
.tp_init = (initproc)JsonArray_init,
|
|
.tp_new = JsonArray_new,
|
|
};
|
|
|
|
static void
|
|
RaiseJsonError(BongoJsonResult res)
|
|
{
|
|
PyErr_Format(PyExc_ValueError, "Error parsing json: %d", res);
|
|
}
|
|
|
|
static BongoJsonNode *
|
|
JsonPyToNode(PyObject *obj)
|
|
{
|
|
BongoJsonNode *node;
|
|
|
|
if (obj == Py_None) {
|
|
return BongoJsonNodeNewNull();
|
|
} else if (PyBool_Check(obj)) {
|
|
if (obj == Py_False) {
|
|
node = BongoJsonNodeNewBool(FALSE);
|
|
} else {
|
|
node = BongoJsonNodeNewBool(TRUE);
|
|
}
|
|
} else if (PyInt_Check(obj)) {
|
|
node = BongoJsonNodeNewInt(PyInt_AsLong(obj));
|
|
} else if (PyLong_Check(obj)) {
|
|
node = BongoJsonNodeNewInt(PyLong_AsLong(obj));
|
|
} else if (PyFloat_Check(obj)) {
|
|
node = BongoJsonNodeNewDouble(PyFloat_AsDouble(obj));
|
|
} else if (PyString_Check(obj)) {
|
|
node = BongoJsonNodeNewString(PyString_AsString(obj));
|
|
} else if (PyUnicode_Check(obj)) {
|
|
PyObject *utf8 = PyUnicode_AsUTF8String(obj);
|
|
node = BongoJsonNodeNewString(PyString_AsString(utf8));
|
|
Py_DECREF(utf8);
|
|
} else if (PyList_Check(obj)) {
|
|
GArray *array;
|
|
int len = PyList_Size(obj);
|
|
int i;
|
|
|
|
array = g_array_sized_new(FALSE, FALSE, sizeof(BongoJsonNode*), len);
|
|
|
|
for (i=0; i<len; i++) {
|
|
BongoJsonNode *item = JsonPyToNode(PyList_GetItem(obj, i));
|
|
g_array_append_val(array, item);
|
|
}
|
|
|
|
node = BongoJsonNodeNewArray(array);
|
|
} else if (PyObject_IsInstance(obj, (PyObject*)&JsonObjectType)) {
|
|
JsonObject *json = ((JsonObject*)obj);
|
|
node = BongoJsonNodeNewObject(json->obj);
|
|
json->own = FALSE;
|
|
} else if (PyObject_IsInstance(obj, (PyObject*)&JsonArrayType)) {
|
|
JsonArray *json = ((JsonArray*)obj);
|
|
node = BongoJsonNodeNewArray(json->array);
|
|
json->own = FALSE;
|
|
} else {
|
|
node = NULL;
|
|
}
|
|
|
|
if (node == NULL) {
|
|
PyErr_SetString(PyExc_TypeError, "Creating JSON node from unsupported type");
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
PyObject *
|
|
JsonObjectToPy(BongoJsonObject *object, BOOL own)
|
|
{
|
|
PyObject *ret = (PyObject*)PyObject_New(JsonObject, &JsonObjectType);
|
|
((JsonObject*)ret)->obj = object;
|
|
((JsonObject*)ret)->own = own;
|
|
((JsonObject*)ret)->valid = TRUE;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static PyObject *
|
|
JsonObjectToPyNative(BongoJsonObject *obj)
|
|
{
|
|
PyObject *ret;
|
|
|
|
ret = PyDict_New();
|
|
|
|
BongoJsonObjectIter iter;
|
|
for (BongoJsonObjectIterFirst(obj, &iter);
|
|
iter.key != NULL;
|
|
BongoJsonObjectIterNext(obj, &iter)) {
|
|
PyObject *child;
|
|
child = JsonNodeToPy(iter.value, FALSE, TRUE);
|
|
if (!child) {
|
|
Py_DECREF(ret);
|
|
return NULL;
|
|
}
|
|
if (PyDict_SetItemString (ret, iter.key, child) == -1) {
|
|
Py_DECREF(ret);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static PyObject *
|
|
JsonArrayToPyNative(GArray *array)
|
|
{
|
|
PyObject *ret;
|
|
unsigned int i;
|
|
|
|
ret = PyList_New(0);
|
|
|
|
for (i = 0; i < array->len; i++) {
|
|
PyObject *child;
|
|
child = JsonNodeToPy (BongoJsonArrayGet(array, i), FALSE, TRUE);
|
|
if (!child) {
|
|
Py_DECREF(ret);
|
|
return NULL;
|
|
}
|
|
|
|
if (PyList_Append (ret, child) == -1) {
|
|
Py_DECREF(ret);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
PyObject *
|
|
JsonNodeToPy(BongoJsonNode *node, BOOL own, BOOL native)
|
|
{
|
|
PyObject *ret;
|
|
char *str;
|
|
|
|
switch(node->type) {
|
|
case BONGO_JSON_OBJECT :
|
|
if (native) {
|
|
return JsonObjectToPyNative(BongoJsonNodeAsObject(node));
|
|
} else {
|
|
ret = JsonObjectToPy(BongoJsonNodeAsObject(node), own);
|
|
}
|
|
break;
|
|
case BONGO_JSON_ARRAY :
|
|
if (native) {
|
|
return JsonArrayToPyNative(BongoJsonNodeAsArray (node));
|
|
} else {
|
|
ret = (PyObject*)PyObject_New(JsonArray, &JsonArrayType);
|
|
((JsonArray*)ret)->own = own;
|
|
((JsonArray*)ret)->array = BongoJsonNodeAsArray(node);
|
|
}
|
|
break;
|
|
case BONGO_JSON_BOOL :
|
|
if (BongoJsonNodeAsBool(node)) {
|
|
ret = Py_True;
|
|
} else {
|
|
ret = Py_False;
|
|
}
|
|
Py_INCREF(ret);
|
|
break;
|
|
case BONGO_JSON_DOUBLE :
|
|
ret = Py_BuildValue("d", BongoJsonNodeAsDouble(node));
|
|
break;
|
|
case BONGO_JSON_INT :
|
|
ret = PyLong_FromLongLong(BongoJsonNodeAsInt(node));
|
|
break;
|
|
case BONGO_JSON_STRING :
|
|
str = BongoJsonNodeAsString(node);
|
|
ret = PyUnicode_DecodeUTF8(str, strlen(str), NULL);
|
|
break;
|
|
default :
|
|
PyErr_Format(PyExc_ValueError, "Unknown node type: %d", node->type);
|
|
ret = NULL;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*** JsonArray ***/
|
|
|
|
void
|
|
JsonArray_dealloc(JsonArray *self)
|
|
{
|
|
if (self->own) {
|
|
BongoJsonArrayFree(self->array);
|
|
}
|
|
|
|
Py_TYPE(self)->tp_free((PyObject*)self);
|
|
}
|
|
|
|
PyObject *
|
|
JsonArray_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
{
|
|
JsonArray *self;
|
|
|
|
(void)args;
|
|
(void)kwds;
|
|
|
|
self = (JsonArray*)type->tp_alloc(type, 0);
|
|
self->own = FALSE;
|
|
self->array = NULL;
|
|
|
|
/* JsonArray is defined as a c subclass of the PyObject.
|
|
* i should be able to cast here safely because i'm casting
|
|
* a pointer either way */
|
|
return (PyObject *)self;
|
|
}
|
|
|
|
int
|
|
JsonArray_init(JsonArray *self, PyObject *args, PyObject *kwds)
|
|
{
|
|
(void)args;
|
|
(void)kwds;
|
|
self->own = TRUE;
|
|
self->array = g_array_sized_new(FALSE, FALSE, sizeof(BongoJsonNode*), 16);
|
|
return 0;
|
|
}
|
|
|
|
|
|
PyObject *
|
|
JsonArray_append(PyObject *selfp, PyObject *args)
|
|
{
|
|
JsonArray *self = (JsonArray*)selfp;
|
|
PyObject *obj;
|
|
BongoJsonNode *node;
|
|
|
|
if (!PyArg_ParseTuple(args, "O", &obj)) {
|
|
PyErr_SetString(PyExc_TypeError, "append() takes 1 argument");
|
|
return NULL;
|
|
}
|
|
|
|
node = JsonPyToNode(obj);
|
|
if (!node) {
|
|
return NULL;
|
|
}
|
|
|
|
BongoJsonArrayAppend(self->array, node);
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
PyObject *
|
|
JsonArray_str(PyObject *selfp)
|
|
{
|
|
JsonArray *self = (JsonArray *)selfp;
|
|
PyObject *ret;
|
|
char *str;
|
|
|
|
str = BongoJsonArrayToString(self->array);
|
|
|
|
ret = Py_BuildValue("s", str);
|
|
|
|
MemFree(str);
|
|
|
|
return ret;
|
|
}
|
|
|
|
Py_ssize_t
|
|
JsonArray_length(PyObject *selfp)
|
|
{
|
|
JsonArray *self = (JsonArray *)selfp;
|
|
return (self->array->len > 0) ? (Py_ssize_t)self->array->len : 0;
|
|
}
|
|
|
|
PyObject *
|
|
JsonArray_item(PyObject *selfp, Py_ssize_t i)
|
|
{
|
|
JsonArray *self = (JsonArray *)selfp;
|
|
BongoJsonNode *node;
|
|
|
|
if (i < 0 || i >= self->array->len) {
|
|
PyErr_SetString(PyExc_IndexError, "Out of bounds");
|
|
return NULL;
|
|
}
|
|
|
|
node = BongoJsonArrayGet(self->array, i);
|
|
|
|
return JsonNodeToPy(node, FALSE, FALSE);
|
|
}
|
|
|
|
/*** JsonObject ***/
|
|
|
|
void
|
|
JsonObject_dealloc(JsonObject *self)
|
|
{
|
|
#if 0
|
|
if (self->obj) {
|
|
BongoJsonObjectFree(self->obj);
|
|
}
|
|
#endif
|
|
|
|
Py_TYPE(self)->tp_free((PyObject*)self);
|
|
}
|
|
|
|
|
|
PyObject *
|
|
JsonObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
{
|
|
JsonObject *self;
|
|
|
|
(void)args;
|
|
(void)kwds;
|
|
|
|
self = (JsonObject*)type->tp_alloc(type, 0);
|
|
self->obj = NULL;
|
|
self->own = FALSE;
|
|
self->valid = TRUE;
|
|
|
|
/* JsonObject is defined as a c subclass of the PyObject.
|
|
* i should be able to cast here safely because i'm casting
|
|
* a pointer either way */
|
|
return (PyObject *)self;
|
|
}
|
|
|
|
int
|
|
JsonObject_init(JsonObject *self, PyObject *args, PyObject *kwds)
|
|
{
|
|
(void)args;
|
|
(void)kwds;
|
|
self->obj = BongoJsonObjectNew();
|
|
self->own = TRUE;
|
|
self->valid = TRUE;
|
|
return 0;
|
|
}
|
|
|
|
PyObject *
|
|
JsonObject_str(PyObject *selfp)
|
|
{
|
|
JsonObject *self = (JsonObject *)selfp;
|
|
PyObject *ret;
|
|
char *str;
|
|
|
|
str = BongoJsonObjectToString(self->obj);
|
|
|
|
ret = Py_BuildValue("s", str);
|
|
|
|
MemFree(str);
|
|
|
|
return ret;
|
|
}
|
|
|
|
Py_ssize_t
|
|
JsonObject_length(PyObject *self)
|
|
{
|
|
(void)self;
|
|
/* FIXME */
|
|
return 1;
|
|
}
|
|
|
|
PyObject *
|
|
JsonObject_subscript(PyObject *selfp, PyObject *key)
|
|
{
|
|
JsonObject *self = (JsonObject*)selfp;
|
|
char *str;
|
|
BongoJsonNode *node;
|
|
BongoJsonResult res;
|
|
|
|
if (!PyString_Check(key)) {
|
|
PyErr_SetString(PyExc_KeyError, "Key must be a string");
|
|
return NULL;
|
|
}
|
|
|
|
str = PyString_AsString(key);
|
|
|
|
res = BongoJsonObjectGet(self->obj, str, &node);
|
|
|
|
if (res != BONGO_JSON_OK) {
|
|
RaiseJsonError(res);
|
|
return NULL;
|
|
}
|
|
|
|
return JsonNodeToPy(node, FALSE, FALSE);
|
|
}
|
|
|
|
int
|
|
JsonObject_subscript_assign(PyObject *selfp, PyObject *key, PyObject *value)
|
|
{
|
|
JsonObject *self = (JsonObject*)selfp;
|
|
BongoJsonNode *node;
|
|
BongoJsonResult res;
|
|
|
|
node = JsonPyToNode(value);
|
|
if (!node) {
|
|
return 0;
|
|
}
|
|
|
|
if (!PyString_Check(key)) {
|
|
PyErr_SetString(PyExc_KeyError, "Key must be a string");
|
|
return 0;
|
|
}
|
|
|
|
res = BongoJsonObjectPut(self->obj, PyString_AsString(key), node);
|
|
if (res != BONGO_JSON_OK) {
|
|
RaiseJsonError(res);
|
|
return 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Static */
|
|
|
|
BOOL
|
|
BongoJsonPreInit(void)
|
|
{
|
|
JsonObjectType.tp_new = PyType_GenericNew;
|
|
if (PyType_Ready(&JsonObjectType) < 0) {
|
|
return FALSE;
|
|
}
|
|
|
|
JsonArrayType.tp_new = PyType_GenericNew;
|
|
if (PyType_Ready(&JsonArrayType) < 0) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
BongoJsonPostInit(PyObject *module)
|
|
{
|
|
Py_INCREF(&JsonObjectType);
|
|
PyModule_AddObject(module, "JsonObject", (PyObject *)&JsonObjectType);
|
|
Py_INCREF(&JsonArrayType);
|
|
PyModule_AddObject(module, "JsonArray", (PyObject *)&JsonArrayType);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static PyObject *
|
|
bongojson_BongoJsonParseString(PyObject *self, PyObject *args)
|
|
{
|
|
(void)self;
|
|
char *jsonStr;
|
|
BongoJsonNode *node;
|
|
BongoJsonResult res;
|
|
PyObject *ret;
|
|
PyObject *obj;
|
|
PyObject *strObj = NULL;
|
|
|
|
if (!PyArg_ParseTuple(args, "O", &obj)) {
|
|
PyErr_SetString(PyExc_TypeError, "ParseString takes one argument");
|
|
return NULL;
|
|
}
|
|
|
|
if (PyString_Check(obj)) {
|
|
jsonStr = PyString_AsString(obj);
|
|
} else if (PyUnicode_Check(obj)) {
|
|
strObj = PyUnicode_AsUTF8String(obj);
|
|
jsonStr = PyString_AsString(strObj);
|
|
} else {
|
|
PyErr_SetString(PyExc_TypeError, "Argument 1 must be a string or unicode object");
|
|
return NULL;
|
|
}
|
|
|
|
res = BongoJsonParseString(jsonStr, &node);
|
|
|
|
if (strObj) {
|
|
Py_DECREF(strObj);
|
|
}
|
|
|
|
if (res != BONGO_JSON_OK) {
|
|
RaiseJsonError(res);
|
|
return NULL;
|
|
}
|
|
|
|
/* Pull out the value and throw away the node */
|
|
ret = JsonNodeToPy(node, FALSE, FALSE);
|
|
if (node->type == BONGO_JSON_STRING) {
|
|
BongoJsonNodeFree(node);
|
|
} else {
|
|
BongoJsonNodeFreeSteal(node);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static PyObject *
|
|
bongojson_ToPy(PyObject *self, PyObject *args)
|
|
{
|
|
(void)self;
|
|
PyObject *obj;
|
|
PyObject *ret;
|
|
|
|
if (!PyArg_ParseTuple(args, "O", &obj)) {
|
|
PyErr_SetString(PyExc_TypeError, "ToPy takes one argument");
|
|
return NULL;
|
|
}
|
|
|
|
if (PyObject_IsInstance(obj, (PyObject*)&JsonObjectType)) {
|
|
JsonObject *json = ((JsonObject*)obj);
|
|
ret = JsonObjectToPyNative(json->obj);
|
|
if (!ret) {
|
|
PyErr_SetString(PyExc_RuntimeError, "Couldn't convert json to python");
|
|
return NULL;
|
|
}
|
|
return ret;
|
|
} else if (PyObject_IsInstance(obj, (PyObject*)&JsonArrayType)) {
|
|
JsonArray *json = ((JsonArray*)obj);
|
|
ret = JsonArrayToPyNative(json->array);
|
|
if (!ret) {
|
|
PyErr_SetString(PyExc_RuntimeError, "Couldn't convert json to python");
|
|
return NULL;
|
|
}
|
|
return ret;
|
|
} else {
|
|
PyErr_SetString(PyExc_TypeError, "Argument 1 must be a bongojson object or array");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
PyMethodDef BongoJsonMethods[] = {
|
|
{"ParseString", bongojson_BongoJsonParseString, METH_VARARGS | METH_STATIC, "Parse a json string"},
|
|
{"ToPy", bongojson_ToPy, METH_VARARGS | METH_STATIC, "Convert a json object to a native python object"},
|
|
{NULL, NULL, 0, NULL}
|
|
};
|
|
|
|
XPL_END_C_LINKAGE
|