Add boolean operators

[fur] / transformation.py

diff --git a/transformation.py b/transformation.py
index 668f4ff..3e898d8 100644 (file)
--- a/transformation.py
+++ b/transformation.py
@@ -38,41 +38,10 @@ CNegationExpression = collections.namedtuple(
     ],
 )
 
-CAdditionExpression = collections.namedtuple(
-    'CAdditionExpression',
-    [
-        'left',
-        'right',
-    ],
-)
-
-CSubtractionExpression = collections.namedtuple(
-    'CSubtractionExpression',
-    [
-        'left',
-        'right',
-    ],
-)
-
-CMultiplicationExpression = collections.namedtuple(
-    'CMultiplicationExpression',
-    [
-        'left',
-        'right',
-    ],
-)
-
-CIntegerDivisionExpression = collections.namedtuple(
-    'CIntegerDivisionExpression',
-    [
-        'left',
-        'right',
-    ],
-)
-
-CModularDivisionExpression = collections.namedtuple(
-    'CModularDivisionExpression',
+CFunctionCallForFurInfixOperator = collections.namedtuple(
+    'CFunctionCallForFurInfixOperator',
     [
+        'name',
         'left',
         'right',
     ],
@@ -105,6 +74,49 @@ CProgram = collections.namedtuple(
     ],
 )
 
+EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING = {
+    '==':   'equals',
+    '!=':   'notEquals',
+    '<=':   'lessThanOrEqual',
+    '>=':   'greaterThanOrEqual',
+    '<':    'lessThan',
+    '>':    'greaterThan',
+}
+
+def transform_equality_level_expression(builtin_dependencies, symbol_list, expression):
+    # Transform expressions like 1 < 2 < 3 into expressions like 1 < 2 && 2 < 3
+    if isinstance(expression.left, parsing.FurInfixExpression) and expression.left.order == 'equality_level':
+        left = transform_equality_level_expression(
+            builtin_dependencies,
+            symbol_list,
+            expression.left
+        )
+
+        middle = left.right
+
+        right = transform_expression(
+            builtin_dependencies,
+            symbol_list,
+            expression.right,
+        )
+
+        # TODO Don't evaluate the middle expression twice
+        return CFunctionCallForFurInfixOperator(
+            name='and',
+            left=left,
+            right=CFunctionCallForFurInfixOperator(
+                name=EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING[expression.operator],
+                left=middle,
+                right=right,
+            ),
+        )
+
+    return CFunctionCallForFurInfixOperator(
+        name=EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING[expression.operator],
+        left=transform_expression(builtin_dependencies, symbol_list, expression.left),
+        right=transform_expression(builtin_dependencies, symbol_list, expression.right),
+    )
+
 BUILTINS = {
     'false':    [],
     'pow':      ['math.h'],
@@ -113,6 +125,10 @@ BUILTINS = {
 }
 
 def transform_expression(builtin_dependencies, symbol_list, expression):
+    if isinstance(expression, parsing.FurParenthesizedExpression):
+        # Parentheses can be removed because everything in the C output is explicitly parenthesized
+        return transform_expression(builtin_dependencies, symbol_list, expression.internal)
+
     if isinstance(expression, parsing.FurNegationExpression):
         return transform_negation_expression(builtin_dependencies, symbol_list, expression)
 
@@ -139,18 +155,27 @@ def transform_expression(builtin_dependencies, symbol_list, expression):
     if type(expression) in LITERAL_TYPE_MAPPING:
         return LITERAL_TYPE_MAPPING[type(expression)](value=expression.value)
 
-    INFIX_TYPE_MAPPING = {
-        parsing.FurAdditionExpression: CAdditionExpression,
-        parsing.FurSubtractionExpression: CSubtractionExpression,
-        parsing.FurMultiplicationExpression: CMultiplicationExpression,
-        parsing.FurIntegerDivisionExpression: CIntegerDivisionExpression,
-        parsing.FurModularDivisionExpression: CModularDivisionExpression,
-    }
+    if isinstance(expression, parsing.FurInfixExpression):
+        if expression.order == 'equality_level':
+            return transform_equality_level_expression(builtin_dependencies, symbol_list, expression)
+
+        INFIX_OPERATOR_TO_FUNCTION_NAME = {
+            '+':    'add',
+            '-':    'subtract',
+            '*':    'multiply',
+            '//':   'integerDivide',
+            '%':    'modularDivide',
+            'and':  'and',
+            'or':   'or',
+        }
+
+        return CFunctionCallForFurInfixOperator(
+            name=INFIX_OPERATOR_TO_FUNCTION_NAME[expression.operator],
+            left=transform_expression(builtin_dependencies, symbol_list, expression.left),
+            right=transform_expression(builtin_dependencies, symbol_list, expression.right),
+        )
 
-    return INFIX_TYPE_MAPPING[type(expression)](
-        left=transform_expression(builtin_dependencies, symbol_list, expression.left),
-        right=transform_expression(builtin_dependencies, symbol_list, expression.right),
-    )
+    raise Exception('Could not transform expression "{}"'.format(expression))
 
 def transform_assignment_statement(builtin_dependencies, symbol_list, assignment_statement):
     # TODO Check that target is not a builtin