Go back to constructors and destructors

[fur] / transformation.py

diff --git a/transformation.py b/transformation.py
index b6d21c8..5fb853c 100644 (file)
--- a/transformation.py
+++ b/transformation.py
@@ -60,7 +60,8 @@ CFunctionCallExpression = collections.namedtuple(
     'CFunctionCallExpression',
     [
         'name',
-        'arguments',
+        'argument_count',
+        'argument_items',
     ],
 )
 
@@ -73,8 +74,24 @@ CSymbolAssignmentStatement = collections.namedtuple(
     ],
 )
 
-CVariableAssignmentStatement = collections.namedtuple(
-    'CVariableAssignmentStatement',
+CArrayVariableInitializationStatement = collections.namedtuple(
+    'CArrayVariableInitializationStatement',
+    [
+        'variable',
+        'items',
+    ],
+)
+
+CVariableInitializationStatement = collections.namedtuple(
+    'CVariableInitializationStatement',
+    [
+        'variable',
+        'expression',
+    ],
+)
+
+CVariableReassignmentStatement = collections.namedtuple(
+    'CVariableReassignmentStatement',
     [
         'variable',
         'expression',
@@ -88,10 +105,35 @@ CExpressionStatement = collections.namedtuple(
     ],
 )
 
+CIfElseStatement = collections.namedtuple(
+    'CIfElseStatement',
+    [
+        'condition_expression',
+        'if_statements',
+        'else_statements',
+    ],
+)
+
+CFunctionDeclaration = collections.namedtuple(
+    'CFunctionDeclaration',
+    [
+        'name',
+    ],
+)
+
+CFunctionDefinition = collections.namedtuple(
+    'CFunctionDefinition',
+    [
+        'name',
+        'statement_list',
+    ],
+)
+
 CProgram = collections.namedtuple(
     'CProgram',
     [
         'builtin_set',
+        'function_definition_list',
         'statements',
         'standard_libraries',
         'string_literal_list',
@@ -216,6 +258,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,49 +276,85 @@ 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):
-    # TODO Function should be a full expression
     if function_call.function.value in BUILTINS.keys():
         # TODO Check that the builtin is actually callable
         accumulators.builtin_set.add(function_call.function.value)
 
-        return CFunctionCallExpression(
-            name='builtin$' + function_call.function.value,
-            arguments=tuple(
-                transform_expression(accumulators, arg)
-                for arg in function_call.arguments
-            ),
-        )
-
-    raise Exception()
+    # TODO Use the symbol from SYMBOL LIST
+    return CFunctionCallExpression(
+        name=function_call.function.value,
+        argument_count=function_call.argument_count,
+        argument_items=transform_expression(accumulators, function_call.argument_items),
+    )
 
 def transform_expression_statement(accumulators, statement):
+    # TODO At some point we can verify that all expression types are supported and just call transform_expression
     expression = {
         parsing.FurFunctionCallExpression: transform_function_call_expression,
+        parsing.FurInfixExpression: transform_expression,
+        parsing.FurIntegerLiteralExpression: transform_expression,
+        parsing.FurSymbolExpression: transform_expression,
         normalization.NormalFunctionCallExpression: transform_function_call_expression,
+        normalization.NormalVariableExpression: transform_expression,
     }[type(statement.expression)](accumulators, statement.expression)
 
     return CExpressionStatement(
         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_array_variable_initialization_statement(accumulators, statement):
+    return CArrayVariableInitializationStatement(
+        variable=statement.variable,
+        items=tuple(transform_expression(accumulators, i) for i in statement.items),
+    )
+
+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_function_definition_statement(accumulators, statement):
+    # TODO Allow defining the same function in different contexts
+    if any(fd.name == statement.name for fd in accumulators.function_definition_list):
+        raise Exception('A function with name "{}" already exists'.format(statement.name))
+
+    accumulators.function_definition_list.append(CFunctionDefinition(
+        name=statement.name,
+        statement_list=tuple(transform_statement(accumulators, s) for s in statement.statement_list)
+    ))
+
+    return CFunctionDeclaration(name=statement.name)
+
 def transform_statement(accumulators, statement):
     return {
         parsing.FurAssignmentStatement: transform_symbol_assignment_statement,
         parsing.FurExpressionStatement: transform_expression_statement,
-        normalization.NormalVariableAssignmentStatement: transform_variable_assignment_statement,
+        normalization.NormalArrayVariableInitializationStatement: transform_array_variable_initialization_statement,
         normalization.NormalExpressionStatement: transform_expression_statement,
+        normalization.NormalFunctionDefinitionStatement: transform_function_definition_statement,
+        normalization.NormalIfElseStatement: transform_if_else_statement,
+        normalization.NormalVariableInitializationStatement: transform_variable_initialization_statement,
+        normalization.NormalVariableReassignmentStatement: transform_variable_reassignment_statement,
     }[type(statement)](accumulators, statement)
 
 
@@ -283,6 +362,7 @@ Accumulators = collections.namedtuple(
     'Accumulators',
     [
         'builtin_set',
+        'function_definition_list',
         'symbol_list',
         'string_literal_list',
     ],
@@ -291,6 +371,7 @@ Accumulators = collections.namedtuple(
 def transform(program):
     accumulators = Accumulators(
         builtin_set=set(),
+        function_definition_list=[],
         symbol_list=[],
         string_literal_list=[],
     )
@@ -306,6 +387,7 @@ def transform(program):
 
     return CProgram(
         builtin_set=accumulators.builtin_set,
+        function_definition_list=accumulators.function_definition_list,
         statements=statement_list,
         standard_libraries=standard_library_set,
         string_literal_list=accumulators.string_literal_list,