Add a stack, and use that for function call arguments

[fur] / normalization.py

diff --git a/normalization.py b/normalization.py
index c96e455..2fa57fc 100644 (file)
--- a/normalization.py
+++ b/normalization.py
@@ -38,6 +38,14 @@ NormalNegationExpression = collections.namedtuple(
     ],
 )
 
+NormalDotExpression = collections.namedtuple(
+    'NormalDotExpression',
+    [
+        'instance',
+        'field',
+    ],
+)
+
 NormalInfixExpression = collections.namedtuple(
     'NormalInfixExpression',
     [
@@ -48,12 +56,18 @@ NormalInfixExpression = collections.namedtuple(
     ],
 )
 
+NormalPushStatement = collections.namedtuple(
+    'NormalPushStatement',
+    (
+        'expression',
+    ),
+)
+
 NormalFunctionCallExpression = collections.namedtuple(
     'NormalFunctionCallExpression',
     [
         'function_expression',
         'argument_count',
-        'argument_items',
     ],
 )
 
@@ -65,6 +79,14 @@ NormalArrayVariableInitializationStatement = collections.namedtuple(
     ],
 )
 
+NormalSymbolArrayVariableInitializationStatement = collections.namedtuple(
+    'NormalSymbolArrayVariableInitializationStatement',
+    [
+        'variable',
+        'symbol_list',
+    ],
+)
+
 NormalVariableInitializationStatement = collections.namedtuple(
     'NormalVariableInitializationStatement',
     [
@@ -137,6 +159,83 @@ def normalize_integer_literal_expression(counter, expression):
         NormalVariableExpression(variable=variable),
     )
 
+NormalListConstructExpression = collections.namedtuple(
+    'NormalListConstructExpression',
+    [
+        'allocate',
+    ],
+)
+
+NormalListAppendStatement = collections.namedtuple(
+    'NormalListAppendStatement',
+    [
+        'list_expression',
+        'item_expression',
+    ],
+)
+
+NormalListGetExpression = collections.namedtuple(
+    'NormalListGetExpression',
+    [
+        'list_expression',
+        'index_expression',
+    ],
+)
+
+def normalize_list_literal_expression(counter, expression):
+    list_variable = '${}'.format(counter)
+    counter += 1
+
+    prestatements = [
+        NormalVariableInitializationStatement(
+            variable=list_variable,
+            expression=NormalListConstructExpression(allocate=len(expression.item_expression_list)),
+        ),
+    ]
+
+    list_expression = NormalVariableExpression(variable=list_variable)
+
+    for item_expression in expression.item_expression_list:
+        counter, item_expression_prestatements, normalized = normalize_expression(
+            counter,
+            item_expression,
+        )
+
+        for p in item_expression_prestatements:
+            prestatements.append(p)
+
+        prestatements.append(
+            NormalListAppendStatement(
+                list_expression=list_expression,
+                item_expression=normalized,
+            )
+        )
+
+    return (
+        counter,
+        tuple(prestatements),
+        list_expression,
+    )
+
+def normalize_list_item_expression(counter, expression):
+    counter, list_prestatements, list_expression = normalize_expression(counter, expression.list_expression)
+    counter, index_prestatements, index_expression = normalize_expression(counter, expression.index_expression)
+
+    result_variable = '${}'.format(counter)
+    result_prestatement = NormalVariableInitializationStatement(
+        variable=result_variable,
+        expression=NormalListGetExpression(
+            list_expression=list_expression,
+            index_expression=index_expression,
+        ),
+    )
+
+    return (
+        counter + 1,
+        list_prestatements + index_prestatements + (result_prestatement,),
+        NormalVariableExpression(variable=result_variable),
+    )
+
 def normalize_string_literal_expression(counter, expression):
     variable = '${}'.format(counter)
     return (
@@ -150,6 +249,72 @@ def normalize_string_literal_expression(counter, expression):
         NormalVariableExpression(variable=variable),
     )
 
+NormalStructureLiteralExpression = collections.namedtuple(
+    'NormalStructureLiteralExpression',
+    [
+        'field_count',
+        'symbol_list_variable',
+        'value_list_variable',
+    ],
+)
+
+def normalize_structure_literal_expression(counter, expression):
+    prestatements = []
+    field_symbol_array = []
+    field_value_array = []
+
+    for symbol_expression_pair in expression.fields:
+        counter, field_prestatements, field_expression = normalize_expression(
+            counter,
+            symbol_expression_pair.expression,
+        )
+
+        for p in field_prestatements:
+            prestatements.append(p)
+
+        field_symbol_array.append(symbol_expression_pair.symbol)
+        field_value_array.append(field_expression)
+
+    symbol_array_variable = '${}'.format(counter)
+    counter += 1
+
+    prestatements.append(
+        NormalSymbolArrayVariableInitializationStatement(
+            variable=symbol_array_variable,
+            symbol_list=tuple(field_symbol_array),
+        )
+    )
+
+    value_array_variable = '${}'.format(counter)
+    counter += 1
+
+    prestatements.append(
+        NormalArrayVariableInitializationStatement(
+            variable=value_array_variable,
+            items=tuple(field_value_array),
+        )
+    )
+
+    variable = '${}'.format(counter)
+
+    prestatements.append(
+        NormalVariableInitializationStatement(
+            variable=variable,
+            expression=NormalStructureLiteralExpression(
+                field_count=len(expression.fields),
+                symbol_list_variable=symbol_array_variable,
+                value_list_variable=value_array_variable,
+            ),
+        )
+    )
+
+    return (
+        counter + 1,
+        tuple(prestatements),
+        NormalVariableExpression(variable=variable),
+    )
+
+
 def normalize_symbol_expression(counter, expression):
     variable = '${}'.format(counter)
     return (
@@ -167,7 +332,6 @@ def normalize_function_call_expression(counter, expression):
     assert isinstance(expression, parsing.FurFunctionCallExpression)
 
     prestatements = []
-    arguments = []
 
     for argument in expression.arguments:
         counter, argument_prestatements, normalized_argument = normalize_expression(counter, argument)
@@ -182,19 +346,15 @@ def normalize_function_call_expression(counter, expression):
                 expression=normalized_argument,
             )
         )
