Some minor refactoring and added a (currently trivial) normalization step

[fur] / transformation.py

diff --git a/transformation.py b/transformation.py
index d27a0c5..98398f8 100644 (file)
--- a/transformation.py
+++ b/transformation.py
@@ -12,6 +12,7 @@ CIntegerLiteral = collections.namedtuple(
 CStringLiteral = collections.namedtuple(
     'CStringLiteral',
     [
+        'index',
         'value',
     ],
 )
@@ -67,9 +68,10 @@ CAssignmentStatement = collections.namedtuple(
 CProgram = collections.namedtuple(
     'CProgram',
     [
-        'builtins',
+        'builtin_set',
         'statements',
         'standard_libraries',
+        'string_literal_list',
         'symbol_list',
     ],
 )
@@ -145,9 +147,19 @@ def transform_expression(accumulators, expression):
             symbol_list_index=accumulators.symbol_list.index(expression.value),
         )
 
+    if isinstance(expression, parsing.FurStringLiteralExpression):
+        value = expression.value
+
+        try:
+            index = accumulators.string_literal_list.index(value)
+        except ValueError:
+            index = len(accumulators.string_literal_list)
+            accumulators.string_literal_list.append(value)
+
+        return CStringLiteral(index=index, value=value)
+
     LITERAL_TYPE_MAPPING = {
         parsing.FurIntegerLiteralExpression: CIntegerLiteral,
-        parsing.FurStringLiteralExpression: CStringLiteral,
     }
 
     if type(expression) in LITERAL_TYPE_MAPPING:
@@ -197,7 +209,7 @@ def transform_negation_expression(accumulators, negation_expression):
 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.builtins.add(function_call.function.value)
+        accumulators.builtin_set.add(function_call.function.value)
 
         return CFunctionCallExpression(
             name='builtin$' + function_call.function.value,
@@ -209,40 +221,48 @@ def transform_function_call_expression(accumulators, function_call):
 
     raise Exception()
 
+def transform_expression_statement(accumulators, statement):
+    return {
+        parsing.FurFunctionCallExpression: transform_function_call_expression,
+    }[type(statement.expression)](accumulators, statement.expression)
+
 def transform_statement(accumulators, statement):
     return {
         parsing.FurAssignmentStatement: transform_assignment_statement,
-        parsing.FurFunctionCallExpression: transform_function_call_expression,
+        parsing.FurExpressionStatement: transform_expression_statement,
     }[type(statement)](accumulators, statement)
 
 
 Accumulators = collections.namedtuple(
     'Accumulators',
     [
-        'builtins',
+        'builtin_set',
         'symbol_list',
+        'string_literal_list',
     ],
 )
 
 def transform(program):
     accumulators = Accumulators(
-        builtins=set(),
-        symbol_list = [],
+        builtin_set=set(),
+        symbol_list=[],
+        string_literal_list=[],
     )
 
-    c_statements = [
+    statement_list = [
         transform_statement(accumulators, statement) for statement in program.statement_list
     ]
 
-    standard_libraries = set()
-    for builtin in accumulators.builtins:
+    standard_library_set = set()
+    for builtin in accumulators.builtin_set:
         for standard_library in BUILTINS[builtin]:
-            standard_libraries.add(standard_library)
+            standard_library_set.add(standard_library)
 
     return CProgram(
-        builtins=accumulators.builtins,
-        statements=c_statements,
-        standard_libraries=standard_libraries,
+        builtin_set=accumulators.builtin_set,
+        statements=statement_list,
+        standard_libraries=standard_library_set,
+        string_literal_list=accumulators.string_literal_list,
         symbol_list=accumulators.symbol_list,
     )