Continue implementation of RPNExprIter & sequences/mapping methods

python_const.c

@@ -1,5 +1,6 @@
 #include "python_const.h"
 
+/** @todo implement GC with m_clear */
 PyModuleDef rpnconstmodule = {
 	PyModuleDef_HEAD_INIT,
 	"pyrpn.const",
@@ -114,6 +115,7 @@ int Py_rpnconst_add(PyObject* mod, const char* name, int value)
 	return 0;
 }
 
+/** @todo rename this function ! (bad prefix) */
 PyObject *Py_rpnconst_init(void)
 {
 	PyObject *mod;

python_if.c

@@ -3,6 +3,14 @@
 PyMethodDef RPNIterExpr_methods[] = {
 	{"get_params", (PyCFunction)rpnif_get_params, METH_NOARGS,
 		"Get a named tuple with parameters"},
+	{"keys", (PyCFunction)rpnif_keys, METH_NOARGS,
+		"Get the list of keys identifing the expressions"},
+	{"values", (PyCFunction)rpnif_values, METH_NOARGS,
+		"Get the list of expressions"},
+	{"items", (PyCFunction)rpnif_items, METH_NOARGS,
+		"Iterate on couple of (key, expr)"},
+	{"step", (PyCFunction)rpnif_step, METH_O,
+		"Run an IF given a position and return the new position"},
 	{"__getstate__", (PyCFunction)rpnif_getstate, METH_NOARGS,
 		"Pickling method. Return a bytes repr of tokenized expression \
 and the stack state."},
@@ -17,6 +25,18 @@ PyMemberDef RPNIterExpr_members[] = {
 	{NULL}
 };
 
+PySequenceMethods RPNIterExpr_seq_methods = {
+	.sq_length = rpnif_len,
+	.sq_item = rpnif_expr_item,
+	.sq_ass_item = rpnif_expr_ass_item,
+};
+
+PyMappingMethods RPNIterExpr_mapping_methods = {
+	.mp_length = rpnif_len,
+	.mp_subscript = rpnif_subscript,
+	.mp_ass_subscript = rpnif_ass_subscript,
+};
+
 PyGetSetDef RPNIterExpr_getset[] = {
 	{NULL}
 };
@@ -29,44 +49,22 @@ static PyBufferProcs RPNIterExpr_as_buffer = {
 
 PyTypeObject RPNIterExprType = {
 	PyVarObject_HEAD_INIT(NULL, 0)
-	"pyrpn.RPNIterExpr",                     /* tp_name */
-	sizeof(PyRPNIterExpr_t),                        /* tp_basicsize */
-	0,                                               /* tp_itemsize */
-	(destructor)rpnif_del, /* tp_dealloc */
-	0,                                               /* tp_print */
-	0,                                               /* tp_getattr */
-	0,                                               /* tp_setattr */
-	0,                                               /* tp_reserved */
-	rpnif_repr,                                    /* tp_repr */
-	0,                                               /* tp_as_number */
-	0,                                               /* tp_as_sequence */
-	0,                              /* tp_as_mapping */
-	0,                                               /* tp_hash  */
-	0,                                               /* tp_call */
-	rpnif_str,                                               /* tp_str */
-	0,                                               /* tp_getattro */
-	0,                                               /* tp_setattro */
-	&RPNIterExpr_as_buffer,                           /* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT |
-	Py_TPFLAGS_BASETYPE,   /* tp_flags */
-	"RPN expression evaluator",                /* tp_doc */
-	0,                                               /* tp_traverse */
-	0,                                               /* tp_clear */
-	0,                                               /* tp_richcompare */
-	0,                                               /* tp_weaklistoffset */
-	0,                                               /* tp_iter */
-	0,                                               /* tp_iternext */
-	RPNIterExpr_methods,                        /* tp_methods */
-	RPNIterExpr_members,                        /* tp_members */
-	RPNIterExpr_getset,                              /* tp_getset */
-	0,                                               /* tp_base */
-	0,                                               /* tp_dict */
-	0,                                               /* tp_descr_get */
-	0,                                               /* tp_descr_set */
-	0,                                               /* tp_dictoffset */
-	rpnif_init,          /* tp_init */
-	0,                                               /* tp_alloc */
-	rpnif_new,                            /* tp_new */
+	.tp_name = "pyrpn.RPNIterExpr",
+	.tp_basicsize = sizeof(PyRPNIterExpr_t),
+	.tp_itemsize = 0,
+	.tp_del = rpnif_del,
+	.tp_repr = rpnif_repr,
+	.tp_as_sequence = &RPNIterExpr_seq_methods,
+	.tp_as_mapping = &RPNIterExpr_mapping_methods,
+	.tp_str = rpnif_str,
+	.tp_as_buffer = &RPNIterExpr_as_buffer,
+	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	.tp_doc = "RPN expression evaluator",
+	.tp_methods = RPNIterExpr_methods,
+	.tp_members = RPNIterExpr_members,
+	.tp_getset = RPNIterExpr_getset,
+	.tp_init = rpnif_init,
+	.tp_new = rpnif_new,
 };
 
 PyObject* rpnif_new(PyTypeObject *subtype, PyObject *args, PyObject* kwds)
@@ -337,11 +335,157 @@ PyObject *rpnif_get_params(PyObject *self)
 	return res;
 }
 
-void rpnif_del(PyObject *self)
+
+PyObject *rpnif_step(PyObject *self, PyObject* opos)
 {
-	PyRPNIterExpr_t *expr_self;
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	if(!PyLong_Check(opos))
+	{
+		PyErr_SetString(PyExc_TypeError, "Expected position to be an int");
+		return NULL;
+	}
+	size_t pos = PyLong_AsSize_t(opos);
+	if(PyErr_Occurred())
+	{
+		return NULL;
+	}
 
-	expr_self = (PyRPNIterExpr_t*)self;
+	pos = rpn_if_step(expr_self->rif, pos);
+
+	return PyLong_FromSize_t(pos);
+}
+
+
+PyObject *rpnif_keys(PyObject *self)
+{
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	rpn_if_default_data_t *rif_data = (rpn_if_default_data_t*)expr_self->rif->params->data;
+
+	Py_ssize_t ret_idx = 0;
+	char xdim_key[64];
+
+	PyObject *ret = PyTuple_New(expr_self->rif->params->rpn_sz);
+	if(PyErr_Occurred())
+	{
+		return NULL;
+	}
+
+#define _ret_append(key) PyTuple_SET_ITEM(ret, ret_idx++, \
+		PyUnicode_FromString(key))
+
+	switch(rif_data->pos_flag)
+	{
+		case RPN_IF_POSITION_XY:
+			_ret_append("X");
+			_ret_append("Y");
+			break;
+		case RPN_IF_POSITION_LINEAR:
+			_ret_append("X");
+			break;
+		case RPN_IF_POSITION_XDIM:
+			for(size_t i=0; i<rif_data->size_lim[0];i++)
+			{
+				snprintf(xdim_key, 64, "P%ld", i);
+				_ret_append(xdim_key);
+			}
+			break;
+		default:
+			PyErr_SetString(PyExc_RuntimeError,
+					"UNKOWN POS_FLAG3");
+			return NULL;
+	}
+	switch(rif_data->res_flag)
+	{
+		case RPN_IF_RES_BOOL:
+		case RPN_IF_RES_XFUN:
+			_ret_append("R");
+			break;
+		case RPN_IF_RES_RGB:
+			_ret_append("R");
+			_ret_append("G");
+			_ret_append("B");
+			break;
+		case RPN_IF_RES_RGBA:
+			_ret_append("R");
+			_ret_append("G");
+			_ret_append("B");
+			_ret_append("A");
+			break;
+		default:
+			break;
+	}
+
+	if(PyErr_Occurred())
+	{
+		return NULL;
+	}
+
+	return ret;
+
+#undef _ret_append
+}
+
+
+PyObject *rpnif_values(PyObject *self)
+{
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	Py_INCREF(expr_self->expr);
+	return expr_self->expr;
+}
+
+
+PyObject *rpnif_items(PyObject *self)
+{
+	size_t i;
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	PyObject *ret = PyTuple_New(expr_self->rif->params->rpn_sz);
+	if(PyErr_Occurred())
+	{
+		return NULL;
+	}
+	PyObject *keys = rpnif_keys(self);
+	for(i=0; i<expr_self->rif->params->rpn_sz; i++)
+	{
+		PyObject *tmp = PyTuple_New(2);
+		if(PyErr_Occurred())
+		{
+			goto err_loop_newtuple;
+		}
+		PyObject *key = PyTuple_GET_ITEM(keys, i);
+		PyObject *value = PyTuple_GET_ITEM(expr_self->expr, i);
+		Py_INCREF(key);
+		Py_INCREF(value);
+		PyTuple_SET_ITEM(tmp, 0, key);
+		PyTuple_SET_ITEM(tmp, 1, value);
+		PyTuple_SET_ITEM(ret, i, tmp);
+		if(PyErr_Occurred())
+		{
+			goto err_loop_setitem;
+		}
+
+				 
+	}
+	
+	return ret;
+
+	/** @todo cleanup seems wrong... */
+	for(i=i; i>=0; i--)
+	{
+err_loop_setitem:
+		PyObject *key = PyTuple_GET_ITEM(keys, i);
+		PyObject *value = PyTuple_GET_ITEM(expr_self->expr, i);
+		Py_DECREF(key);
+		Py_DECREF(value);
+err_loop_newtuple:
+	}
+	Py_DECREF(ret);
+	return NULL;
+}
+
+
+void rpnif_del(PyObject *self)
+{
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
 	if(expr_self->rif)
 	{
 		rpn_if_free(expr_self->rif);
@@ -349,6 +493,201 @@ void rpnif_del(PyObject *self)
 	}
 }
 
+
+Py_ssize_t rpnif_len(PyObject *self)
+{
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	return expr_self->rif->params->rpn_sz;
+}
+
+PyObject* rpnif_expr_item(PyObject *self, Py_ssize_t idx)
+{
+	Py_ssize_t _idx = idx;
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+
+	if(idx < 0)
+	{
+		idx = expr_self->rif->params->rpn_sz - 1 + idx;
+	}
+	if(idx < 0 || idx >= expr_self->rif->params->rpn_sz)
+	{
+		PyErr_Format(PyExc_IndexError,
+				"No expression %ld with given options",
+				_idx);
+		return NULL;
+	}
+	PyObject *ret = PyTuple_GET_ITEM(expr_self->expr, idx);
+	Py_INCREF(ret);
+	return ret;
+}
+
+
+int rpnif_expr_ass_item(PyObject *self, Py_ssize_t idx, PyObject* elt)
+{
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	
+	if(!PyUnicode_Check(elt))
+	{
+		PyErr_SetString(PyExc_TypeError, "RPNExpr expected");
+		return -1;
+	}
+
+	PyObject *bytes_str = PyUnicode_AsASCIIString(elt);
+	if(PyErr_Occurred())
+	{
+		return -1;
+	}
+	const char *code = PyBytes_AS_STRING(bytes_str);
+
+	rpn_expr_t *expr = &(expr_self->rif->rpn[idx]);
+
+	if(rpn_expr_recompile(expr, code) < 0)
+	{
+		PyErr_Format(PyExc_ValueError,
+				"Error during expression '%s' compilation : %s",
+				code, expr->err_reason);
+		return -1;
+	}
+
+	return 0;
+}
+
+static Py_ssize_t _rpnif_subscript_idx(PyObject *self, PyObject *_key)
+{
+	if(!PyUnicode_Check(_key))
+	{
+		PyErr_SetString(PyExc_TypeError, "Key should be a str");
+		return -1;
+	}
+	PyObject *bytes_str = PyUnicode_AsASCIIString(_key);
+	if(PyErr_Occurred())
+	{
+		return -1;
+	}
+	const char *key = PyBytes_AS_STRING(bytes_str);
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	rpn_if_default_data_t *rif_data = (rpn_if_default_data_t*)expr_self->rif->params->data;
+
+	Py_ssize_t idx = -1;
+	Py_ssize_t res_idx = -1;
+
+	switch(rif_data->pos_flag)
+	{
+		case RPN_IF_POSITION_XY:
+			res_idx = 2;
+			if(key[1] != '\0') { break; }
+			switch(key[0])
+			{
+				case 'X':
+					idx=0;
+					break;
+				case 'Y':
+					idx=1;
+					break;
+			}
+			break;
+		case RPN_IF_POSITION_LINEAR:
+			res_idx = 1;
+			if(!strcmp("X", key))
+			{
+				idx = 0;
+			}
+			break;
+		case RPN_IF_POSITION_XDIM:
+			size_t ndim = rif_data->size_lim[0];
+			res_idx = ndim;
+			char possible_key[64];
+			for(size_t i=0; i<ndim; i++)
+			{
+				snprintf(possible_key, 64, "P%ld", i);
+				if(!strcmp(possible_key, key))
+				{
+					idx = i;
+					break;
+				}
+			}
+			break;
+		default:
+			PyErr_SetString(PyExc_RuntimeError,
+					"UNKOWN POS_FLAG");
+			return -1;
+	}
+	if(idx < 0)
+	{
+		// not found yet, looking for result key
+		switch(rif_data->res_flag)
+		{
+			case RPN_IF_RES_BOOL:
+			case RPN_IF_RES_XFUN:
+				if(!strcmp("R", key))
+				{
+					idx = res_idx;
+				}
+				break;
+			case RPN_IF_RES_RGBA:
+				if(!strcmp("A", key))
+				{
+					idx = res_idx + 3;
+				}
+			case RPN_IF_RES_RGB:
+				if(key[1] != '\0')
+				{
+					break;
+				}
+				switch(key[0])
+				{
+					case 'R':
+						idx=res_idx;
+						break;
+					case 'G':
+						idx=res_idx+1;
+						break;
+					case 'B':
+						idx=res_idx+2;
+						break;
+				}
+				break;
+			default:
+				// not implemented, not unknown....
+				PyErr_SetString(PyExc_RuntimeError,
+						"UNKOWN RES_FLAG");
+				return -1;
+		}
+	}
+	return idx;
+}
+
+PyObject* rpnif_subscript(PyObject *self, PyObject *key)
+{
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	
+	Py_ssize_t idx = _rpnif_subscript_idx(self, key);
+	if(idx < 0)
+	{
+		PyErr_Format(PyExc_IndexError,
+				"No expression '%s' with given parameters",
+				key);
+		return NULL;
+	}
+	PyObject *expr = PyTuple_GET_ITEM(expr_self->expr, idx);
+	Py_INCREF(expr);
+	return expr;
+}
+
+int rpnif_ass_subscript(PyObject *self, PyObject *key, PyObject *elt)
+{
+	Py_ssize_t idx = _rpnif_subscript_idx(self, key);
+	if(idx < 0)
+	{
+		PyErr_Format(PyExc_IndexError,
+				"Cannot set expression '%s' that do not exists with this parameters",
+				key);
+		return -1;
+	}
+
+	return rpnif_expr_ass_item(self, idx, elt);
+}
+
 int rpnif_getbuffer(PyObject *self, Py_buffer *view, int flags)
 {
 	PyRPNIterExpr_t *expr_self;
@@ -412,7 +751,7 @@ void rpnif_releasebuffer(PyObject *self, Py_buffer *view)
 PyObject* rpnif_str(PyObject *self)
 {
 	PyErr_SetString(PyExc_NotImplementedError,
-		"Not implemented");
+		"str Not implemented");
 	return NULL;
 	/**@todo TODO write the function */
 	Py_RETURN_NONE;
@@ -420,17 +759,85 @@ PyObject* rpnif_str(PyObject *self)
 
 PyObject* rpnif_repr(PyObject *self)
 {
-	PyErr_SetString(PyExc_NotImplementedError,
-		"Not implemented");
-	return NULL;
-	/**@todo TODO write the function */
-	Py_RETURN_NONE;
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	char *buff;
+	size_t sz;
+	rpn_if_default_data_t *rif_data = (rpn_if_default_data_t*)expr_self->rif->params->data;
+
+	char *str_pos, *str_res;
+	char tmp[64];
+
+	switch(rif_data->pos_flag)
+	{
+		case RPN_IF_POSITION_XY:
+			str_pos = "XY";
+			break;
+		case RPN_IF_POSITION_LINEAR:
+			str_pos = "LINEAR";
+			break;
+		case RPN_IF_POSITION_XDIM:
+			snprintf(tmp, 64, "XDIM[%ld]", rif_data->size_lim[0]);
+			str_pos = tmp;
+			break;
+		default:
+			PyErr_SetString(PyExc_RuntimeError,
+					"UNKOWN POS_FLAG2");
+			return NULL;
+	}
+
+	switch(rif_data->res_flag)
+	{
+		case RPN_IF_RES_BOOL:
+			str_res = "BOOL";
+			break;
+		case RPN_IF_RES_CONST:
+			str_res = "CONST";
+			break;
+		case RPN_IF_RES_CONST_RGBA:
+			str_res = "CONST_RGBA";
+			break;
+		case RPN_IF_RES_COUNT:
+			str_res = "COUNT";
+			break;
+		case RPN_IF_RES_XFUN:
+			str_res = "XFUN";
+			break;
+		case RPN_IF_RES_RGB:
+			str_res = "RGB";
+			break;
+		case RPN_IF_RES_RGBA:
+			str_res = "RGBA";
+			break;
+		default:
+			PyErr_SetString(PyExc_RuntimeError,
+					"UNKOWN RES_FLAG2");
+			return NULL;
+	}
+
+	sz = snprintf(NULL, 0,
+			"<RPNIterExpr pos_flag:%s res_flag:%s expr_sz:%ld>",
+			str_pos, str_res, expr_self->rif->params->rpn_sz);
+	
+	buff = malloc(sizeof(char) * (sz + 1));
+	if(!buff)
+	{
+		PyErr_Format(PyExc_RuntimeError, "Error allocating RPNIterExpr repr : ",
+				strerror(errno));
+		return NULL;
+	}
+
+	sz = snprintf(buff, sz+1,
+			"<RPNIterExpr pos_flag:%s res_flag:%s expr_sz:%ld>",
+			str_pos, str_res, expr_self->rif->params->rpn_sz);
+	PyObject *res = Py_BuildValue("s", buff);
+	free(buff);
+	return res;
 }
 
 PyObject* rpnif_getstate(PyObject *self, PyObject *noargs)
 {
 	PyErr_SetString(PyExc_NotImplementedError,
-		"Not implemented");
+		"getstate Not implemented");
 	return NULL;
 	/**@todo TODO write the function */
 	Py_RETURN_NONE;
@@ -439,7 +846,7 @@ PyObject* rpnif_getstate(PyObject *self, PyObject *noargs)
 PyObject* rpnif_setstate(PyObject *self, PyObject *state_bytes)
 {
 	PyErr_SetString(PyExc_NotImplementedError,
-		"Not implemented");
+		"setstate Not implemented");
 	return NULL;
 	/**@todo TODO write the function */
 	Py_RETURN_NONE;

python_if.h

@@ -108,6 +108,9 @@ void rpnif_releasebuffer(PyObject *self, Py_buffer *view);
 /**@brief Return a named tuple of custom rif data */
 PyObject *rpnif_get_params(PyObject *self);
 
+/**@brief Runs an if on given */
+PyObject *rpnif_step(PyObject *self, PyObject* pos);
+
 /**@brief Return the list of expressions */
 PyObject *rpnif_get_expr(PyObject *self);
 
@@ -140,5 +143,22 @@ PyObject* rpnif_repr(PyObject *self);
  */
 PyObject* rpnif_str(PyObject *self);
 
+/**@brief RPNExpr.__len__() method
+ * @return A integer with the number of tokens in expression
+ */
+Py_ssize_t rpnif_len(PyObject *self);
+
+PyObject* rpnif_expr_item(PyObject *self, Py_ssize_t);
+int rpnif_expr_ass_item(PyObject *self, Py_ssize_t idx, PyObject* elt);
+
+
+PyObject* rpnif_subscript(PyObject *self, PyObject *key);
+int rpnif_ass_subscript(PyObject *self, PyObject *key, PyObject *elt);
+
+PyObject *rpnif_keys(PyObject *self);
+PyObject *rpnif_values(PyObject *self);
+PyObject *rpnif_items(PyObject *self);
+
+
 #endif
 

python_rpnexpr.c

@@ -46,9 +46,11 @@ PyMemberDef RPNExpr_members[] = {
 	{NULL}
 };
 
+/**@todo Continue sequence implementation with contains, concat, repeat etc. */
 PySequenceMethods RPNExpr_seq_methods = {
 	.sq_length = rpnexpr_len,
 	.sq_item = rpnexpr_token_item,
+	.sq_ass_item = rpnexpr_token_ass_item,
 };
 
 PyTypeObject RPNExprType = {
@@ -536,6 +538,79 @@ PyObject* rpnexpr_token_item(PyObject *self, Py_ssize_t idx)
 }
 
 
+int rpnexpr_token_ass_item(PyObject *self, Py_ssize_t idx, PyObject* elt)
+{
+	PyRPNExpr_t *expr_self = (PyRPNExpr_t*)self;
+	Py_ssize_t _idx = idx;
+	if(idx < 0)
+	{
+		idx = expr_self->rpn->toks.tokens_sz - 1 + idx;
+	}
+	if(idx < 0 || idx > expr_self->rpn->toks.tokens_sz)
+	{
+		PyErr_Format(PyExc_IndexError,
+			"Cannot set token %ld in expression of size %ld",
+			_idx, expr_self->rpn->toks.tokens_sz);
+		return -1;
+	}
+
+	if(!PyObject_IsInstance(elt, (PyObject*)&RPNTokenType))
+	{
+		PyErr_Format(PyExc_TypeError,
+				"Given element in not RPNToken subtype");
+		return -1;
+	}
+
+	short new_elt = 0;
+	if(idx == expr_self->rpn->toks.tokens_sz)
+	{
+		new_elt = 1;
+		expr_self->rpn->toks.tokens_sz++;
+		size_t new_sz = expr_self->rpn->toks.tokens_sz*sizeof(rpn_token_t);
+		rpn_token_t *tmp = realloc(expr_self->rpn->toks.tokens, new_sz);
+		if(!tmp)
+		{
+			PyErr_Format(PyExc_MemoryError,
+					"Error reallocation tokenized expression : %s",
+					strerror(errno));
+			return -1;
+		}
+		expr_self->rpn->toks.tokens = tmp;
+	}
+
+	rpn_token_t original = expr_self->rpn->toks.tokens[idx];
+
+	RPNToken_t *token = (RPNToken_t*)elt;
+	expr_self->rpn->toks.tokens[idx] = token->value;
+	if(rpn_expr_tokens_updated(expr_self->rpn) < 0)
+	{
+		PyErr_Format(PyExc_ValueError,
+				"Unable to update expression : %s",
+				strerror(errno));
+		goto rollback;
+	}
+	return 0;
+
+rollback:
+	if(new_elt)
+	{
+		expr_self->rpn->toks.tokens_sz--;
+	}
+	else
+	{
+		expr_self->rpn->toks.tokens[idx] = original;
+		if(rpn_expr_tokens_updated(expr_self->rpn) < 0)
+		{
+			PyErr_Format(PyExc_RuntimeError,
+					"Unable to rollback expression : %s",
+					strerror(errno));
+			goto rollback;
+		}
+	}
+	return -1;
+}
+
+
 PyObject* rpnexpr_eval(PyObject* self, PyObject** argv, Py_ssize_t argc)
 {
 	PyRPNExpr_t *expr_self;

python_rpnexpr.h

@@ -43,8 +43,6 @@
  *
  * This file is the header of the RPNExpr Python class
  *
- * @todo implements tp_as_sequence in order to give access to tokens from
- * expr. To do this we have to implement a python module representing tokens.
  */
 
 /**@brief RPNExpr Python class methods list
@@ -154,6 +152,7 @@ PyObject* rpnexpr_copy(PyObject *cls, PyObject *noargs);
 Py_ssize_t rpnexpr_len(PyObject *self);
 
 PyObject* rpnexpr_token_item(PyObject *self, Py_ssize_t);
+int rpnexpr_token_ass_item(PyObject *self, Py_ssize_t idx, PyObject* elt);
 
 /**@brief Eval an RPN expression given arguments and return the
  * value

python_rpntoken.c

@@ -13,6 +13,7 @@ PyTypeObject RPNTokenType = {
 	.tp_basicsize = sizeof(RPNToken_t),
 	.tp_itemsize = 0,
 	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	.tp_richcompare = rpntoken_richcompare,
 	.tp_init = rpntoken_init,
 	.tp_new = PyType_GenericNew,
 	.tp_str = rpntoken_str,
@@ -210,6 +211,61 @@ int rpntoken_init(PyObject *_self, PyObject *args, PyObject *kwds)
 	return -1;
 }
 
+PyObject* rpntoken_richcompare(PyObject *_self, PyObject *_other, int op)
+{
+	RPNToken_t *self, *other;
+	self = (RPNToken_t*)_self;
+	other = (RPNToken_t*)_other;
+
+	int cmp = self->value.type - other->value.type;
+	if(cmp == 0)
+	{
+		switch(self->value.type)
+		{
+			case RPN_op:
+				cmp = self->value.op_n - other->value.op_n;
+				break;
+			case RPN_arg:
+				cmp = self->value.arg_n - other->value.arg_n;
+				break;
+			case RPN_val:
+				cmp = self->value.value - other->value.value;
+				break;
+			default:
+				PyErr_Format(PyExc_RuntimeError,
+						"Unknown token type %d",
+						self->value.type);
+				return NULL;
+		}
+	}
+
+	switch(op)
+	{
+		case Py_LT:
+			if(cmp < 0) { Py_RETURN_TRUE; }
+			Py_RETURN_FALSE;
+		case Py_LE:
+			if(cmp <= 0) { Py_RETURN_TRUE; }
+			Py_RETURN_FALSE;
+		case Py_EQ:
+			if(cmp == 0) { Py_RETURN_TRUE; }
+			Py_RETURN_FALSE;
+		case Py_NE:
+			if(cmp != 0) { Py_RETURN_TRUE; }
+			Py_RETURN_FALSE;
+		case Py_GT:
+			if(cmp > 0) { Py_RETURN_TRUE; }
+			Py_RETURN_FALSE;
+		case Py_GE:
+			if(cmp >= 0) { Py_RETURN_TRUE; }
+			Py_RETURN_FALSE;
+		default:
+			PyErr_Format(PyExc_NotImplementedError,
+					"Unknown comparison %d",
+					self->value.type);
+			return NULL;
+	}
+}
 
 PyObject* rpntoken_repr(PyObject *_self)
 {

python_rpntoken.h

@@ -66,6 +66,7 @@ PyObject* rpntoken_from_str(PyObject *_self, PyObject *arg);
 PyObject* rpntoken_from_token(const rpn_token_t *token);
 
 int rpntoken_init(PyObject *_self, PyObject *args, PyObject *kwds);
+PyObject* rpntoken_richcompare(PyObject *_self, PyObject *other, int op);
 PyObject* rpntoken_str(PyObject *_self);
 PyObject* rpntoken_repr(PyObject *_self);
 

rpn_if.c

@@ -95,6 +95,7 @@ rpn_if_t* rpn_if_new(const rpn_if_param_t *params, rpn_value_t *memmap)
 			#endif
 			goto rpn_init_error;
 		}
+		rpn_expr_compile(&(res->rpn[i]), "");
 	}
 
 	return res;
@@ -113,7 +114,7 @@ rpn_if_t* rpn_if_new(const rpn_if_param_t *params, rpn_value_t *memmap)
 		err = errno;
 		if(res->self_mem)
 		{
-			munmap(res->mem, params->mem_sz);
+			munmap(res->mem, params->mem_sz * params->value_sz);
 		}
 	mmap_err:
 		err = errno;
@@ -135,19 +136,19 @@ void rpn_if_free(rpn_if_t* rif)
 	free(rif->rpn_res);
 	if(rif->self_mem)
 	{
-		munmap(rif->mem, rif->params->mem_sz);
+		munmap(rif->mem, rif->params->mem_sz * rif->params->value_sz);
 	}
 	free(rif);
 }
 
 size_t rpn_if_step(rpn_if_t *rif, size_t pos)
 {
-	size_t i;
 	size_t newpos;
 	rif->params->getarg_f(rif, pos);
-	for(i=0; i<rif->params->rpn_sz; i++)
+	for(size_t i=0; i<rif->params->rpn_sz; i++)
 	{
-		rif->rpn_res[i] = rpn_expr_eval(&(rif->rpn[i]), rif->rpn_args);
+		rpn_value_t res = rpn_expr_eval(&(rif->rpn[i]), rif->rpn_args);
+		rif->rpn_res[i] = res;
 	}
 	rif->params->setres_f(rif, &newpos);
 	return newpos;

rpn_if.h

@@ -126,6 +126,7 @@ size_t rpn_if_step(rpn_if_t *rif, size_t pos);
  */
 rpn_expr_t **rpn_if_rpn_get(rpn_if_t *rif);
 
+
 /**@brief New @ref rpn_if_s and partial initialisation
  * @param mem_sz memory size in bytes
  * @param rpn_argc number of arguments taken by @ref rpn_expr_s

rpn_jit.c

@@ -87,6 +87,16 @@ int rpn_expr_reinit(rpn_expr_t* expr)
 	return 0;
 }
 
+
+int rpn_expr_recompile(rpn_expr_t *expr, const char *code)
+{
+	if(rpn_expr_reinit(expr) < 0)
+	{
+		return -1;
+	}
+	return rpn_expr_compile(expr, code);
+}
+
 int rpn_expr_tokens_updated(rpn_expr_t* expr)
 {
 	if(rpn_expr_reinit(expr) < 0)
@@ -103,6 +113,7 @@ int rpn_expr_tokens_updated(rpn_expr_t* expr)
 		free(expr->expr);
 	}
 	expr->expr = rpn_tokenized_expr(&expr->toks, 0);
+	expr->state = RPN_READY;
 	return 0;
 }
 
@@ -165,7 +176,7 @@ int rpn_expr_untokenize(rpn_expr_t *expr, rpn_tokenized_t *tokens, char long_op)
 		if(_rpn_expr_token_copy(expr, &(tokens->tokens[i])) < 0)
 		{
 			err = errno;
-			if(errno == EINVAL)
+			if(errno == EUCLEAN)
 			{
 				dprintf(2,
 "Fatal error, unknown token type : %d.\nMemory corruption ?\n",
@@ -311,7 +322,7 @@ int _rpn_expr_compile_expr(rpn_expr_t* expr)
 	{
 		if(_rpn_expr_token_copy(expr, token) < 0)
 		{
-			if(errno == EINVAL)
+			if(errno == EUCLEAN)
 			{
 				dprintf(2,
 "Fatal error, unknown token type : %d chr %ld.\nMemory corruption ?\n",
@@ -357,7 +368,7 @@ int _rpn_expr_compile_tokens(rpn_expr_t* expr)
 		token = &(expr->toks.tokens[i]);
 		if(_rpn_expr_token_copy(expr, token) < 0)
 		{
-			if(errno == EINVAL)
+			if(errno == EUCLEAN)
 			{
 				dprintf(2,
 "Fatal error, unknown token type : %d\nMemory corruption ?\n",
@@ -438,6 +449,11 @@ int _rpn_expr_token_copy(rpn_expr_t *expr, rpn_token_t *token)
 			value = NULL;
 			break;
 		case RPN_arg:
+			if(expr->args_count <= token->arg_n)
+			{
+				errno = EINVAL;
+				return -1;
+			}
 			local_op.fun = &rpn_arg;
 			local_op.fun_sz = &(CODE_SZ(rpn_arg));
 			value = &(token->arg_n);
@@ -448,7 +464,7 @@ int _rpn_expr_token_copy(rpn_expr_t *expr, rpn_token_t *token)
 			value = &(token->value);
 			break;
 		default:
-			errno = EINVAL;
+			errno = EUCLEAN;
 			return -1;
 	}
 	if(_rpn_code_part_cpy(expr, local_op.fun, *(local_op.fun_sz),

rpn_jit.h

@@ -152,6 +152,13 @@ int rpn_expr_init(rpn_expr_t* expr, const unsigned char stack_sz,
  */
 int rpn_expr_reinit(rpn_expr_t* expr);
 
+/**@brief Recompile an existing, allready initialized, expression
+ * @param rpn_expr_t* The expression
+ * @param const char * The code to compile
+ * @return 0 if no error else -1
+ */
+int rpn_expr_recompile(rpn_expr_t *expr, const char *code);
+
 /**@brief Takes into account modifications in token representation
  * @param rpn_expr_t*
  * @return 0 if no error else -1

tests/tests_pyrpn.py

@@ -126,10 +126,11 @@ class Test0RpnModule(unittest.TestCase):
                         if tok not in counters:
                             counters[tok] = 0
                         counters[tok] += 1
-        all_ops = len(pyrpn.get_ops()) + 2
+        all_ops = len(pyrpn.get_ops()) + 1
         entropy = 1-sum([(n/all_count)**2
                           for _, n in counters.items()])
         self.assertGreater(entropy, 1-(1/all_ops), "Low entropy !")
-   
+ 
+
 if __name__ == '__main__':
     unittest.main()

tests/tests_rpn_sequence.py

@@ -1,20 +1,20 @@
 #!/usr/bin/python3
-# Copyright 2023 Weber Yann
+# copyright 2023 weber yann
 #
-# This file is part of rpnifs.
+# this file is part of rpnifs.
 #
 #        geneifs is free software: you can redistribute it and/or modify
-#        it under the terms of the GNU General Public License as published by
-#        the Free Software Foundation, either version 3 of the License, or
+#        it under the terms of the gnu general public license as published by
+#        the free software foundation, either version 3 of the license, or
 #        (at your option) any later version.
 #
 #        geneifs 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 General Public License for more details.
+#        but without any warranty; without even the implied warranty of
+#        merchantability or fitness for a particular purpose.  see the
+#        gnu general public license for more details.
 #
-#        You should have received a copy of the GNU General Public License
-#        along with geneifs.  If not, see <http://www.gnu.org/licenses/>.
+#        you should have received a copy of the gnu general public license
+#        along with geneifs.  if not, see <http://www.gnu.org/licenses/>.
 #
 
 import copy
@@ -26,8 +26,8 @@ import unittest
 
 try:
     import pyrpn
-except (ImportError, NameError) as e:
-    print("Error importing pyrpn. Try to run make.",
+except (importerror, nameerror) as e:
+    print("error importing pyrpn. try to run make.",
           file=sys.stderr)
     raise e
 
@@ -60,6 +60,61 @@ class TestRpnExprCopy(unittest.TestCase):
             with self.subTest(expr=expr, expected_len=elen):
                 self.assertEqual(len(expr), elen)
 
+    def test_getter(self):
+        """ Test __getitem__ """
+        tests = ((['0x42', '+', 'A0'], 1),
+                 (['A0'], 1))
+        for test in tests:
+            elts, nargs = test
+            expr_str = ' '.join(elts)
+            expr = pyrpn.RPNExpr(expr_str, nargs)
+            with self.subTest(expr=expr):
+                for i in range(len(expr)):
+                    self.assertEqual(expr[i],
+                            pyrpn.tokens.Token.from_str(elts[i]))
+
+    def test_setter(self):
+        """ Testing __setitem__ """
+        expr = pyrpn.RPNExpr('A0 A1 +', 2)
+        for _ in range(1024):
+            a0, a1 = (random.randint(0, 0x10000) for _ in range(2))
+            res = expr.eval(a0, a1)
+            self.assertEqual(res, a0+a1)
+
+        expr[2] = pyrpn.tokens.Operand('*')
+        self.assertEqual(str(expr), 'A0 A1 *')
+        for _ in range(1024):
+            a0, a1 = (random.randint(0, 0x1000) for _ in range(2))
+            res = expr.eval(a0, a1)
+            self.assertEqual(res, a0*a1)
+
+    def test_setter_append(self):
+        """ Testing __setitem__ to append new token """
+        expr = pyrpn.RPNExpr('A0 A1', 2)
+        expr[2] = pyrpn.tokens.Operand('+')
+        for _ in range(1024):
+            a0, a1 = (random.randint(0, 0x10000) for _ in range(2))
+            res = expr.eval(a0, a1)
+            self.assertEqual(res, a0+a1)
+
+    def test_setter_err_check_arg(self):
+        """ Testing __setitem__ errors on invalid argument number"""
+        for argcnt in range(1,10):
+            expr = pyrpn.RPNExpr('0x0', argcnt)
+            for argno in range(argcnt):
+                expr[0] = pyrpn.tokens.Argument(argno)
+            for argno in range(argcnt, 0x100):
+                with self.assertRaises(ValueError):
+                    expr[0] = pyrpn.tokens.Argument(argno)
+
+    def test_setter_err_check_idx(self):
+        """ Testing __setitem__ errors on invalid index"""
+        for elen in range(100):
+            expr = pyrpn.RPNExpr(pyrpn.random_expr(2, elen), 2)
+            for pos in range(len(expr)+1, 0x100):
+                with self.assertRaises(IndexError):
+                    expr[pos] = pyrpn.tokens.Value(0x1)
+
 
 if __name__ == '__main__':
     unittest.main()

tests/tests_rpniter.py

@@ -1,4 +1,41 @@
 #!/usr/bin/python3
+# copyright 2023 weber yann
+#
+# this file is part of rpnifs.
+#
+#        geneifs is free software: you can redistribute it and/or modify
+#        it under the terms of the gnu general public license as published by
+#        the free software foundation, either version 3 of the license, or
+#        (at your option) any later version.
+#
+#        geneifs 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 general public license for more details.
+#
+#        you should have received a copy of the gnu general public license
+#        along with geneifs.  if not, see <http://www.gnu.org/licenses/>.
+#
+
+import copy
+import pickle
+import random
+import sys
+
+import unittest
+
+try:
+    import pyrpn
+except (importerror, nameerror) as e:
+    print("error importing pyrpn. try to run make.",
+          file=sys.stderr)
+    raise e
+
+
+class TestRpnExprCopy(unittest.TestCase):
+    """ Testing RPNExpr sequence method """
+
+
 import unittest
 import warnings
 

tests/tests_rpniter_seq.py

@@ -0,0 +1,100 @@
+#!/usr/bin/python3
+# copyright 2023 weber yann
+#
+# this file is part of rpnifs.
+#
+#        geneifs is free software: you can redistribute it and/or modify
+#        it under the terms of the gnu general public license as published by
+#        the free software foundation, either version 3 of the license, or
+#        (at your option) any later version.
+#
+#        geneifs 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 general public license for more details.
+#
+#        you should have received a copy of the gnu general public license
+#        along with geneifs.  if not, see <http://www.gnu.org/licenses/>.
+#
+
+import copy
+import pickle
+import random
+import sys
+
+import unittest
+
+try:
+    import pyrpn
+except (importerror, nameerror) as e:
+    print("error importing pyrpn. try to run make.",
+          file=sys.stderr)
+    raise e
+
+
+class TestRpnIterSequence(unittest.TestCase):
+    """ Testing RPNIterExpr sequence methods """
+
+    def test_len(self):
+        """ Testing RPNIterExpr.__len__ with various values/constants """
+        tests = [([pyrpn.const.POS_XY, pyrpn.const.RESULT_RGB, (1024,1024)],
+                   5),
+                 ([pyrpn.const.POS_LINEAR, pyrpn.const.RESULT_CONST_RGBA, (1024,), (255,0,0,255)],
+                   1),
+                 ([pyrpn.const.POS_XY, pyrpn.const.RESULT_CONST_RGBA, (640,480), (255,0,0,255)],
+                   2),
+                 ([pyrpn.const.POS_LINEAR, pyrpn.const.RESULT_RGBA, (1024,)],
+                   5),
+                 ([pyrpn.const.POS_XDIM, pyrpn.const.RESULT_RGB, (4, 2, 2, 640, 480)],
+                  7),
+        ]
+        for args, expt_len in tests:
+            rif=pyrpn.RPNIterExpr(*args)
+            with self.subTest(rif=rif, expt_len=expt_len, args=args):
+                self.assertEqual(expt_len, len(rif))
+
+
+
+class TestRPNIterMapping(unittest.TestCase):
+    """ Testing RPNIterExpr mapping methods """
+
+
+    def test_keys(self):
+        """ Testing RPNIterExpr.__getitem__ with various values/constants """
+        tests = [([pyrpn.const.POS_XY, pyrpn.const.RESULT_RGB, (1024,1024)],
+                  ['X', 'Y', 'R', 'G', 'B']),
+                 ([pyrpn.const.POS_LINEAR, pyrpn.const.RESULT_CONST_RGBA, (1024,), (255,0,0,255)],
+                   ['X']),
+                 ([pyrpn.const.POS_XY, pyrpn.const.RESULT_CONST_RGBA, (640,480), (255,0,0,255)],
+                   ['X', 'Y']),
+                 ([pyrpn.const.POS_LINEAR, pyrpn.const.RESULT_RGBA, (1024,)],
+                   ['X', 'R', 'G', 'B', 'A']),
+                 ([pyrpn.const.POS_XDIM, pyrpn.const.RESULT_RGB, (4, 2, 2, 640, 480)],
+                     ['P0', 'P1', 'P2', 'P3', 'R', 'G', 'B']),
+        ]
+        for args, keys in tests:
+            rif=pyrpn.RPNIterExpr(*args)
+            for curkey in keys:
+                with self.subTest(rif=rif, key=curkey):
+                    expr = rif[curkey]
+            expt = set(keys)
+            self.assertEqual(set(rif.keys()), expt)
+            for key, value in rif.items():
+                with self.subTest(item=(key, value), id1=id(rif[key]),
+                        id2=id(value), rif=rif):
+                    self.assertEqual(rif[key], value)
+
+    def test_assignement(self):
+        """ Testing RPNIterExpr.__setitem__ """
+        rif = pyrpn.RPNIterExpr(pyrpn.const.POS_XY, pyrpn.const.RESULT_RGB, (1024,1024))
+        rif['X'] = 'A0 A1 +'
+        for _ in range(1000):
+            a, b = [random.randint(0,0xFFFF) for _  in range(2)]
+            args = (a,b, 0,0,0)
+            self.assertEqual(a+b, rif['X'].eval(*args))
+            self.assertEqual(0, rif['Y'].eval(*args))
+
+
+if __name__ == '__main__':
+    unittest.main()
+

tests/tests_tokens.py

@@ -0,0 +1,92 @@
+#!/usr/bin/python3
+# copyright 2023 weber yann
+#
+# this file is part of rpnifs.
+#
+#        geneifs is free software: you can redistribute it and/or modify
+#        it under the terms of the gnu general public license as published by
+#        the free software foundation, either version 3 of the license, or
+#        (at your option) any later version.
+#
+#        geneifs 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 general public license for more details.
+#
+#        you should have received a copy of the gnu general public license
+#        along with geneifs.  if not, see <http://www.gnu.org/licenses/>.
+#
+import random
+import sys
+
+import unittest
+
+try:
+    import pyrpn
+except (importerror, nameerror) as e:
+    print("error importing pyrpn. try to run make.",
+          file=sys.stderr)
+    raise e
+
+
+class TestTokens(unittest.TestCase):
+    """ Testing tokens module """
+
+    def test_argument(self):
+        """ Testing tokens.Argument type  init """
+        for argno in range(1024):
+            arg = pyrpn.tokens.Argument(argno)
+            with self.subTest(argno=argno, arg=arg):
+                self.assertEqual(arg.argno, argno)
+
+    def test_value(self):
+        """ Testing tokens.Value type init """
+        for _ in range(1024):
+            v = random.randint(0, 0xFFFFFFFF)
+            val = pyrpn.tokens.Value(v)
+            with self.subTest(val=v, token_value=val):
+                self.assertEqual(val.value, v)
+
+    def test_op(self):
+        """ Testing tokens.Operand type init """
+        for opcode in range(pyrpn.tokens.Operand.opcode_max()+1):
+            operand = pyrpn.tokens.Operand(opcode)
+            with self.subTest(opcode=opcode, operand=operand):
+                self.assertEqual(opcode, operand.opcode)
+
+            op_fromstr = pyrpn.tokens.Operand(str(operand))
+            with self.subTest(from_str=op_fromstr, opcode=opcode):
+                self.assertEqual(opcode, op_fromstr.opcode)
+
+    def test_cmp(self):
+        """ Testing token comparison """
+        tests = {
+                'lt': ([('A0', 'A1'), ('0x10', '0x11'), ('-', '/'),
+                        ('-', 'A0'), ('-', '0x1'), ('A0', '0x1')],
+                       [('A1', 'A0'), ('0x11', '0x10'), ('/', '-'),
+                        ('A0', '-'), ('0x1000', '+'), ('0x0', 'A1')]),
+                'eq': [[('A0', 'A0'), ('0x1', '0x1'), ('+', '+')],
+                       []]
+        }
+        tests['gt'] = (tests['lt'][1], tests['lt'][0])
+        tests['le'] = [tests['lt'][i] + tests['eq'][i] for i in range(2)]
+        tests['ge'] = [tests['gt'][i] + tests['eq'][i] for i in range(2)]
+        tests['eq'][1] = [('A0', '0x0'), ('A0', '+'), ('0x0', '+')] 
+
+        assertions = {'lt': (self.assertLess, self.assertGreaterEqual),
+                'le': (self.assertLessEqual, self.assertGreater),
+                'eq': (self.assertEqual, self.assertNotEqual),
+                'gt': (self.assertGreater, self.assertLessEqual),
+                'ge': (self.assertGreaterEqual, self.assertLess)}
+
+        for comparison, (cmp_true, cmp_false) in tests.items():
+            assert_true, assert_false = assertions[comparison]
+            lst = [(assert_true, cmp_true), (assert_false, cmp_false)]
+            for assertion, cmplist in lst:
+                for test in cmplist:
+                    a=pyrpn.tokens.Token.from_str(test[0])
+                    b=pyrpn.tokens.Token.from_str(test[1])
+                    with self.subTest(assertion=assertion, a=a, b=b):
+                        assertion(a, b)
+
+