Almost working commit

gte/__main__.py

@@ -16,12 +16,16 @@ logger = logging.getLogger()
 logger.debug('Logger started')
 
 from . import turmit, rpnlib
-from .turmit import Turmit
+#from .turmit import Turmit
+from cturmit import CTurmit as Turmit
 from .world import World, LivingTurmit, eval_prog
 from .mutator import mutate
 
 parser = argparse.ArgumentParser(description='Genetic Turmit Evolver')
 
+parser.add_argument('-L', '--list-op', action="store_const", default=False,
+                    const=True, help="List operations and exit")
+
 subparsers = parser.add_subparsers(help='sub-commands help')
 
 parser_evolve = subparsers.add_parser('evolve', help='evolving help')
@@ -112,7 +116,15 @@ parser_gen.add_argument('--threads', '-t', type=int, metavar='N',
 
 args = parser.parse_args()
 
-if 'pool_size' in args:
+if args.list_op:
+    from . import rpnlib
+    print("Operations list & aliases :")
+    for i, opname in enumerate(rpnlib._op_list):
+        alias = rpnlib._op_alias[opname] if opname in rpnlib._op_alias else ""
+        print("\t%02X: %8s\t%s" % (i, opname, alias))
+    exit(0)
+
+elif 'pool_size' in args:
     # Evolver
     if args.prog is None:
         prog = rpnlib.RpnExpr.random(args.prog_size)

gte/turmit.py

@@ -424,11 +424,11 @@ class Turmit(object):
             Condition type is encoded on an int : 
             - 0b0000 : je
             - 0b0001 : jne
-            - 0b0010 : jle
-            - 0b0011 : jl
+            - 0b0010 : jl
+            - 0b0011 : jle
             - 0b0100 : jg
             - 0b0101 : jge
-            - 0b0110 : jne
+            - 0b0110 : jmp
             - 0b0111 : jmp
 
             @param a int : operand

gte/world.py

@@ -12,7 +12,8 @@ import time
 import numpy as np
 from random import randint
 
-from .turmit import Turmit
+#from .turmit import Turmit
+from cturmit import CTurmit as Turmit
 
 logger = logging.getLogger()
 
@@ -169,6 +170,8 @@ class LivingTurmit(Turmit):
     ''' @brief Represent a Turmit with coordinates in a world '''
 
     def __init__(self, world, color = None, x=None, y=None, diag=True, **kwargs):
+        if 'prog' in kwargs:
+            kwargs['prog'] = str(kwargs['prog']).lower()
         super().__init__(**kwargs)
         
         if not isinstance(world, World):
@@ -228,6 +231,7 @@ class LivingTurmit(Turmit):
             r = g = b = self._world[self._y][self._x]
         else:
             r,g,b = self._world[self._y][self._x]
+        r = int(r); g=int(g); b=int(b)
         tdir = super().__call__(x=self._x, y=self._y, r=r, g=g, b=b)
         self.move(tdir)
 
@@ -253,7 +257,10 @@ class LivingTurmit(Turmit):
         ''' @brief Process a determinit score : determinist_expr / total expr
             @return float in [0.0..1.0]
         '''
-        return (self._determin_score + 1) / self._steps
+        try:
+            return (self._determin_score + 1) / self._steps
+        except AttributeError:
+            return 1
 
     def dirvar(self):
         ''' @brief Process @ref _dirvar to return a direction variation

libs/cturmit.c

@@ -102,11 +102,11 @@ but %ld found", sz);
 	PyMapping_DelItemString(kwds, "prog");
 	if(expr)
 	{
-		if(!PyUnicode_Check(expr))
+		if(!PyUnicode_Check(expr) && !(expr = PyObject_Str(expr)))
 		{
 			PyErr_Restore(errtype, errvalue, errbck);
 			PyErr_SetString(PyExc_TypeError,
-				"prog expected to be a string");
+				"prog expected to be a string !");
 			return -1;
 		}
 		expr = PyUnicode_AsASCIIString(expr);
@@ -155,8 +155,11 @@ but %ld found", sz);
 		TURMIT_AUTOCOMP);
 	if(self->turmit->err)
 	{
+		snprintf(err_msg, 128,
+			"Unable to compile '%s' err : %s", arg_expr,
+			self->turmit->err_str);
 		PyErr_SetString(PyExc_ValueError,
-			"Unable to compile given prog");
+			err_msg);
 		return -1;
 	}
 	return 0;
@@ -208,6 +211,15 @@ PyObject* CTurmit_call(PyObject *func, PyObject *args, PyObject *kwds)
 			Py_RETURN_NONE;
 		}
 		exec_args[i] = PyLong_AsUnsignedLongLong(arg);
+		if(PyErr_Occurred())
+		{
+			PyErr_Restore(errtype, errvalue, errbck);
+			snprintf(err_msg, 64, "An integer is required for %s",
+				argsname[i]);
+			PyErr_SetString(PyExc_TypeError,
+				err_msg);
+			Py_RETURN_NONE;
+		}
 	}
 
 	res = turmit_exec(self->turmit, exec_args);

libs/turmit.c

@@ -156,6 +156,7 @@ turmit_t *turmit_init(turmit_t *turmit, ssize_t stack_sz, ssize_t int_max,
 	turmit->stack_cur = turmit->stack_sz - 1;
 	turmit->stack = malloc(sizeof(turmit_int) * turmit->stack_sz);
 	turmit->err = 0;
+	turmit->err_str = NULL;
 
 	if(!turmit->stack)
 	{
@@ -173,6 +174,7 @@ turmit_t *turmit_init(turmit_t *turmit, ssize_t stack_sz, ssize_t int_max,
 
 void turmit_clean(turmit_t *turmit)
 {
+	if(turmit->err_str) { free(turmit->err_str); }
 	if(turmit->expr) { free(turmit->expr); }
 	if(turmit->op_expr) { free(turmit->op_expr); }
 
@@ -247,7 +249,7 @@ int turmit_compile(turmit_t *turmit)
 				perror("Unable to allocate memory");
 				goto turmit_compile_err;
 			}
-			bzero(&(pret[opcur - 1]),
+			bzero(pret + opcur - 1,
 				64 * sizeof(turmit_op_t));
 			turmit->op_expr = pret;
 		}
@@ -279,7 +281,7 @@ int turmit_compile(turmit_t *turmit)
 			cur+= 2;
 			iret = strtol(cur, &endptr, 16);
 			err = errno;
-			if(err)
+			if(err || endptr == cur)
 			{
 				fprintf(stderr, "Invalid constant %s : %s\n",
 					cur-2, strerror(err));
@@ -313,10 +315,19 @@ int turmit_compile(turmit_t *turmit)
 		isym = tsym;
 		while(isym->str != NULL)
 		{
-			if((strncasecmp(isym->str, cur, strlen(isym->str)) == 0) ||
-				(isym->alias && strncmp(cur, isym->alias,3) == 0))
+			endptr = cur;
+			if(strncasecmp(isym->str, cur, strlen(isym->str)) == 0)
+			{
+				endptr = cur+strlen(isym->str);
+			}
+			else if(isym->alias && strncmp(cur, isym->alias,
+					strlen(isym->alias)) == 0)
 			{
-				cur += strlen(isym->str);
+				endptr = cur+strlen(isym->alias);
+			}
+			if(cur != endptr)
+			{
+				cur = endptr;
 				turmit->op_expr[opcur].op.op = isym->op_fun;
 				turmit->op_expr[opcur].value = TURMIT_SYM_OP;
 				opcur++;
@@ -330,7 +341,16 @@ int turmit_compile(turmit_t *turmit)
 		}
 		//unrecognized symbol :'(
 		turmit->err = 1;
-		cur++;
+		if(turmit->err_str) { free(turmit->err_str); }
+		turmit->err_str = malloc(sizeof(char) * 256);
+		if(!turmit->err_str)
+		{
+			perror("Unable to allocate memory for error string");
+			return -1;
+		}
+		snprintf(turmit->err_str, 256,
+			"Error compiling prog starting at : '%s'", cur);
+		goto turmit_compile_err;
 	}
 	if(!opcur)
 	{	//empty expression

libs/turmit.h

@@ -97,7 +97,11 @@ struct turmit_s
 	turmit_int *stack;
 	ssize_t stack_cur;
 
+	/**@brief 0 if no error
+	 * @note only for compilation error for the moment
+	 */
 	char err;
+	char *err_str;
 };
 
 inline static turmit_int __SPOP(turmit_t *t) {