Make some test pass with CTurmit

gte/__init__.py

@@ -1,4 +1,13 @@
 ##@brief GTE Genetic Turmits Evolver
 
-from . import turmit
+try:
+	import cturmit as turmit
+	print(turmit.CTurmit)
+	Turmit = turmit.CTurmit
+	print("WOO")
+except ImportError:
+	from . import turmit
+	from .turmit import Turmit
+
+
 from . import rpnlib

libs/Makefile

@@ -1,15 +1,15 @@
 PYTHON=/usr/bin/python3
+CFLAGS=-Wall -Werror -O0 -g
+CC=gcc $(CFLAGS) 
+#CFLAGS=-Wall -Werror
 
 all: cturmit*.so
 
-turmit.o: turmit.c turmit.h
-	gcc -c turmit.c
-
-cturmit*.so: setup.py build/lib.*/cturmit*.so turmit.o
+cturmit*.so: setup.py build/lib.*/cturmit*.so
 	cp build/lib.*/cturmit*.so ./
 
-build/lib.*/cturmit*.so: cturmit.c cturmit.h
-	$(PYTHON) setup.py --verbose build
+build/lib.*/cturmit*.so: cturmit.c cturmit.h turmit.c turmit.h
+	make clean; CFLAGS="$(CFLAGS)" $(PYTHON) setup.py --verbose build
 
 .PHONY: clean
 

libs/cturmit.c

@@ -18,16 +18,185 @@ PyInit_cturmit(void)
 	return m;
 }
 
