Added lambda expressions

[fur] / transformation.py

diff --git a/transformation.py b/transformation.py
index eb6d9cb..e8ee51c 100644 (file)
--- a/transformation.py
+++ b/transformation.py
@@ -1,7 +1,6 @@
 import collections
 
-import normalization
-import parsing # TODO Remove this import, as we should be normalizing everything before it gets here
+import conversion
 
 CIntegerLiteral = collections.namedtuple(
     'CIntegerLiteral',
@@ -157,7 +156,7 @@ BUILTINS = {
 }
 
 def transform_variable_expression(accumulators, expression):
-    assert isinstance(expression, normalization.NormalVariableExpression)
+    assert isinstance(expression, conversion.CPSVariableExpression)
     return CVariableExpression(variable=expression.variable)
 
 def transform_string_literal_expression(accumulators, expression):
@@ -191,25 +190,24 @@ def transform_integer_literal_expression(accumulators, expression):
 
 CListConstructExpression = collections.namedtuple(
     'CListConstructExpression',
-    [
+    (
         'allocate',
-    ],
+    ),
+)
+
+CLambdaExpression = collections.namedtuple(
+    'CLambdaExpression',
+    (
+        'name',
+    ),
 )
 
 CListAppendStatement = collections.namedtuple(
     'CListAppendStatement',
-    [
+    (
         'list_expression',
         'item_expression',
-    ],
-)
-
-CListGetExpression = collections.namedtuple(
-    'CListGetExpression',
-    [
-        'list_expression',
-        'index_expression',
-    ],
+    ),
 )
 
 def transform_structure_literal_expression(accumulators, expression):
@@ -219,15 +217,27 @@ def transform_structure_literal_expression(accumulators, expression):
         value_list_variable=expression.value_list_variable,
     )
 
+def transform_lambda_expression(accumulators, expression):
+    # TODO This function feels hacky
+    if len(accumulators.lambda_number_list) == 0:
+        accumulators.lambda_number_list.append(0)
+    else:
+        accumulators.lambda_number_list.append(accumulators.lambda_number_list[-1] + 1)
+
+    name = '__lambda_{}'.format(accumulators.lambda_number_list[-1])
+
+    accumulators.function_definition_list.append(CFunctionDefinition(
+        name=name,
+        argument_name_list=expression.argument_name_list,
+        statement_list=tuple(transform_statement(accumulators, s) for s in expression.statement_list),
+    ))
+
+    return CLambdaExpression(name=name)
+
+
 def transform_list_construct_expression(accumulators, expression):
     return CListConstructExpression(allocate=expression.allocate)
 
-def transform_list_get_expression(accumulators, expression):
-    return CListGetExpression(
-        list_expression=transform_expression(accumulators, expression.list_expression),
-        index_expression=transform_expression(accumulators, expression.index_expression),
-    )
-
 def transform_list_append_statement(accumulators, expression):
     return CListAppendStatement(
         list_expression=transform_expression(accumulators, expression.list_expression),
@@ -236,14 +246,14 @@ def transform_list_append_statement(accumulators, expression):
 
 def transform_expression(accumulators, expression):
     return {
-        normalization.NormalFunctionCallExpression: transform_function_call_expression,
-        normalization.NormalIntegerLiteralExpression: transform_integer_literal_expression,
-        normalization.NormalListConstructExpression: transform_list_construct_expression,
-        normalization.NormalListGetExpression: transform_list_get_expression,
-        normalization.NormalStructureLiteralExpression: transform_structure_literal_expression,
-        normalization.NormalStringLiteralExpression: transform_string_literal_expression,
-        normalization.NormalSymbolExpression: transform_symbol_expression,
-        normalization.NormalVariableExpression: transform_variable_expression,
+        conversion.CPSFunctionCallExpression: transform_function_call_expression,
+        conversion.CPSIntegerLiteralExpression: transform_integer_literal_expression,
+        conversion.CPSLambdaExpression: transform_lambda_expression,
+        conversion.CPSListConstructExpression: transform_list_construct_expression,
+        conversion.CPSStructureLiteralExpression: transform_structure_literal_expression,
+        conversion.CPSStringLiteralExpression: transform_string_literal_expression,
+        conversion.CPSSymbolExpression: transform_symbol_expression,
+        conversion.CPSVariableExpression: transform_variable_expression,
     }[type(expression)](accumulators, expression)
 
 def transform_symbol_assignment_statement(accumulators, assignment_statement):
@@ -338,16 +348,16 @@ def transform_push_statement(accumulators, statement):
 
 def transform_statement(accumulators, statement):
     return {
-        normalization.NormalArrayVariableInitializationStatement: transform_array_variable_initialization_statement,
-        normalization.NormalAssignmentStatement: transform_symbol_assignment_statement,
-        normalization.NormalExpressionStatement: transform_expression_statement,
-        normalization.NormalFunctionDefinitionStatement: transform_function_definition_statement,
-        normalization.NormalIfElseStatement: transform_if_else_statement,
-        normalization.NormalListAppendStatement: transform_list_append_statement,
-        normalization.NormalPushStatement: transform_push_statement,
-        normalization.NormalSymbolArrayVariableInitializationStatement: transform_symbol_array_variable_initialization_statement,
-        normalization.NormalVariableInitializationStatement: transform_variable_initialization_statement,
-        normalization.NormalVariableReassignmentStatement: transform_variable_reassignment_statement,
+        conversion.CPSArrayVariableInitializationStatement: transform_array_variable_initialization_statement,
+        conversion.CPSAssignmentStatement: transform_symbol_assignment_statement,
+        conversion.CPSExpressionStatement: transform_expression_statement,
+        conversion.CPSFunctionDefinitionStatement: transform_function_definition_statement,
+        conversion.CPSIfElseStatement: transform_if_else_statement,
+        conversion.CPSListAppendStatement: transform_list_append_statement,
+        conversion.CPSPushStatement: transform_push_statement,
+        conversion.CPSSymbolArrayVariableInitializationStatement: transform_symbol_array_variable_initialization_statement,
+        conversion.CPSVariableInitializationStatement: transform_variable_initialization_statement,
+        conversion.CPSVariableReassignmentStatement: transform_variable_reassignment_statement,
     }[type(statement)](accumulators, statement)
 
 
@@ -356,6 +366,7 @@ Accumulators = collections.namedtuple(
     [
         'builtin_set',
         'function_definition_list',
+        'lambda_number_list',
         'operator_set',
         'symbol_list',
         'string_literal_list',
@@ -366,6 +377,7 @@ def transform(program):
     accumulators = Accumulators(
         builtin_set=set(),
         function_definition_list=[],
+        lambda_number_list=[],
         operator_set=set(),
         symbol_list=[],
         string_literal_list=[],