Add boolean operators

[fur] / transformation.py

diff --git a/transformation.py b/transformation.py
index e3658bc..3e898d8 100644 (file)
--- a/transformation.py
+++ b/transformation.py
@@ -16,6 +16,13 @@ CStringLiteral = collections.namedtuple(
     ],
 )
 
+CConstantExpression = collections.namedtuple(
+    'CConstantExpression',
+    [
+        'value'
+    ],
+)
+
 CSymbolExpression = collections.namedtuple(
     'CSymbolExpression',
     [
@@ -31,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',
     ],
@@ -98,12 +74,61 @@ 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'],
     'print':    ['stdio.h'],
+    'true':     [],
 }
 
 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)
 
@@ -111,6 +136,9 @@ def transform_expression(builtin_dependencies, symbol_list, expression):
         return transform_function_call_expression(builtin_dependencies, symbol_list, expression)
 
     if isinstance(expression, parsing.FurSymbolExpression):
+        if expression.value in ['true', 'false']:
+            return CConstantExpression(value=expression.value)
+
         if expression.value not in symbol_list:
             symbol_list.append(expression.value)
 
@@ -127,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
@@ -162,6 +199,7 @@ def transform_negation_expression(builtin_dependencies, symbol_list, negation_ex
 
 def transform_function_call_expression(builtin_dependencies, symbol_list, function_call):
     if function_call.function.value in BUILTINS.keys():
+        # TODO Check that the builtin is actually callable
         builtin_dependencies.add(function_call.function.value)
 
         return CFunctionCallExpression(