-        arguments.append(NormalVariableExpression(
-            variable=variable,
-        ))
+        prestatements.append(
+            NormalPushStatement(
+                expression=NormalVariableExpression(
+                    variable=variable,
+                ),
+            ),
+        )
         counter += 1
 
-    arguments_variable = '${}'.format(counter)
-    counter += 1
-
-    prestatements.append(NormalArrayVariableInitializationStatement(
-        variable=arguments_variable,
-        items=tuple(arguments),
-    ))
-
     counter, function_prestatements, function_expression = normalize_expression(
         counter,
         expression.function,
@@ -216,14 +376,22 @@ def normalize_function_call_expression(counter, expression):
         function_expression = NormalVariableExpression(variable=function_variable)
         counter += 1
 
+    result_variable = '${}'.format(counter)
+
+    prestatements.append(
+        NormalVariableInitializationStatement(
+            variable=result_variable,
+            expression=NormalFunctionCallExpression(
+                function_expression=function_expression,
+                argument_count=len(expression.arguments),
+            ),
+        )
+    )
+
     return (
-        counter,
+        counter + 1,
         tuple(prestatements),
-        NormalFunctionCallExpression(
-            function_expression=function_expression,
-            argument_count=len(arguments),
-            argument_items=NormalVariableExpression(variable=arguments_variable),
-        ),
+        NormalVariableExpression(variable=result_variable),
     )
 
 def normalize_basic_infix_operation(counter, expression):
@@ -362,12 +530,33 @@ def normalize_boolean_expression(counter, expression):
         NormalVariableExpression(variable=result_variable),
     )
 
+def normalize_dot_expression(counter, expression):
+    assert isinstance(expression.right, parsing.FurSymbolExpression)
+
+    counter, prestatements, left_expression = normalize_expression(counter, expression.left)
+
+    variable = '${}'.format(counter)
+
+    dot_expression_prestatement = NormalVariableInitializationStatement(
+        variable=variable,
+        expression=NormalDotExpression(
+            instance=left_expression,
+            field=expression.right.symbol,
+        ),
+    )
+
+    return (
+        counter + 1,
+        prestatements + (dot_expression_prestatement,),
+        NormalVariableExpression(variable=variable),
+    )
 
 def normalize_infix_expression(counter, expression):
     return {
         'multiplication_level': normalize_basic_infix_operation,
         'addition_level': normalize_basic_infix_operation,
         'comparison_level': normalize_comparison_expression,
+        'dot_level': normalize_dot_expression,
         'and_level': normalize_boolean_expression,
         'or_level': normalize_boolean_expression,
     }[expression.order](counter, expression)
@@ -408,9 +597,6 @@ def normalize_if_expression(counter, expression):
         NormalVariableExpression(variable=result_variable),
     )
 
-
-
-
 def normalize_negation_expression(counter, expression):
     counter, prestatements, internal_expression = normalize_expression(counter, expression.value)
 
@@ -436,8 +622,11 @@ def normalize_expression(counter, expression):
         parsing.FurIfExpression: normalize_if_expression,
         parsing.FurInfixExpression: normalize_infix_expression,
         parsing.FurIntegerLiteralExpression: normalize_integer_literal_expression,
+        parsing.FurListLiteralExpression: normalize_list_literal_expression,
+        parsing.FurListItemExpression: normalize_list_item_expression,
         parsing.FurNegationExpression: normalize_negation_expression,
         parsing.FurStringLiteralExpression: normalize_string_literal_expression,
+        parsing.FurStructureLiteralExpression: normalize_structure_literal_expression,
         parsing.FurSymbolExpression: normalize_symbol_expression,
     }[type(expression)](counter, expression)
 
@@ -502,12 +691,12 @@ def normalize_statement_list(counter, statement_list, **kwargs):
             result_statement_list.append(s)
         result_statement_list.append(normalized)
 
+    # TODO The way we fix the last statement is really confusing
     last_statement = result_statement_list[-1]
 
     if isinstance(last_statement, NormalExpressionStatement) and isinstance(last_statement.expression, NormalVariableExpression):
-        result_expression = result_statement_list.pop().expression
-
         if assign_result_to is not None:
+            result_expression = result_statement_list.pop().expression
             result_statement_list.append(
                 NormalVariableReassignmentStatement(
                     variable=assign_result_to,