CFunctionCallForFurInfixOperator = collections.namedtuple(
'CFunctionCallForFurInfixOperator',
[
+ 'metadata',
'name',
- 'left',
- 'right',
],
)
+CPushStatement = collections.namedtuple(
+ 'CPushStatement',
+ (
+ 'expression',
+ ),
+)
+
CFunctionCallExpression = collections.namedtuple(
'CFunctionCallExpression',
[
'function_expression',
'argument_count',
- 'argument_items',
],
)
'>': CInfixDeclaration(name='greaterThan', in_type='integer', out_type='boolean', operator='>'),
}
-def transform_comparison_level_expression(accumulators, expression):
- accumulators.operator_set.add(FUR_INFIX_OPERATOR_TO_C_INFIX_OPERATOR[expression.operator])
-
- # Transform expressions like 1 < 2 < 3 into expressions like 1 < 2 && 2 < 3
- if isinstance(expression.left, parsing.FurInfixExpression) and expression.left.order == 'comparison_level':
- left = transform_comparison_level_expression(
- accumulators,
- expression.left
- )
-
- middle = left.right
-
- right = transform_expression(
- accumulators,
- expression.right,
- )
-
- # TODO Don't evaluate the middle expression twice
- return CFunctionCallForFurInfixOperator(
- name='and',
- left=left,
- right=CFunctionCallForFurInfixOperator(
- name=FUR_INFIX_OPERATOR_TO_C_INFIX_OPERATOR[expression.operator].name,
- left=middle,
- right=right,
- ),
- )
-
- return CFunctionCallForFurInfixOperator(
- name=FUR_INFIX_OPERATOR_TO_C_INFIX_OPERATOR[expression.operator].name,
- left=transform_expression(accumulators, expression.left),
- right=transform_expression(accumulators, expression.right),
- )
-
def transform_infix_operator_without_c_equivalent(accumulators, expression):
return CFunctionCallForFurInfixOperator(
+ metadata=expression.metadata,
name='concatenate',
- left=transform_expression(accumulators, expression.left),
- right=transform_expression(accumulators, expression.right),
)
+
def transform_infix_expression(accumulators, expression):
if expression.operator in FUR_INFIX_OPERATOR_TO_C_FUNCTION:
return transform_infix_operator_without_c_equivalent(accumulators, expression)
- if expression.order == 'comparison_level':
- return transform_comparison_level_expression(accumulators, expression)
-
accumulators.operator_set.add(FUR_INFIX_OPERATOR_TO_C_INFIX_OPERATOR[expression.operator])
return CFunctionCallForFurInfixOperator(
+ metadata=expression.metadata,
name=FUR_INFIX_OPERATOR_TO_C_INFIX_OPERATOR[expression.operator].name,
- left=transform_expression(accumulators, expression.left),
- right=transform_expression(accumulators, expression.right),
)
def transform_integer_literal_expression(accumulators, expression):
return CFunctionCallExpression(
function_expression=transform_expression(accumulators, function_call.function_expression),
argument_count=function_call.argument_count,
- argument_items=transform_expression(accumulators, function_call.argument_items),
)
def transform_expression_statement(accumulators, statement):
return CFunctionDeclaration(name=statement.name)
+def transform_push_statement(accumulators, statement):
+ return CPushStatement(expression=transform_expression(accumulators, statement.expression))
+
def transform_statement(accumulators, statement):
return {
parsing.FurExpressionStatement: transform_expression_statement,
normalization.NormalFunctionDefinitionStatement: transform_function_definition_statement,
normalization.NormalIfElseStatement: transform_if_else_statement,
normalization.NormalListAppendStatement: transform_list_append_statement,
+ normalization.NormalPushStatement: transform_push_statement,
normalization.NormalSymbolArrayVariableInitializationStatement: transform_symbol_array_variable_initialization_statement,
normalization.NormalVariableInitializationStatement: transform_variable_initialization_statement,
normalization.NormalVariableReassignmentStatement: transform_variable_reassignment_statement,