Normalize parenthesized and negated expressions

[fur] / transformation.py

diff --git a/transformation.py b/transformation.py
index 2d729fa..4c1ef3b 100644 (file)
--- a/transformation.py
+++ b/transformation.py
@@ -81,6 +81,14 @@ CVariableInitializationStatement = collections.namedtuple(
     ],
 )
 
+CVariableReassignmentStatement = collections.namedtuple(
+    'CVariableReassignmentStatement',
+    [
+        'variable',
+        'expression',
+    ],
+)
+
 CExpressionStatement = collections.namedtuple(
     'CExpressionStatement',
     [
@@ -88,6 +96,15 @@ CExpressionStatement = collections.namedtuple(
     ],
 )
 
+CIfElseStatement = collections.namedtuple(
+    'CIfElseStatement',
+    [
+        'condition_expression',
+        'if_statements',
+        'else_statements',
+    ],
+)
+
 CProgram = collections.namedtuple(
     'CProgram',
     [
@@ -216,6 +233,7 @@ def transform_expression(accumulators, expression):
         parsing.FurInfixExpression: transform_infix_expression, # TODO Shouldn't need this
         normalization.NormalFunctionCallExpression: transform_function_call_expression,
         normalization.NormalInfixExpression: transform_infix_expression,
+        normalization.NormalNegationExpression: transform_negation_expression,
         normalization.NormalVariableExpression: transform_variable_expression,
     }[type(expression)](accumulators, expression)
 
@@ -233,9 +251,9 @@ def transform_symbol_assignment_statement(accumulators, assignment_statement):
         ),
     )
 
-def transform_negation_expression(accumulators, negation_expression):
+def transform_negation_expression(accumulators, expression):
     return CNegationExpression(
-        value=transform_expression(accumulators, negation_expression.value),
+        value=transform_expression(accumulators, expression.internal_expression),
     )
 
 def transform_function_call_expression(accumulators, function_call):
@@ -264,18 +282,33 @@ def transform_expression_statement(accumulators, statement):
         expression=expression,
     )
 
+def transform_if_else_statement(accumulators, statement):
+    return CIfElseStatement(
+        condition_expression=transform_expression(accumulators, statement.condition_expression),
+        if_statements=tuple(transform_statement(accumulators, s) for s in statement.if_statements),
+        else_statements=tuple(transform_statement(accumulators, s) for s in statement.else_statements),
+    )
+
 def transform_variable_initialization_statement(accumulators, statement):
     return CVariableInitializationStatement(
         variable=statement.variable,
         expression=transform_expression(accumulators, statement.expression),
     )
 
+def transform_variable_reassignment_statement(accumulators, statement):
+    return CVariableReassignmentStatement(
+        variable=statement.variable,
+        expression=transform_expression(accumulators, statement.expression),
+    )
+
 def transform_statement(accumulators, statement):
     return {
         parsing.FurAssignmentStatement: transform_symbol_assignment_statement,
         parsing.FurExpressionStatement: transform_expression_statement,
-        normalization.NormalVariableInitializationStatement: transform_variable_initialization_statement,
         normalization.NormalExpressionStatement: transform_expression_statement,
+        normalization.NormalIfElseStatement: transform_if_else_statement,
+        normalization.NormalVariableInitializationStatement: transform_variable_initialization_statement,
+        normalization.NormalVariableReassignmentStatement: transform_variable_reassignment_statement,
     }[type(statement)](accumulators, statement)