Added if expression statements

[fur] / transformation.py

diff --git a/transformation.py b/transformation.py
index 41cd712..0b58907 100644 (file)
--- a/transformation.py
+++ b/transformation.py
@@ -1,7 +1,7 @@
 import collections
 
 import normalization
-import parsing
+import parsing # TODO Remove this import, as we should be normalizing everything before it gets here
 
 CIntegerLiteral = collections.namedtuple(
     'CIntegerLiteral',
@@ -18,13 +18,6 @@ CStringLiteral = collections.namedtuple(
     ],
 )
 
-CConstantExpression = collections.namedtuple(
-    'CConstantExpression',
-    [
-        'value'
-    ],
-)
-
 CVariableExpression = collections.namedtuple(
     'CVariableExpression',
     [
@@ -59,12 +52,13 @@ CFunctionCallForFurInfixOperator = collections.namedtuple(
 CFunctionCallExpression = collections.namedtuple(
     'CFunctionCallExpression',
     [
-        'name',
+        'function_expression',
         'argument_count',
         'argument_items',
     ],
 )
 
+# TODO We are currently not changing variables, just preventing them from being accessed.
 CSymbolAssignmentStatement = collections.namedtuple(
     'CSymbolAssignmentStatement',
     [
@@ -109,8 +103,8 @@ CIfElseStatement = collections.namedtuple(
     'CIfElseStatement',
     [
         'condition_expression',
-        'if_statements',
-        'else_statements',
+        'if_statement_list',
+        'else_statement_list',
     ],
 )
 
@@ -121,6 +115,8 @@ CFunctionDeclaration = collections.namedtuple(
     ],
 )
 
+# TODO If a function definition doesn't end with an expression, we have issues currently because we try to return statement.
+# TODO Closures currently wrap entire defining environment, even symbols that are not used, which makes garbage collection ineffective.
 CFunctionDefinition = collections.namedtuple(
     'CFunctionDefinition',
     [
@@ -153,8 +149,8 @@ BUILTINS = {
 def transform_variable_expression(accumulators, expression):
     return CVariableExpression(variable=expression.variable)
 
-def transform_string_literal(accumulators, expression):
-    value = expression.value
+def transform_string_literal_expression(accumulators, expression):
+    value = expression.string
 
     try:
         index = accumulators.string_literal_list.index(value)
@@ -165,17 +161,17 @@ def transform_string_literal(accumulators, expression):
     return CStringLiteral(index=index, value=value)
 
 def transform_symbol_expression(accumulators, expression):
-    if expression.value in ['true', 'false']:
-        return CConstantExpression(value=expression.value)
+    if expression.symbol in BUILTINS:
+        accumulators.builtin_set.add(expression.symbol)
 
     try:
-        symbol_list_index = accumulators.symbol_list.index(expression.value)
+        symbol_list_index = accumulators.symbol_list.index(expression.symbol)
     except ValueError:
         symbol_list_index = len(accumulators.symbol_list)
-        accumulators.symbol_list.append(expression.value)
+        accumulators.symbol_list.append(expression.symbol)
 
     return CSymbolExpression(
-        symbol=expression.value,
+        symbol=expression.symbol,
         symbol_list_index=symbol_list_index,
     )
 
@@ -252,11 +248,7 @@ def transform_infix_expression(accumulators, expression):
     )
 
 def transform_integer_literal_expression(accumulators, expression):
-    return CIntegerLiteral(value=expression.value)
-
-def transform_parenthesized_expression(accumulators, expression):
-    # Parentheses can be removed because everything in the C output is explicitly parenthesized
-    return transform_expression(accumulators, expression.internal)
+    return CIntegerLiteral(value=expression.integer)
 
 def transform_negation_expression(accumulators, expression):
     return CNegationExpression(
@@ -266,16 +258,16 @@ def transform_negation_expression(accumulators, expression):
 def transform_expression(accumulators, expression):
     # TODO Clean up handlers for parsing expressions
     return {
-        parsing.FurFunctionCallExpression: transform_function_call_expression,
         parsing.FurInfixExpression: transform_infix_expression,
         parsing.FurIntegerLiteralExpression: transform_integer_literal_expression,
         parsing.FurNegationExpression: transform_negation_expression,
-        parsing.FurParenthesizedExpression: transform_parenthesized_expression,
-        parsing.FurStringLiteralExpression: transform_string_literal,
-        parsing.FurSymbolExpression: transform_symbol_expression,
+        parsing.FurStringLiteralExpression: transform_string_literal_expression,
         normalization.NormalFunctionCallExpression: transform_function_call_expression,
         normalization.NormalInfixExpression: transform_infix_expression,
+        normalization.NormalIntegerLiteralExpression: transform_integer_literal_expression,
         normalization.NormalNegationExpression: transform_negation_expression,
+        normalization.NormalStringLiteralExpression: transform_string_literal_expression,
+        normalization.NormalSymbolExpression: transform_symbol_expression,
         normalization.NormalVariableExpression: transform_variable_expression,
     }[type(expression)](accumulators, expression)
 
@@ -297,13 +289,9 @@ def transform_symbol_assignment_statement(accumulators, assignment_statement):
     )
 
 def transform_function_call_expression(accumulators, function_call):
-    if function_call.function.value in BUILTINS.keys():
-        # TODO Check that the builtin is actually callable
-        accumulators.builtin_set.add(function_call.function.value)
-
     # TODO Use the symbol from SYMBOL LIST
     return CFunctionCallExpression(
-        name=function_call.function.value,
+        function_expression=transform_expression(accumulators, function_call.function_expression),
         argument_count=function_call.argument_count,
         argument_items=transform_expression(accumulators, function_call.argument_items),
     )
@@ -316,8 +304,8 @@ def transform_expression_statement(accumulators, statement):
 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),
+        if_statement_list=tuple(transform_statement(accumulators, s) for s in statement.if_statement_list),
+        else_statement_list=tuple(transform_statement(accumulators, s) for s in statement.else_statement_list),
     )
 
 def transform_array_variable_initialization_statement(accumulators, statement):
@@ -389,6 +377,11 @@ def transform(program):
         transform_statement(accumulators, statement) for statement in program.statement_list
     ]
 
+    # This prevents warnings about normalized variables being entire C statements
+    last_statement = statement_list[-1]
+    if isinstance(last_statement, normalization.NormalExpressionStatement) and isinstance(last_statement.expression, normalization.NormalVariableExpression):
+        del statement_list[-1]
+
     standard_library_set = set()
     for builtin in accumulators.builtin_set:
         for standard_library in BUILTINS[builtin]: