Implement an RpnExpr class + add more options to Turmits

Adding prog attribute to Turmit (storing a RpnExpr)

gte/rpnlib.py

@@ -31,6 +31,10 @@ def RpnOp(method):
                 if not isinstance(topush, int):
                     raise ValueError('Turmit.%s() returned a list containing a\
  %s : %s' % (method.__name__, type(topush), topush))
+                if self._max_int is not None:
+                    topush %= self._max_int
+                    if not self._signed_int and topush < 0:
+                        topush = self._max_int - topush
                 self._push(topush)
         except TypeError:
             if not isinstance(res, int):
@@ -41,6 +45,34 @@ def RpnOp(method):
     _op_list[method.__name__] = (method, wrapped)
     return wrapped
 
+class RpnExpr(list):
+    ''' @brief Extended list that only contains RpnSymbol '''
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        for i, item in enumerate(self):
+            if not isinstance(item, RpnSymbol):
+                raise TypeError('Item %d is %s but RpnSymbol expected' % (i,
+                                                                          item))
+    def __setitem__(self, idx, val):
+        if not isinstance(val, RpnSymbol):
+            raise TypeError('RpnSymbol expected but got %s' % type(val))
+        super().__setitem(idx, val)
+
+    @classmethod
+    def random(cls, sz):
+        return cls([RpnSymbol.random() for _ in range(sz)])
+
+    @classmethod
+    def from_string(cls, val):
+        ''' @brief generate an expr from a string 
+            @param val str : expression
+            @return RpnExpr
+        '''
+        return cls([RpnSymbol.from_string(s.strip())
+                    for s in val.split()
+                    if len(s.strip()) > 0])
+
 class RpnSymbol(object):
     ''' @brief Designed to handle operation and operand for Turmit expr '''
 
@@ -56,10 +88,29 @@ class RpnSymbol(object):
         '''
         self.optype = optype
         self.value = value
+
+        err = False
+        err_type = 'Unknown'
         if optype == self.OPERATION:
-            self.value = list(_op_list.keys())[value % len(_op_list)]
+            if isinstance(value, str):
+                if not value in _op_list:
+                    err = True
+                    err_type = 'operation'
+                else:
+                    self.value = value
+            else:
+                self.value = list(_op_list.keys())[value % len(_op_list)]
         elif optype == self.VARIABLE:
-            self.value = list(_var_list.keys())[value % len(_var_list)]
+            if isinstance(value, str):
+                if not value in _var_list:
+                    err = True
+                    err_type = 'variable'
+                else:
+                    self.value = value
+            else:
+                self.value = list(_var_list.keys())[value % len(_var_list)]
+        if err:
+            msg = 'Invalid %s : "%s"' % (err_type, value.upper())
 
     def __str__(self):
         ''' @brief Return a string representation of current symbol '''
@@ -70,6 +121,31 @@ class RpnSymbol(object):
         else:
             return self.value.upper()
 
+    def __repr__(self):
+        if self.optype == self.OPERATION:
+            optype = 'OPE'
+        elif self.optype == self.VALUE:
+            optype = 'VAL'
+        elif self.optype == self.VARIABLE:
+            optype = 'VAR'
+        name = '%s.%s' % (self.__class__.__module__,
+                        self.__class__.__name__)
+        return '<%s %s(%s)>' % (name, optype, self.value)
+
+    @classmethod
+    def from_string(cls, val):
+        try:
+            val = int(val, base=0)
+            return cls(val, cls.VALUE)
+        except Exception:
+            pass
+        if val.lower() in _op_list.keys():
+            return cls(val, cls.OPERATION)
+        elif val.lower() in _var_list.keys():
+            return cls(val, cls.VARIABLE)
+        raise ValueError('Unrecognized symbol "%s"' % val)
+            
+
     @classmethod
     def random(cls, optype=None):
         ''' @brief Return a randomly generated symbol '''

gte/turmit.py

@@ -5,16 +5,75 @@ class Turmit(object):
         infinite looping stack with variable stack size.
     '''
     
-    def __init__(self, stack_size=8):
+    def __init__(self, stack_size=8, **kwargs):
+        ''' @brief Instanciated a new Turmit with a programm and a memory stack
+            @param stack_size int : stack_size
+            @param prog str | RpnExpr | None : turmit programm if None generate
+            it randomlt
+            @param prog_size int : if prog is generated randomly it will make
+            this size
+            @param max_int int : maximum integer value + 1
+            @param signed_int bool : if True integers are signed
+	    @throw ValueError for bad option value
+	    @throw RuntimError for bad arguments
+        '''
+        if stack_size < 2:
+            msg = 'Stack size has to be >= 2 but %d given' % (stack_size)
+            raise ValueError(msg)
+
         ## @brief List that represent a stack
         self._stack = [ 0 for _ in range(stack_size)]
         ## @brief Stack head index
         self._cur = stack_size - 1
         ## @brief Stores turmit direction
         self._dir = 0
