Enhancement & features in python_if + other stuff

- Adds str & repr to RPNIterExpr
- Adds richcompare to RPNExpr
- Adds tests

python_const.c

@@ -14,6 +14,10 @@ PyModuleDef rpnconstmodule = {
 
 /* Various named tuple definition, instanciated in python_rpnexpr module init */
 static PyStructSequence_Field params_fields[] = {
+	{
+		.name = "argc",
+		.doc = "Number of arguments expected by expressions",
+	},
 	{	.name = "pos_flag",
 		.doc = "Position flag, indicating coordinate system",
 	},

python_if.c

@@ -270,10 +270,11 @@ with given arguments");
 /**@brief Returns the parameters in a named tuple */
 PyObject *rpnif_get_params(PyObject *self)
 {
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
 	PyObject *res, *val;
 	rpn_if_default_data_t *params;
 
-	params = (rpn_if_default_data_t*)(((PyRPNIterExpr_t*)self)->rif->params->data);
+	params = (rpn_if_default_data_t*)(expr_self->rif->params->data);
 
 	short expt_sizes[2];
 	if(rpn_if_sizes_from_flag(params->pos_flag, params->res_flag, expt_sizes) < 0)
@@ -287,12 +288,15 @@ PyObject *rpnif_get_params(PyObject *self)
 	{
 		return NULL;
 	}
-	val = PyLong_FromLong(params->pos_flag);
+	val = PyLong_FromLong(expr_self->rif->params->rpn_argc);
 	PyStructSequence_SET_ITEM(res, 0, val);
 
-	val = PyLong_FromLong(params->res_flag);
+	val = PyLong_FromLong(params->pos_flag);
 	PyStructSequence_SET_ITEM(res, 1, val);
 
+	val = PyLong_FromLong(params->res_flag);
+	PyStructSequence_SET_ITEM(res, 2, val);
+
 	if(params->pos_flag == RPN_IF_POSITION_XDIM)
 	{
 		expt_sizes[0] = params->size_lim[0] + 1;
@@ -304,7 +308,7 @@ PyObject *rpnif_get_params(PyObject *self)
 		Py_DECREF(res);
 		return NULL;
 	}
-	PyStructSequence_SET_ITEM(res, 2, lim);
+	PyStructSequence_SET_ITEM(res, 3, lim);
 
 	for(Py_ssize_t i=0; i<expt_sizes[0]; i++)
 	{
@@ -315,7 +319,7 @@ PyObject *rpnif_get_params(PyObject *self)
 	if(!params->const_val)
 	{
 		Py_INCREF(Py_None);
-		PyTuple_SET_ITEM(res, 3, Py_None);
+		PyTuple_SET_ITEM(res, 4, Py_None);
 	}
 	else
 	{
@@ -325,7 +329,7 @@ PyObject *rpnif_get_params(PyObject *self)
 			Py_DECREF(res);
 			return NULL;
 		}
-		PyStructSequence_SET_ITEM(res, 3, values);
+		PyStructSequence_SET_ITEM(res, 4, values);
 		for(Py_ssize_t i=0; i<expt_sizes[1]; i++)
 		{
 			val = PyLong_FromRpnValue_t(params->const_val[i]);
@@ -385,7 +389,7 @@ PyObject *rpnif_keys(PyObject *self)
 		case RPN_IF_POSITION_XDIM:
 			for(size_t i=0; i<rif_data->size_lim[0];i++)
 			{
-				snprintf(xdim_key, 64, "P%ld", i);
+				snprintf(xdim_key, 64, "D%ld", i);
 				_ret_append(xdim_key);
 			}
 			break;
@@ -509,7 +513,7 @@ PyObject* rpnif_expr_item(PyObject *self, Py_ssize_t idx)
 	{
 		idx = expr_self->rif->params->rpn_sz - 1 + idx;
 	}
-	if(idx < 0 || idx >= expr_self->rif->params->rpn_sz)
+	if(idx < 0 || (size_t) idx >= expr_self->rif->params->rpn_sz)
 	{
 		PyErr_Format(PyExc_IndexError,
 				"No expression %ld with given options",
@@ -599,7 +603,7 @@ static Py_ssize_t _rpnif_subscript_idx(PyObject *self, PyObject *_key)
 			char possible_key[64];
 			for(size_t i=0; i<ndim; i++)
 			{
-				snprintf(possible_key, 64, "P%ld", i);
+				snprintf(possible_key, 64, "D%ld", i);
 				if(!strcmp(possible_key, key))
 				{
 					idx = i;
@@ -750,23 +754,145 @@ void rpnif_releasebuffer(PyObject *self, Py_buffer *view)
 
 PyObject* rpnif_str(PyObject *self)
 {
-	PyErr_SetString(PyExc_NotImplementedError,
-		"str Not implemented");
-	return NULL;
-	/**@todo TODO write the function */
-	Py_RETURN_NONE;
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	rpn_if_default_data_t *rif_data = \
+		(rpn_if_default_data_t*)expr_self->rif->params->data;
+	const size_t rpn_sz = expr_self->rif->params->rpn_sz;
+	const char pyfmt[] = "%VA%ld=%U=\"%S\";";
+
+	size_t i;
+	PyObject *buf, *tmp, *items;
+
+	buf = NULL;
+	items = rpnif_items(self);
+	if(PyErr_Occurred()) { return NULL; }
+
+
+	for(i=0; i<rpn_sz; i++)
+	{
+		PyObject *key, *value, *elt;
+		elt = PyTuple_GET_ITEM(items, i);
+		key = PyTuple_GET_ITEM(elt, 0);
+		value = PyTuple_GET_ITEM(elt, 1);
+
+		tmp = PyUnicode_FromFormat(pyfmt,
+				buf, "",
+				i, key, value);
+		if(buf) { Py_DECREF(buf); }
+		if(PyErr_Occurred()) { return NULL; }
+		buf = tmp;
+	}
+
+
+	switch(rif_data->res_flag)
+	{
+		case RPN_IF_RES_CONST:
+			tmp = PyUnicode_FromFormat("%U A%ld=C(*)=%lld",
+					buf, i+1, rif_data->const_val[0]);
+			Py_DECREF(buf);
+			buf=tmp;
+			break;
+		case RPN_IF_RES_CONST_RGBA:
+			tmp = PyUnicode_FromFormat("%U A%ld=R(*)=%lld A%ld=G(*)=%lld A%ld=B(*)=%lld A%ld=A(*)=%lld",
+					buf,
+					i+1, rif_data->const_val[0],
+					i+2, rif_data->const_val[1],
+					i+3, rif_data->const_val[2],
+					i+4, rif_data->const_val[3]);
+			Py_DECREF(buf);
+			buf=tmp;
+			break;
+	}
+
+	Py_INCREF(buf);
+	return buf;
+}
+
+
+static PyObject* _rpnif_expr_repr(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;
+
+	PyObject *buf, *tmp, *items, *const_res;
+	const char pyfmt[] = "%V\"%U\":\"%S\"%V";
+
+	buf = const_res = NULL;
+
+	items = rpnif_items(self);
+	if(PyErr_Occurred()) { return NULL; }
+
+#define _const_res_key ",\"const_res\":"
+	switch(rif_data->res_flag)
+	{
+		case RPN_IF_RES_CONST:
+			const_res = PyUnicode_FromFormat(
+					_const_res_key "{\"r\":%llu}}",
+					rif_data->const_val[0]);
+			break;
+		/*
+		case RPN_IF_RES_CONST_RGB:
+			const_res = PyUnicode_FromFormat(
+					"\"const_res\": {\"r\":%llu, \"g\":%llu, \"b\":%llu}}",
+					rif_data->const_val[0],
+					rif_data->const_val[1],
+					rif_data->const_val[2])
+			break;
+		*/
+		case RPN_IF_RES_CONST_RGBA:
+			const_res = PyUnicode_FromFormat(
+					_const_res_key \
+					"{\"r\":%llu,\"g\":%llu,\"b\":%llu,\"a\":%llu}}",
+					rif_data->const_val[0],
+					rif_data->const_val[1],
+					rif_data->const_val[2],
+					rif_data->const_val[3]);
+			break;
+		default:
+			const_res = PyUnicode_FromFormat("}");
+			break;
+	}
+#undef _const_res_key
+
+	const size_t rpn_sz = expr_self->rif->params->rpn_sz;
+
+	for(size_t i=0; i<rpn_sz; i++)
+	{
+		PyObject *key, *value, *elt;
+		elt = PyTuple_GET_ITEM(items, i);
+		key = PyTuple_GET_ITEM(elt, 0);
+		value = PyTuple_GET_ITEM(elt, 1);
+
+		tmp = PyUnicode_FromFormat(pyfmt,
+				buf, "{", key, value,
+				i==rpn_sz-1?const_res:NULL, ",");
+		if(buf)
+		{
+			Py_DECREF(buf);
+		}
+		if(PyErr_Occurred())
+		{
+			return NULL;
+		}
+		buf = tmp;
+	}
+
+
+	return buf;
 }
 
 PyObject* rpnif_repr(PyObject *self)
 {
 	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];
 
+	PyObject *expr_repr = _rpnif_expr_repr(self);
+	if(PyErr_Occurred()) { return NULL; }
+
 	switch(rif_data->pos_flag)
 	{
 		case RPN_IF_POSITION_XY:
@@ -776,7 +902,7 @@ PyObject* rpnif_repr(PyObject *self)
 			str_pos = "LINEAR";
 			break;
 		case RPN_IF_POSITION_XDIM:
-			snprintf(tmp, 64, "XDIM[%ld]", rif_data->size_lim[0]);
+			snprintf(tmp, 64, "XDIM%ld", rif_data->size_lim[0]);
 			str_pos = tmp;
 			break;
 		default:
@@ -785,6 +911,8 @@ PyObject* rpnif_repr(PyObject *self)
 			return NULL;
 	}
 
+	PyObject *const_res = NULL;
+
 	switch(rif_data->res_flag)
 	{
 		case RPN_IF_RES_BOOL:
@@ -792,6 +920,7 @@ PyObject* rpnif_repr(PyObject *self)
 			break;
 		case RPN_IF_RES_CONST:
 			str_res = "CONST";
+			const_res = PyTuple_New(1);
 			break;
 		case RPN_IF_RES_CONST_RGBA:
 			str_res = "CONST_RGBA";
@@ -813,24 +942,15 @@ PyObject* rpnif_repr(PyObject *self)
 					"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;
-	}
+	PyObject *res;
+
+	const_res = const_res?const_res:Py_None;
 
-	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);
+	res = PyUnicode_FromFormat(
+			"<RPNIterExpr pos_flag:%s res_flag:%s expr:'%U' const_res:%S>",
+			str_pos, str_res, expr_repr, const_res);
+	if(PyErr_Occurred()) { return NULL; }
 	return res;
 }
 

python_rpnexpr.c

@@ -53,16 +53,21 @@ PySequenceMethods RPNExpr_seq_methods = {
 	.sq_ass_item = rpnexpr_token_ass_item,
 };
 
+
 PyTypeObject RPNExprType = {
 	PyVarObject_HEAD_INIT(NULL, 0)
 	.tp_name = "pyrpn.RPNExpr",
-	.tp_doc = "RPN expression evaluator",
+	.tp_doc = "RPN expression evaluator\n\
+\n\
+Instanciation :\n\
+RPNExpr(expression:str, args_count:int, stack_size:int=16)",
 	.tp_basicsize = sizeof(PyRPNExpr_t),
 	.tp_itemsize = 0,
 	.tp_del = rpnexpr_del,
 	.tp_repr = rpnexpr_repr,
 	.tp_str = rpnexpr_str,
 	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	.tp_richcompare = rpnexpr_richcompare,
 	.tp_methods = RPNExpr_methods,
 	.tp_as_sequence = &RPNExpr_seq_methods,
 	.tp_members = RPNExpr_members,
@@ -691,8 +696,9 @@ PyObject* rpnexpr_mutate(PyObject* slf, PyObject *args, PyObject *kwds)
 		return NULL;
 	}
 
-	if(!py_params)
+	if(!py_params || py_params == Py_None)
 	{
+		if(py_params == Py_None) { Py_DECREF(Py_None); }
 		memcpy(&params, &rpn_mutation_params_default,
 				sizeof(rpn_mutation_params_t));
 	}
@@ -763,6 +769,30 @@ PyObject* rpnexpr_repr(PyObject *self)
 	return res;
 }
 
+
+PyObject* rpnexpr_richcompare(PyObject *_self, PyObject *other, int op)
+{
+	PyObject *sta, *stb, *res;
+
+	if(!PyObject_IsInstance(other, (PyObject*)&RPNExprType))
+	{
+		PyErr_Format(PyExc_TypeError,
+				"Can only be compared with RPNExpr");
+		return NULL;
+	}
+
+	sta = rpnexpr_getstate(_self, NULL);
+	stb = rpnexpr_getstate(other, NULL);
+
+	res = PyObject_RichCompare(sta, stb, op);
+
+	Py_DECREF(sta);
+	Py_DECREF(stb);
+
+	return res;
+}
+
+
 PyObject* rpnexpr_random(PyObject *cls, PyObject *args, PyObject *kwds)
 {
 	long long int args_count, expr_sz;

python_rpnexpr.h

@@ -191,6 +191,8 @@ PyObject* rpnexpr_repr(PyObject *self);
  */
 PyObject* rpnexpr_str(PyObject *self);
 
+PyObject* rpnexpr_richcompare(PyObject *_self, PyObject *other, int op);
+
 /**@brief Return a new Python str with a random RPN expression
  * @param mod pyrpn module object
  * @param args Position arguments in Python list

python_rpntoken.c

@@ -217,6 +217,14 @@ PyObject* rpntoken_richcompare(PyObject *_self, PyObject *_other, int op)
 	self = (RPNToken_t*)_self;
 	other = (RPNToken_t*)_other;
 
+
+	if(!PyObject_IsInstance(_other, (PyObject*)&RPNTokenType))
+	{
+		PyErr_Format(PyExc_TypeError,
+				"Can only be compared with RPNToken subtypes");
+		return NULL;
+	}
+
 	int cmp = self->value.type - other->value.type;
 	if(cmp == 0)
 	{

rpn_if_default.c

@@ -1,7 +1,8 @@
 #include "rpn_if_default.h"
 
 rpn_if_param_t* rpn_if_default_params(short pos_flag, short res_flag,
-	const size_t *lim, const rpn_value_t *val, unsigned char rpn_stack_sz)
+	const size_t *lim, const rpn_value_t *res_const,
+	unsigned char rpn_stack_sz)
 {
 	rpn_if_param_t *res;
 	rpn_if_default_data_t *data;
@@ -85,13 +86,13 @@ rpn_if_param_t* rpn_if_default_params(short pos_flag, short res_flag,
 				pos_flag);
 			return NULL;
 	}
-	if(const_val_sz && !val)
+	if(const_val_sz && !res_const)
 	{
 		fprintf(stderr,
 			"Missing values when creating if params");
 		return NULL;
 	}
-	else if(!const_val_sz && val)
+	else if(!const_val_sz && res_const)
 	{
 		//Warning
 	}
@@ -119,7 +120,7 @@ rpn_if_param_t* rpn_if_default_params(short pos_flag, short res_flag,
 
 	if(const_val_sz)
 	{
-		memcpy(data->const_val, val, const_val_sz);
+		memcpy(data->const_val, res_const, const_val_sz);
 	}
 	else
 	{

rpn_if_default.h

@@ -107,7 +107,8 @@ struct rpn_if_default_data_s
  * @todo Implementation/testing
  */
 rpn_if_param_t* rpn_if_default_params(short pos_flag, short res_flag,
-	const size_t *lim, const rpn_value_t *val, unsigned char rpn_stack_sz);
+	const size_t *lim, const rpn_value_t *res_const,
+	unsigned char rpn_stack_sz);
 
 /** Fetch size limit and const values array sizes given flag values
  *  @param pos_flag (@ref ifs_if_default_posflag)

tests/tests_rpniter.py

@@ -146,6 +146,28 @@ class TestRPNIterInit(unittest.TestCase):
                     self.assertEqual(len(arr), expt_sz)
                     arr += 0x11111111 # check writing to all bytes
 
+    def test_str(self):
+        """ Test string representation of rif """
+
+        tests = [[pyrpn.const.POS_XY, pyrpn.const.RESULT_RGB, (1024,1024)],
+                 [pyrpn.const.POS_LINEAR, pyrpn.const.RESULT_CONST_RGBA, (1024,), (255,0,0,255)],
+                 [pyrpn.const.POS_XY, pyrpn.const.RESULT_CONST_RGBA, (640,480), (255,0,0,255)],
+                 [pyrpn.const.POS_LINEAR, pyrpn.const.RESULT_RGBA, (1024,)],
+                 [pyrpn.const.POS_XDIM, pyrpn.const.RESULT_RGB, (4, 2, 2, 640, 480)],
+        ]
+        for args in tests:
+            rif = pyrpn.RPNIterExpr(*args)
+            [expr.mutate(n_mutations=5) for expr in rif]
+            codes = {spl[1]:spl[2].strip('"')
+                     for spl in [s.split('=') for s in str(rif).split(';')
+                                 if len(s.strip())]}
+            argc = rif.get_params().argc
+            for key, orig in rif.items():
+                expr = pyrpn.RPNExpr(codes[key], argc)
+                with self.subTest(rif=rif, key=key, orig=orig, clone=expr):
+                    self.assertEqual(orig, expr)
+
+
 if __name__ == '__main__':
     unittest.main()
 

tests/tests_rpniter_seq.py

@@ -70,7 +70,7 @@ class TestRPNIterMapping(unittest.TestCase):
                  ([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']),
+                     ['D0', 'D1', 'D2', 'D3', 'R', 'G', 'B']),
         ]
         for args, keys in tests:
             rif=pyrpn.RPNIterExpr(*args)