A prototype for solve dividing two integers

pyclibrary/c_parser.py

@@ -35,6 +35,91 @@
 __all__ = ['win_defs', 'CParser']
 
 
+def wrap_int(t):
+    logger.debug('wrap_int: {} {}'.format(t.dump(), type(t)))
+    t[0] = "CInt({})".format(eval(t[0]))
+    return t
+
+class CInt(int):
+    def __new__(cls, base=10, *args, **kwargs):
+        return  super(CInt, cls).__new__(cls, base, *args, **kwargs)
+
+    def __truediv__(self, other):
+        if isinstance(other, CInt):
+            is_positive = self >= 0 and other >= 0
+            return CInt(int(self) // int(other)) if is_positive else -CInt(-int(self) // int(other))
+        else:
+            return super(CInt, self).__truediv__(other)
+
+    def __rtruediv__(self, other):
+        if isinstance(other, CInt):
+            is_positive = self >= 0 and other >= 0
+            return CInt(int(other) // int(self)) if is_positive else -CInt(-int(other) // int(self))
+        else:
+            return super(CInt, self).__rtruediv__(other)
+
+    def __mod__(self, other):
+        if isinstance(other, CInt):
+            is_positive = self >= 0 and other >= 0
+            return CInt(int(self) % int(other)) if is_positive else -CInt(-int(self) % int(other))
+        else:
+            return super(CInt, self).__mod__(other)
+
+    def __rmod__(self, other):
+        if isinstance(other, CInt):
+            is_positive = self >= 0 and other >= 0
+            return CInt(int(other) % int(self)) if is_positive else -CInt(-int(other) % int(self))
+        else:
+            return super(CInt, self).__rmod__(other)
+
+    def __sub__(self, other):
+        if isinstance(other, CInt):
+            return CInt(int(self) - int(other))
+        else:
+            return super(CInt, self).__sub__(other)
+
+    def __rsub__(self, other):
+        if isinstance(other, CInt):
+            return CInt(int(other) - int(self))
+        else:
+            return super(CInt, self).__rsub__(other)
+
+    def __add__(self, other):
+        if isinstance(other, CInt):
+            return CInt(int(self) + int(other))
+        else:
+            return super(CInt, self).__add__(other)
+
+    def __radd__(self, other):
+        if isinstance(other, CInt):
+            return CInt(int(other) + int(self))
+        else:
+            return super(CInt, self).__radd__(other)
+
+    def __mul__(self, other):
+        if isinstance(other, CInt):
+            return CInt(int(self) * int(other))
+        else:
+            return super(CInt, self).__mul__(other)
+
+    def __rmul__(self, other):
+        if isinstance(other, CInt):
+            return CInt(int(other) * int(self))
+        else:
+            return super(CInt, self).__rmul__(other)
+
+    def __str__(self):
+        return "CInt({})".format(super(CInt, self).__str__())
+
+    def __repr__(self):
+        return "CInt({})".format(super(CInt, self).__repr__())
+
+    def __neg__(self):
+        return CInt(-int(self))
+
+    def __pos__(self):
+        return CInt(+int(self))
+
 class Type(tuple):
     """
     Representation of a C type. CParser uses this class to store the parsed
@@ -1508,7 +1593,7 @@ def eval(self, expr, *args):
         expr = expr.strip()
         cast = (lparen + self.type_spec + self.abstract_declarator +
                 rparen).suppress()
-        expr = (quotedString | number | cast).transformString(expr)
+        expr = (quotedString | number_in_expr | cast).transformString(expr)
         if expr == '':
             return None
         return eval(expr, *args)
@@ -1651,10 +1736,14 @@ def print_parse_results(pr, depth=0, name=''):
 hexint = Regex(r'[+-]?\s*0[xX][{}]+[UL]*'.format(hexnums)).setParseAction(int_strip)
 decint = Regex(r'[+-]?\s*[0-9]+[UL]*').setParseAction(int_strip)
 integer = (hexint | decint)
+integer.setParseAction(wrap_int)
+# in eval expr would not match identifier, it would match a number cause error
+integer_in_expr = (hexint | decint)
 # The floating regex is ugly but it is because we do not want to match
 # integer to it.
 floating = Regex(r'[+-]?\s*((((\d(\.\d*)?)|(\.\d+))[eE][+-]?\d+)|((\d\.\d*)|(\.\d+)))')
-number = (floating | integer)
+number =  (floating |integer)
+number_in_expr = (floating |integer_in_expr)
 
 # Miscelaneous
 bi_operator = oneOf("+ - / * | & || && ! ~ ^ % == != > < >= <= -> . :: << >> = ? :")

tests/headers/variables.h

@@ -56,6 +56,18 @@ float x1 = (5 + 3 * 0x1) / 8.0;
 // Test type casting handling.
 int x2 = (typeCast)0x544 <<16;
 
+// Test int div 9 / 2 should be 4
+float x3 = 9.0 / 2.0;
+int x4 = 9 / 2;
+float x5 = 9 / 2;
+int x6_1 = 9;
+int x6_2 = 2;
+float x6 = x6_1 / x6_2;
+float x7 = x6_1 / 2.0;
+float x8 = (9 / 2) * 2 + 9 % 2;
+int x9 = -9 / 2; // -4
+int x10 = -9 % 2; // -1
+
 // Test array
 float array[2] = {0x1, 3.1415e6};
 static const int * const (**intJunk[4]);

tests/test_parser.py

@@ -566,6 +566,24 @@ def test_variables(self):
         assert ('x2' in variables and
                 variables['x2'] == (88342528, Type('int')))
 
+        # Test int div 9 / 2 should be 4
+        assert ('x3' in variables and
+                variables['x3'] == (4.5, Type('float')))
+        assert ('x4' in variables and
+                variables['x4'] == (4, Type('int')))
+        assert ('x5' in variables and
+                variables['x5'] == (4., Type('float')))
+        assert ('x6' in variables and
+                variables['x6'] == (4., Type('float')))
+        assert ('x7' in variables and
+                variables['x7'] == (4.5, Type('float')))
+        assert ('x8' in variables and
+                variables['x8'] == (9., Type('float')))
+        assert ('x9' in variables and
+                variables['x9'] == (-4, Type('int')))
+        assert ('x10' in variables and
+                variables['x10'] == (-1, Type('int')))
+
         # Test array handling
         assert ('array' in variables and
                 variables['array'] == ([1, 3141500.0], Type('float', [2])))