Normalized all infix expression statements

[fur] / generation.py

diff --git a/generation.py b/generation.py
index 816ebc9..149a5e2 100644 (file)
--- a/generation.py
+++ b/generation.py
@@ -28,6 +28,9 @@ def generate_symbol_expression(c_symbol_expression):
         c_symbol_expression.symbol,
     )
 
+def generate_variable_expression(expression):
+    return expression.variable
+
 def generate_expression(expression):
     if isinstance(expression, transformation.CNegationExpression):
         return generate_negation_expression(expression)
@@ -52,7 +55,9 @@ def generate_expression(expression):
             generate_expression(expression.right),
         )
 
-    raise Exception('Could not handle expresssion "{}"'.format(expression))
+    return {
+        transformation.CVariableExpression: generate_variable_expression,
+    }[type(expression)](expression)
 
 def generate_negation_expression(c_negation_expression):
     return 'builtin$negate({})'.format(
@@ -65,22 +70,49 @@ def generate_function_call(c_function_call):
         ', '.join(generate_expression(argument) for argument in c_function_call.arguments),
     )
 
-def generate_expression_statement(c_function_call_statement):
+def generate_expression_statement(statement):
     # TODO Do we need to garbage collect the results of arbitrary statements?
-    return '{};'.format(generate_expression(c_function_call_statement))
+    return '{};'.format(generate_expression(statement.expression))
 
-def generate_assignment_statement(c_assignment_statement):
+def generate_symbol_assignment_statement(c_assignment_statement):
     return 'Environment_set(environment, SYMBOL_LIST[{}] /* symbol: {} */, {});'.format(
         c_assignment_statement.target_symbol_list_index,
         c_assignment_statement.target,
         generate_expression(c_assignment_statement.expression),
     )
 
-def generate_statement(statement):
-    if isinstance(statement, transformation.CAssignmentStatement):
-        return generate_assignment_statement(statement)
+def generate_variable_initialization_statement(statement):
+    return 'Object {} = {};'.format(
+        statement.variable,
+        generate_expression(statement.expression),
+    )
+
+def generate_variable_reassignment_statement(statement):
+    return '{} = {};'.format(
+        statement.variable,
+        generate_expression(statement.expression),
+    )
 
-    return generate_expression_statement(statement)
+
+def indent(s):
+    return '\n'.join(' ' * 2 + l for l in s.split('\n'))
+
+def generate_if_else_statement(statement):
+    # TODO Check that the argument is boolean
+    return 'if({}.instance.boolean)\n{{\n{}\n}}\nelse\n{{\n{}\n}}'.format(
+        generate_expression(statement.condition_expression),
+        indent('\n'.join(generate_statement(s) for s in statement.if_statements)),
+        indent('\n'.join(generate_statement(s) for s in statement.else_statements)),
+    )
+
+def generate_statement(statement):
+    return {
+        transformation.CExpressionStatement: generate_expression_statement,
+        transformation.CIfElseStatement: generate_if_else_statement,
+        transformation.CSymbolAssignmentStatement: generate_symbol_assignment_statement,
+        transformation.CVariableInitializationStatement: generate_variable_initialization_statement,
+        transformation.CVariableReassignmentStatement: generate_variable_reassignment_statement,
+    }[type(statement)](statement)
 
 def generate(program):
     template = ENV.get_template('program.c')