+        ## @brief Stores turmit program
+        self._prog = None
+        self._prog_sz = 42
+
+        ## @brief Stores maximum int value + 1
+        #  @note This limit is handled by @ref rpnlib.RpnOp()
+        self._max_int = 0x10000
+        ## @brief If True integers are signed
+        #  @note This limit is handled by @ref rpnlib.RpnOp()
+        self._signed_int = True
+
+        if 'max_int' in kwargs:
+            v = kwargs['max_int']
+            if v < 1:
+                raise ValueError('Maximum int have to be >= 1 but %d found' % v)
+            self._max_int = kwargs['max_int']
+            del(kwargs['max_int'])
+        if 'signed_int' in kwargs:
+            self._signed_int = bool(kwargs['signed_int'])
+            del(kwargs['signed_int'])
+        if 'prog_size' in kwargs:
+            v = kwargs['prog_size']
+            if v < 2:
+                raise ValueError('Prog_size have to be >= 2 but %d found' % v)
+            self._prog_sz = v
+            del(kwargs['prog_size'])
+        if 'prog' in kwargs:
+            v = kwargs['prog']
+            if isinstance(v, str):
+                v = RpnExpr.from_string(v)
+            if isinstance(v, RpnExpr):
+                self._prog = v
+            else:
+                msg = 'Str or RpnExpr expected but %s found' % (type(v))
+                raise TypeError(msg)
+            del(kwargs['prog'])
+        if len(kwargs) > 0:
+            msg = 'Unexpected arguments : [%s]' % ', '.join(kwargs.keys())
+            raise RuntimeError(msg)
+
+        if self._prog is None:
+            self._prog = RpnExpr.random(self._prog_sz)
+            
 
     @property
     def shead(self):
+        ''' @brief Stack head attribute '''
         return self._stack[self._cur]
 
     def _pop(self):
@@ -46,8 +105,11 @@ class Turmit(object):
 
     @RpnOp
     def mem_sz(self, new_sz):
+        ''' @brief Update memory stack size
+        '''
+	    
         if new_sz < 2:
-            raise ValueError('New size sould be >= 2')
+            new_sz = 2
         stksz = len(self._stack)
         if new_sz > stksz:
             self._stack += [ 0 for _ in range(new_sz - stksz) ]

tests/test_rpnexpr.py

@@ -0,0 +1,27 @@
+import unittest
+
+from gte.turmit import Turmit
+from gte.rpnlib import _op_list, RpnSymbol, RpnExpr
+
+class RpnExprTestCase(unittest.TestCase):
+
+    def test_init(self):
+        expr = RpnExpr()
+
+    def test_random(self):
+        expr = RpnExpr.random(5)
+        self.assertEqual(len(expr), 5)
+
+    def test_fromstring(self):
+        expr = RpnExpr.from_string("""    5   0xFF
+        X
+        \tMOD""")
+        self.assertEqual(len(expr), 4)
+        tests = ((RpnSymbol.VALUE, 5),
+                 (RpnSymbol.VALUE, 255),
+                 (RpnSymbol.VARIABLE, 'X'),
+                 (RpnSymbol.OPERATION, 'MOD'))
+        for i, (optype, val) in enumerate(tests):
+            self.assertEqual(expr[i].optype, optype)
+            self.assertEqual(expr[i].value, val)
+

tests/test_rpnsymbol.py

@@ -14,3 +14,7 @@ class RpnSymbolTestCase(unittest.TestCase):
     def test_value(self):
         sym = RpnSymbol(42, RpnSymbol.VALUE)
         self.assertEqual(str(sym), '0x002A')
+
+    def test_op(self):
+        sym = RpnSymbol(0, RpnSymbol.OPERATION)
+        self.assertEqual(str(sym), 'MEM_SZ')

tests/test_turmit.py

@@ -6,13 +6,42 @@ from gte.rpnlib import _op_list
 
 class TurmitTestCase(unittest.TestCase):
     
-    def test_init_class(self):
+    def test_init(self):
         ''' Test Turmit class __init__ '''
         t = Turmit(42)
         self.assertEqual(len(t._stack), 42)
         self.assertEqual(t.shead, 0)
         self.assertEqual(len(t._stack) - 1 , t._cur)
 
+    def test_init_args(self):
+        ''' Test Turmit __init__ arguments '''
+        t = Turmit()
+        t = Turmit(prog_size = 42)
+        t = Turmit(prog = 'G R B 44 MOD ADD 43 MOD ADD 42 MOD')
+        t = Turmit(prog_size = 10)
+        self.assertEqual(len(t._prog), 10)
+        t = Turmit(max_int = 42)
+        self.assertEqual(t._max_int, 42)
+        t = Turmit(signed_int = False)
+        self.assertFalse(t._signed_int)
+        t = Turmit(prog = 'G R B ADD ADD 42 MOD', max_int = 42,
+                   signed_int = False, stack_size=42)
+
+    def test_init_badargs(self):
+        ''' Test Turmit __init__ bad arguments '''
+        with self.assertRaises(RuntimeError):
+            t = Turmit(foobar=42)
+        with self.assertRaises(ValueError):
+            t = Turmit(-1)
+        with self.assertRaises(ValueError):
+            t = Turmit(max_int = -1)
+        with self.assertRaises(ValueError):
+            t = Turmit(prog='foobar')
+
+
+
+class TurmitOperationTestCase(unittest.TestCase):
+    
     def test_push(self):
         ''' Test Turmit _push() method '''
         t = Turmit()