Bugfixes & enhancement in CTurmit init

Allowing copy

gte/world.py

     w = World(args.world_height, args.world_width, gray=True)
     logger.debug('Running P%d run#%d %s' % (progid, trynum, prog))
     w.raz()
-    turmits = [LivingTurmit(world=w, prog=prog, diag=not args.no_diagonals)
+    base = LivingTurmit(world=w, prog=prog, diag=not args.no_diagonals)
+    turmits = [ LivingTurmit(world=w, turmit=base)
                for _ in range(args.turmit_count)]
 
     start = time.time()

libs/cturmit.c

 	ssize_t arg_stk_sz, arg_int_max;
 	char *arg_expr;
 	int i;
+	CTurmit *turmit;
 	PyObject *stack_size, *int_max, *expr, *keys;
 	PyObject *errtype, *errvalue, *errbck;
 	
 	PyErr_Fetch(&errtype, &errvalue, &errbck);
+	turmit  = (CTurmit*)PyMapping_GetItemString(kwds, "turmit");
+	if(turmit)
+	{
+		return _CTurmit_copy_init(self, turmit);
+	}
+	PyErr_Restore(errtype, errvalue, errbck);
 
 	stack_size = int_max = expr = NULL;
 	self->turmit = NULL;
 	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
+static int _CTurmit_copy_init(CTurmit *self, CTurmit *t)
+{
+	self->turmit = turmit_copy(t->turmit);
+	if(!self->turmit)
+	{
+		//set error
+		return -1;
+	}
+	return 0;
+}
+
 PyObject* CTurmit_call(PyObject *func, PyObject *args, PyObject *kwds)
 {
 	turmit_int res;

libs/cturmit.h

 	{NULL}  /* Sentinel */
 };
 
+static int _CTurmit_copy_init(CTurmit *self, CTurmit *t);
+
 static PyObject *
 CTurmit_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
 

libs/turmit.c

 	return turmit;
 }
 
+turmit_t *turmit_copy(turmit_t *turmit)
+{
+	turmit_t *res;
+	res = malloc(sizeof(turmit_t));
+	if(!res)
+	{
+		perror("Unable to allocate memory for copy");
+		return NULL;
+	}
+	memcpy(res, turmit, sizeof(turmit_t));
+	if(turmit->expr)
+	{
+		res->expr = strdup(turmit->expr);
+	}
+	if(turmit->stack)
+	{
+		res->stack = malloc(sizeof(turmit_int) * res->stack_sz);
+		memcpy(res->stack, turmit->stack,
+			sizeof(turmit_int) * res->stack_sz);
+	}
+	if(turmit->op_expr)
+	{
+		res->op_expr = malloc(sizeof(turmit_op_t) * res->op_expr_sz);
+		if(!res->op_expr)
+		{
+			perror("Unable to allocate memory for expression");
+			return res;
+		}
+		memcpy(res->op_expr, turmit->op_expr,
+			sizeof(turmit_op_t) * res->op_expr_sz);
+	}
+	return res;
+}
+
 void turmit_clean(turmit_t *turmit)
 {
 	if(turmit->err_str) { free(turmit->err_str); }
 
 		//Checking for values
 		//hex
-		if(strcasecmp("0x", cur) == 0)
+		if(strncasecmp("0x", cur, 2) == 0)
 		{
 			cur+= 2;
 			iret = strtol(cur, &endptr, 16);
 		{
 			iret = strtol(cur, &endptr, 10);
 			err = errno;
-			if(err)
+			if(err || endptr == cur)
 			{
 				fprintf(stderr, "Invalid constant %s : %s\n",
 					cur, strerror(err));

libs/turmit.h

 turmit_t *turmit_init(turmit_t *turmit, ssize_t stack_sz, ssize_t int_max,
 	const char *expr, unsigned char flags);
 
+turmit_t *turmit_copy(turmit_t *turmit);
+
 void turmit_clean(turmit_t *turmit);
 
 /**@brief Free memory of a turmit

tests/test_cturmit.py

         r = t(x=2, y=2, r=255, g=0, b=0)
         self.assertEqual(r, 3)
 
+    def test_copy(self):
+        t = Turmit(prog = 'G R B ADD ADD 42 MOD', max_int = 0xFFFF,
+                   stack_size=42)
+        t2 = Turmit(turmit=t)
+        r = t2(x=1, y=2, r=255, g=255, b=255)
+        self.assertEqual(r, 9)
+        r = t2(x=2, y=2, r=255, g=0, b=0)
+        self.assertEqual(r, 3)
+        
+
     def test_init_badargs(self):
         ''' Test Turmit __init__ bad arguments '''
         with self.assertRaises(RuntimeError):
             t = Turmit(prog='foobar')
 
 
+class TurmitExprCompileTestCase(unittest.TestCase):
+    ''' Tests compilatin capabilities of cturmit '''
+
+    def test_values(self):
+        progs = ('1', '0x1', '9', '0x9', '0xf', '0xF', '0x1FFF', '0xFFF1',
+        '12345');
+        for prog in progs:
+            t = Turmit(prog=prog)
+
+    def test_var(self):
+        progs = ('x', 'y', 'r', 'g', 'b')
+        for prog in progs:
+            t = Turmit(prog=prog)
+
 
 class TurmitOperationTestCase(unittest.TestCase):