Normalized all infix expression statements

[fur] / transformation.py

diff --git a/transformation.py b/transformation.py
index 5de9bbf..efc7d99 100644 (file)
--- a/transformation.py
+++ b/transformation.py
@@ -73,8 +73,16 @@ CSymbolAssignmentStatement = collections.namedtuple(
     ],
 )
 
-CVariableAssignmentStatement = collections.namedtuple(
-    'CVariableAssignmentStatement',
+CVariableInitializationStatement = collections.namedtuple(
+    'CVariableInitializationStatement',
+    [
+        'variable',
+        'expression',
+    ],
+)
+
+CVariableReassignmentStatement = collections.namedtuple(
+    'CVariableReassignmentStatement',
     [
         'variable',
         'expression',
@@ -88,6 +96,15 @@ CExpressionStatement = collections.namedtuple(
     ],
 )
 
+CIfElseStatement = collections.namedtuple(
+    'CIfElseStatement',
+    [
+        'condition_expression',
+        'if_statements',
+        'else_statements',
+    ],
+)
+
 CProgram = collections.namedtuple(
     'CProgram',
     [
@@ -108,10 +125,10 @@ EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING = {
     '>':    'greaterThan',
 }
 
-def transform_equality_level_expression(accumulators, expression):
+def transform_comparison_level_expression(accumulators, 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(
+    if isinstance(expression.left, parsing.FurInfixExpression) and expression.left.order == 'comparison_level':
+        left = transform_comparison_level_expression(
             accumulators,
             expression.left
         )
@@ -151,8 +168,8 @@ def transform_variable_expression(accumulators, expression):
     return CVariableExpression(variable=expression.variable)
 
 def transform_infix_expression(accumulators, expression):
-    if expression.order == 'equality_level':
-        return transform_equality_level_expression(accumulators, expression)
+    if expression.order == 'comparison_level':
+        return transform_comparison_level_expression(accumulators, expression)
 
     INFIX_OPERATOR_TO_FUNCTION_NAME = {
         '+':    'add',
@@ -264,8 +281,21 @@ def transform_expression_statement(accumulators, statement):
         expression=expression,
     )
 
-def transform_variable_assignment_statement(accumulators, statement):
-    return CVariableAssignmentStatement(
+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),
     )
@@ -274,8 +304,10 @@ def transform_statement(accumulators, statement):
     return {
         parsing.FurAssignmentStatement: transform_symbol_assignment_statement,
         parsing.FurExpressionStatement: transform_expression_statement,
-        normalization.NormalVariableAssignmentStatement: transform_variable_assignment_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)