-def transform_expression(builtin_dependencies, expression):
- if isinstance(expression, parsing.FurNegationExpression):
- return transform_negation_expression(builtin_dependencies, expression)
-
- if isinstance(expression, parsing.FurFunctionCallExpression):
- return transform_function_call_expression(builtin_dependencies, expression)
-
- LITERAL_TYPE_MAPPING = {
- parsing.FurIntegerLiteralExpression: CIntegerLiteral,
- parsing.FurStringLiteralExpression: CStringLiteral,
- parsing.FurSymbolExpression: CSymbolExpression,
- }
-
- if type(expression) in LITERAL_TYPE_MAPPING:
- return LITERAL_TYPE_MAPPING[type(expression)](value=expression.value)
-
- INFIX_TYPE_MAPPING = {
- parsing.FurAdditionExpression: CAdditionExpression,
- parsing.FurSubtractionExpression: CSubtractionExpression,
- parsing.FurMultiplicationExpression: CMultiplicationExpression,
- parsing.FurIntegerDivisionExpression: CIntegerDivisionExpression,
- parsing.FurModularDivisionExpression: CModularDivisionExpression,
- }
-
- return INFIX_TYPE_MAPPING[type(expression)](
- left=transform_expression(builtin_dependencies, expression.left),
- right=transform_expression(builtin_dependencies, expression.right),
+def transform_variable_expression(accumulators, expression):
+ assert isinstance(expression, conversion.CPSVariableExpression)
+ return CVariableExpression(variable=expression.variable)
+
+def transform_string_literal_expression(accumulators, expression):
+ value = expression.string
+
+ 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)
+
+def transform_symbol_expression(accumulators, expression):
+ if expression.symbol in BUILTINS:
+ accumulators.builtin_set.add(expression.symbol)
+
+ try:
+ symbol_list_index = accumulators.symbol_list.index(expression.symbol)
+ except ValueError:
+ symbol_list_index = len(accumulators.symbol_list)
+ accumulators.symbol_list.append(expression.symbol)
+
+ return CSymbolExpression(
+ symbol=expression.symbol,
+ symbol_list_index=symbol_list_index,
+ )
+
+def transform_integer_literal_expression(accumulators, expression):
+ return CIntegerLiteral(value=expression.integer)
+
+CListConstructExpression = collections.namedtuple(
+ 'CListConstructExpression',
+ (
+ 'allocate',
+ ),
+)
+
+CLambdaExpression = collections.namedtuple(
+ 'CLambdaExpression',
+ (
+ 'name',
+ ),
+)
+
+CListAppendStatement = collections.namedtuple(
+ 'CListAppendStatement',
+ (
+ 'list_expression',
+ 'item_expression',
+ ),
+)
+
+def transform_structure_literal_expression(accumulators, expression):
+ return CStructureLiteralExpression(
+ field_count=expression.field_count,
+ symbol_list_variable=expression.symbol_list_variable,
+ 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_append_statement(accumulators, expression):
+ return CListAppendStatement(
+ list_expression=transform_expression(accumulators, expression.list_expression),
+ item_expression=transform_expression(accumulators, expression.item_expression),