Add a stack, and use that for function call arguments

[fur] / normalization.py

diff --git a/normalization.py b/normalization.py
index ca6f57f..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',
     [
@@ -227,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 (
@@ -244,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)
@@ -259,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,
@@ -293,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):
@@ -439,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)
@@ -514,6 +626,7 @@ def normalize_expression(counter, 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)
 
@@ -578,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,