-	void
+static int
+CTurmit_init(CTurmit *self, PyObject *args, PyObject *kwds)
+{
+	size_t sz;
+	char err_msg[128];
+	ssize_t arg_stk_sz, arg_int_max;
+	char *arg_expr;
+	PyObject *stack_size, *int_max, *expr;
+	PyObject *errtype, *errvalue, *errbck;
+	
+	PyErr_Fetch(&errtype, &errvalue, &errbck);
+
+	stack_size = int_max = expr = NULL;
+	self->turmit = NULL;
+
+	//Checking arguments
+	if((sz = PySequence_Length(args)) >= 0)
+	{
+		if(sz > 1)
+		{
+			PyErr_Restore(errtype, errvalue, errbck);
+			snprintf(err_msg, 128, "1 positional argument expected \
+but %ld found", sz);
+			PyErr_SetString(PyExc_TypeError, err_msg);
+			return -1;
+		}
+		stack_size = PySequence_GetItem(args, 0);
+	}
+	if(!stack_size)
+	{
+		stack_size = stack_size?stack_size:\
+			PyMapping_GetItemString(kwds, "stack_size");
+		if(stack_size && !PyLong_CheckExact(stack_size))
+		{
+			PyErr_Restore(errtype, errvalue, errbck);
+			PyErr_SetString(PyExc_TypeError,
+				"stack_size expected to be an integer");
+			return -1;
+		}
+	}
+	if(stack_size)
+	{
+		arg_stk_sz = PyLong_AsSize_t(stack_size);
+		if(arg_stk_sz == (size_t)-1 && PyErr_Occurred())
+		{
+			PyErr_Restore(errtype, errvalue, errbck);
+			PyErr_SetString(PyExc_TypeError,
+				"size_t overflow with stack_size");
+			return -1;
+		}
+	}
+	else
+	{
+		arg_stk_sz = 8;
+	}
+
+	int_max = PyMapping_GetItemString(kwds, "int_max");
+	if(int_max && !PyLong_CheckExact(int_max))
+	{
+		PyErr_Restore(errtype, errvalue, errbck);
+		PyErr_SetString(PyExc_TypeError,
+			"stack_size expected to be an integer");
+		return -1;
+	}
+	if(int_max)
+	{
+		arg_int_max = PyLong_AsSize_t(stack_size);
+		if(arg_int_max == (size_t)-1 && PyErr_Occurred())
+		{
+			PyErr_SetString(PyExc_TypeError,
+				"size_t overflow with stack_size");
+		}
+	}
+	else
+	{
+		arg_int_max = 0x100000;
+	}
+
+	expr = PyMapping_GetItemString(kwds, "prog");
+	if(expr && !PyUnicode_Check(expr))
+	{
+		PyErr_Restore(errtype, errvalue, errbck);
+		PyErr_SetString(PyExc_TypeError,
+			"prog expected to be a string");
+		return -1;
+	}
+	if(expr)
+	{
+		expr = PyUnicode_AsASCIIString(expr);
+		if(!expr)
+		{
+			PyErr_Restore(errtype, errvalue, errbck);
+			PyErr_SetString(PyExc_TypeError,
+				"prog expected to be an ASCII string");
+			return -1;
+		}
+		arg_expr = (char*)PyBytes_AsString(expr);
+		if(!arg_expr)
+		{
+			PyErr_Restore(errtype, errvalue, errbck);
+			PyErr_SetString(PyExc_TypeError,
+				"Unable to convert prog to Cstring");
+			return -1;
+		}
+	}
+	else
+	{
+		arg_expr = "";
+	}
+
+	PyErr_Restore(errtype, errvalue, errbck);
+	self->turmit = turmit_alloc(arg_stk_sz, arg_int_max, arg_expr,
+		TURMIT_AUTOCOMP);
+	return 0;
+}
+
+static PyObject *
+CTurmit_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+	CTurmit *self;
+	self = (CTurmit *)type->tp_alloc(type, 0);
+	if(self != NULL) {
+		//do stuff
+	}
+	return (PyObject *)self;
+}
+
+void
 CTurmit_dealloc(CTurmit *self)
 {
+	if(self->turmit) { turmit_free(self->turmit); }
 	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-	Py_ssize_t
+Py_ssize_t
 CTurmit_len(CTurmit *self)
 {
 	return self->len;
 }
 
+PyObject* CTurmit__push(CTurmit* self, PyObject *args)
+{
+	char err_msg[128];
+	size_t sz;
+	turmit_int ival;
+	PyObject *val;
+	PyObject *errtype, *errvalue, *errbck;
+
+	PyErr_Fetch(&errtype, &errvalue, &errbck);
+
+	if((sz = PySequence_Length(args)) >= 0)
+	{
+		if(sz > 1)
+		{
+			PyErr_Restore(errtype, errvalue, errbck);
+			snprintf(err_msg, 128, "1 positional argument expected \
+but %ld found", sz);
+			PyErr_SetString(PyExc_TypeError, err_msg);
+			Py_RETURN_NONE;
+		}
+		val = PySequence_GetItem(args, 0);
+	}
+	if(!val)
+	{
+		PyErr_Restore(errtype, errvalue, errbck);
+		PyErr_SetString(PyExc_TypeError,
+			"Argument val is missing");
+		Py_RETURN_NONE;
+
+	}
+	ival = PyLong_AsSize_t(val);
+	if(ival == (size_t)-1 && PyErr_Occurred()) { Py_RETURN_NONE; }
+	SPUSH(self->turmit, ival);
+	PyErr_Restore(errtype, errvalue, errbck);
+	Py_RETURN_NONE;
+}
+
+PyObject* CTurmit_get__cur(CTurmit *self, void *ref)
+{
+	return PyLong_FromSsize_t(self->turmit->stack_cur);
+}
 

libs/cturmit.h

@@ -6,7 +6,9 @@
 typedef struct
 {
 	PyObject VAR_HEAD;
+	
 	Py_ssize_t len;
+	turmit_t *turmit;
 } CTurmit;
 
 static PyModuleDef cturmitmodule = {
@@ -28,38 +30,57 @@ static PyMemberDef CTurmit_members[] = {
 	{NULL}  /* Sentinel */
 };
 
+/*
+	Magic methods
+*/
 Py_ssize_t CTurmit_len(CTurmit*);
 
 static PyMappingMethods CTurmit_asmapping[] = {{
 	(void*)CTurmit_len,
 }};
 
+/*
+	Other methods
+*/
+#define TURMIT_PYOP(NAME) PyObject* CTurmit_op_##NAME(CTurmit* self) {\
+	turmit_op_##NAME(self->turmit);\
+	Py_RETURN_NONE;\
+}
+#define TURMIT_PYOPDEF(NAME) {#NAME, (PyCFunction)CTurmit_op_##NAME, \
+	METH_NOARGS, NULL}
+
+PyObject* CTurmit__push(CTurmit* self, PyObject *args);
+TURMIT_PYOP(add)
+
 static PyMethodDef CTurmit_methods[] = {
+	{"_push", (PyCFunction)CTurmit__push, METH_KEYWORDS | METH_VARARGS,
+		"Push a value on the stack"},
+	TURMIT_PYOPDEF(add),
 	{NULL}  /* Sentinel */
 };
 
+PyObject* CTurmit_get__cur(CTurmit *self, void *ref);
 
-	static PyObject *
-CTurmit_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-	CTurmit *self;
-	self = (CTurmit *)type->tp_alloc(type, 0);
-	if(self != NULL) {
-		//do stuff
-	}
-	return (PyObject *)self;
-}
+static struct PyGetSetDef CTurmit_getset[] = {
+	{"_cur", (getter)CTurmit_get__cur, NULL, NULL, NULL},
+	{NULL}  /* Sentinel */
+};
+
+static PyObject *
+CTurmit_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
+
+/**@brief CTurmit __init__ function
+ * @param CTurmit* self
+ * @param PyObject* can contain an interger representing stack size
+ * @param Pyobject* contains kwargs. Can be : stack_size, max_int, prog
+ */
+static int
+CTurmit_init(CTurmit *self, PyObject *args, PyObject *kwds);
 
 void
 CTurmit_dealloc(CTurmit *self);
 
-	static int
-CTurmit_init(CTurmit *self, PyObject *args, PyObject *kwds)
-{
-	//Init attributes
-	self->len = 0;
-	return 0;
-}
+
 
 static PyTypeObject CTurmitType = {
 	PyVarObject_HEAD_INIT(NULL, 0)
@@ -91,7 +112,7 @@ static PyTypeObject CTurmitType = {
 	0,						/* tp_iternext */
 	CTurmit_methods,				/* tp_methods */
 	CTurmit_members,				/* tp_members */
-	0,						/* tp_getset */
+	CTurmit_getset,					/* tp_getset */
 	0,						/* tp_base */
 	0,						/* tp_dict */
 	0,						/* tp_descr_get */

libs/turmit.c

@@ -10,6 +10,8 @@ TURMIT_OP(mem_sz)
 	new_sz = new_sz<2?2:new_sz;
 
 	new = realloc(turmit->stack, sizeof(turmit_int) * new_sz);
+	if(!new) { return; }
+	turmit->stack = new;
 	if(old_sz < new_sz)
 	{
 		bzero(turmit->stack + old_sz, new_sz - old_sz);
@@ -33,7 +35,8 @@ TURMIT_OP(bin_and)
 
 TURMIT_OP(dup)
 {
-	SPUSH(turmit, SCUR(turmit));
+	turmit_int a = SCUR(turmit);
+	SPUSH(turmit, a);
 }
 
 TURMIT_OP(lshift)
@@ -110,8 +113,8 @@ TURMIT_OP(jcmp)
 	cnd = SPOP(turmit);
 	b = SPOP(turmit);
 	a = SPOP(turmit);
-	if((cnd & 7 == 0 && a != b) || (cnd > 6) || (cnd & 1 && a == b) ||
-		(cnd & 7 > 2 && a < b) || (cnd & 7 > 4 && a > b))
+	if(((cnd & 7) == 0 && a != b) || (cnd > 6) || ((cnd & 1) && a == b) ||
+		((cnd & 7) > 2 && a < b) || ((cnd & 7) > 4 && a > b))
 	{
 		turmit->op_cur += offset - 1;
 	}
@@ -134,8 +137,6 @@ turmit_t *turmit_alloc(ssize_t stack_sz, ssize_t int_max, const char *expr,
 turmit_t *turmit_init(turmit_t *turmit, ssize_t stack_sz, ssize_t int_max,
 	const char *expr, unsigned char flags)
 {
-	int ret;
-
 	turmit->expr = strndup(expr, TURMIT_EXPR_MAX_SZ);
 	turmit->flags = flags;
 	turmit->int_max = int_max;
@@ -144,7 +145,7 @@ turmit_t *turmit_init(turmit_t *turmit, ssize_t stack_sz, ssize_t int_max,
 	turmit->op_cur = 0;
 	turmit->stack_sz = stack_sz;
 	turmit->stack = malloc(sizeof(turmit_int) * turmit->stack_sz);
-	turmit->stack_cur = 0;
+	turmit->stack_cur = turmit->stack_sz - 1;
 
 	if(turmit->flags & TURMIT_AUTOCOMP)
 	{
@@ -153,6 +154,19 @@ turmit_t *turmit_init(turmit_t *turmit, ssize_t stack_sz, ssize_t int_max,
 	return turmit;
 }
 
+void turmit_clean(turmit_t *turmit)
+{
+	if(turmit->expr) { free(turmit->expr); }
+	if(turmit->op_expr) { free(turmit->op_expr); }
+
+}
+
+void turmit_free(turmit_t *turmit)
+{
+	turmit_clean(turmit);
+	free(turmit);
+}
+
 turmit_int turmit_exec(turmit_t *turmit, const turmit_int args[5])
 {
 	turmit_op_t *op;
@@ -164,7 +178,7 @@ turmit_int turmit_exec(turmit_t *turmit, const turmit_int args[5])
 		switch(op->value)
 		{
 		case 1:
-			op->op.op(turmit, args);
+			op->op.op(turmit);
 			break;
 		case 2:
 			SPUSH(turmit, op->op.val);
@@ -185,8 +199,11 @@ turmit_int turmit_exec(turmit_t *turmit, const turmit_int args[5])
 
 int turmit_compile(turmit_t *turmit)
 {
-	char *cur, *endptr, *vptr;
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-braces"
 	turmit_sym_t tsym[] = TURMIT_OP_LST;
+#pragma GCC diagnostic pop
+	char *cur, *endptr;
 	turmit_sym_t *isym;
 	ssize_t opcur;
 	turmit_op_t *pret;
@@ -194,7 +211,6 @@ int turmit_compile(turmit_t *turmit)
 	int err;
 	int i;
 
-
 	turmit->op_expr_sz = 64;
 	turmit->op_expr = malloc(sizeof(turmit_op_t) * turmit->op_expr_sz);
 	bzero(turmit->op_expr, sizeof(turmit_op_t) * turmit->op_expr_sz);
@@ -204,7 +220,7 @@ int turmit_compile(turmit_t *turmit)
 	while(*cur != '\0')
 	{
 		if(opcur >= turmit->op_expr_sz - 1)
-		{
+		{	//more space needed
 			turmit->op_expr_sz += 64;
 			pret = realloc(turmit->op_expr,
 				sizeof(turmit_op_t) * turmit->op_expr_sz);
@@ -218,10 +234,14 @@ int turmit_compile(turmit_t *turmit)
 			turmit->op_expr = pret;
 		}
 		//Checking for separators
-		if(*cur == ' ' || *cur == '\t' || *cur == ' ') { continue; }
+		if(*cur == ' ' || *cur == '\t' || *cur == ' ')
+		{
+			cur++;
+			continue;
+		}
 
 		//Checking for variables
-		for(vptr = TURMIT_VAR_L; *vptr != '\0'; vptr++)
+		for(i=0; TURMIT_VAR_L[i] != '\0'; i++)
 		{
 			if(tolower(*cur) == TURMIT_VAR_L[i])
 			{
@@ -232,7 +252,7 @@ int turmit_compile(turmit_t *turmit)
 				break;
 			}
 		}
-		if(*vptr != '\0') { continue; }
+		if(TURMIT_VAR_L[i] != '\0') { continue; }
 
 		//Checking for values
 		if(strcasecmp("0x", cur) == 0)
@@ -258,7 +278,7 @@ int turmit_compile(turmit_t *turmit)
 		while(isym->str != NULL)
 		{
 			if(strcasecmp(isym->str, cur) == 0 ||
-				isym->alias != '\0' && *cur == isym->alias)
+				(isym->alias && strncmp(cur, isym->alias,3)))
 			{
 				cur += strlen(isym->str);
 				turmit->op_expr[opcur].op.op = isym->op_fun;

libs/turmit.h

@@ -1,3 +1,6 @@
+#ifndef _TURMIT_H_
+#define _TURMIT_H_
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -11,6 +14,7 @@ typedef unsigned long long int turmit_int;
 typedef struct turmit_op_s turmit_op_t;
 typedef struct turmit_s turmit_t;
 typedef struct turmit_sym_s turmit_sym_t;
+typedef void (*turmit_op_f)(turmit_t*);
 
 #define SCUR(t) (t->stack[t->stack_cur])
 #define SDEC(t) (t->stack_cur = (t->stack_cur>0?t->stack_cur:t->stack_sz) -1)
@@ -33,19 +37,21 @@ typedef struct turmit_sym_s turmit_sym_t;
 
 #define TURMIT_VAR_L		"xyrgb"
 
-#define TURMIT_OPSYM(NAME) {#NAME, '\0', op_##NAME}
-#define TURMIT_OPSYMALIAS(NAME, alias) {#NAME, alias, op_##NAME}
+#define TURMIT_OPSYM(NAME) {#NAME, NULL, turmit_op_##NAME}
+#define TURMIT_OPSYMALIAS(NAME, alias) {#NAME, alias, turmit_op_##NAME}
+
 
 // OPSYMALIAS has to be first !
 #define TURMIT_OP_LST {\
-	TURMIT_OPSYMALIAS(add, '+'),\
-	TURMIT_OPSYMALIAS(sub, '-'),\
-	TURMIT_OPSYMALIAS(mul, '*'),\
-	TURMIT_OPSYMALIAS(div, '/'),\
-	TURMIT_OPSYMALIAS(mod, '%'),\
-	TURMIT_OPSYMALIAS(bin_or, '|'),\
-	TURMIT_OPSYMALIAS(bin_and, '&'),\
-	TURMIT_OPSYMALIAS(bin_xor, '^'),\
+	TURMIT_OPSYMALIAS(add, "+"),\
+	TURMIT_OPSYMALIAS(sub, "-"),\
+	TURMIT_OPSYMALIAS(mul, "*"),\
+	TURMIT_OPSYMALIAS(div, "/"),\
+	TURMIT_OPSYMALIAS(mod, "%"),\
+	TURMIT_OPSYMALIAS(bin_or, "|"),\
+	TURMIT_OPSYMALIAS(bin_and, "&"),\
+	TURMIT_OPSYMALIAS(bin_xor, "^"),\
+	TURMIT_OPSYMALIAS(lshift, "<<"),\
 	TURMIT_OPSYM(mem_sz),\
 	TURMIT_OPSYM(dup),\
 	TURMIT_OPSYM(pop),\
@@ -59,13 +65,13 @@ typedef struct turmit_sym_s turmit_sym_t;
 struct turmit_sym_s
 {
 	char *str;
-	char alias;
-	void (*op_fun)(turmit_t*, const turmit_int[5]);
+	char *alias;
+	turmit_op_f op_fun;
 };
 
 union turmit_op_u
 {
-	void (*op)(turmit_t*, const turmit_int[5]);
+	turmit_op_f op;
 	turmit_int val;
 	short var; /*!< interpreted % 5 */
 };
@@ -99,8 +105,7 @@ inline static turmit_int __SPOP(turmit_t *t) {
 }
 
 
-#define TURMIT_OP(NAME) static void op_##NAME (turmit_t *turmit, \
-	const turmit_int args[5])
+#define TURMIT_OP(NAME) void turmit_op_##NAME (turmit_t *turmit)
 
 /**@brief Allocate memory and initialise a turmit
  * @param const char* The turmit expression
@@ -119,6 +124,8 @@ turmit_t *turmit_alloc(ssize_t stack_sz, ssize_t int_max, const char *expr,
 turmit_t *turmit_init(turmit_t *turmit, ssize_t stack_sz, ssize_t int_max,
 	const char *expr, unsigned char flags);
 
+void turmit_clean(turmit_t *turmit);
+
 /**@brief Free memory of a turmit
  * @param turmit the turmit to free
  */
@@ -136,3 +143,37 @@ turmit_int turmit_exec(turmit_t *turmit, const turmit_int args[5]);
  */
 int turmit_compile(turmit_t *turmit);
 
+TURMIT_OP(mem_sz);
+
+TURMIT_OP(add);
+
+TURMIT_OP(sub);
+
+TURMIT_OP(bin_and);
+
+TURMIT_OP(dup);
+
+TURMIT_OP(lshift);
+
+TURMIT_OP(mod);
+
+TURMIT_OP(mul);
+
+TURMIT_OP(div);
+
+TURMIT_OP(bin_or);
+
+TURMIT_OP(bin_xor);
+
+TURMIT_OP(pop);
+
+TURMIT_OP(swp);
+
+TURMIT_OP(jmp);
+
+TURMIT_OP(jz);
+
+TURMIT_OP(jcmp);
+
+#endif
+

tests/test_turmit.py

@@ -1,7 +1,10 @@
 import unittest
 import inspect
 
-from gte.turmit import Turmit
+import gte
+Turmit = gte.Turmit
+#from gte import Turmit
+print(Turmit)
 from gte.rpnlib import _op_list
 
 class TurmitTestCase(unittest.TestCase):