],
)
-CVariableReassignmentStatement = collections.namedtuple(
- 'CVariableReassignmentStatement',
- [
- 'variable',
- 'expression',
- ],
-)
-
CExpressionStatement = collections.namedtuple(
'CExpressionStatement',
[
],
)
-CIfElseStatement = collections.namedtuple(
- 'CIfElseStatement',
+CIfElseExpression = collections.namedtuple(
+ 'CIfElseExpression',
[
'condition_expression',
'if_statement_list',
'CFunctionDefinition',
[
'name',
+ 'index',
'argument_name_list',
'statement_list',
],
'CLambdaExpression',
(
'name',
+ 'index',
),
)
)
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)
-
if expression.name is None:
- name = '__lambda_{}'.format(accumulators.lambda_number_list[-1])
+ name = '__lambda'
else:
name = expression.name
+ index = accumulators.function_name_iterators.get(name, 0)
+ accumulators.function_name_iterators[name] = index + 1
+
accumulators.function_definition_list.append(CFunctionDefinition(
name=name,
+ index=index,
argument_name_list=expression.argument_name_list,
statement_list=tuple(transform_statement(accumulators, s) for s in expression.statement_list),
))
- return CLambdaExpression(name=name)
+ return CLambdaExpression(
+ name=name,
+ index=index,
+ )
def transform_list_construct_expression(accumulators, expression):
def transform_expression(accumulators, expression):
return {
conversion.CPSFunctionCallExpression: transform_function_call_expression,
+ conversion.CPSIfElseExpression: transform_if_else_expression,
conversion.CPSIntegerLiteralExpression: transform_integer_literal_expression,
conversion.CPSLambdaExpression: transform_lambda_expression,
conversion.CPSListConstructExpression: transform_list_construct_expression,
expression=transform_expression(accumulators, statement.expression),
)
-def transform_if_else_statement(accumulators, statement):
- return CIfElseStatement(
+def transform_if_else_expression(accumulators, statement):
+ return CIfElseExpression(
condition_expression=transform_expression(accumulators, statement.condition_expression),
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),
expression=transform_expression(accumulators, statement.expression),
)
-def transform_variable_reassignment_statement(accumulators, statement):
- return CVariableReassignmentStatement(
- variable=statement.variable,
- expression=transform_expression(accumulators, statement.expression),
- )
-
def transform_push_statement(accumulators, statement):
return CPushStatement(expression=transform_expression(accumulators, statement.expression))
conversion.CPSArrayVariableInitializationStatement: transform_array_variable_initialization_statement,
conversion.CPSAssignmentStatement: transform_symbol_assignment_statement,
conversion.CPSExpressionStatement: transform_expression_statement,
- conversion.CPSIfElseStatement: transform_if_else_statement,
conversion.CPSListAppendStatement: transform_list_append_statement,
conversion.CPSPushStatement: transform_push_statement,
conversion.CPSSymbolArrayVariableInitializationStatement: transform_symbol_array_variable_initialization_statement,
conversion.CPSVariableInitializationStatement: transform_variable_initialization_statement,
- conversion.CPSVariableReassignmentStatement: transform_variable_reassignment_statement,
}[type(statement)](accumulators, statement)
[
'builtin_set',
'function_definition_list',
- 'lambda_number_list',
+ 'function_name_iterators',
'operator_set',
'symbol_list',
'string_literal_list',
accumulators = Accumulators(
builtin_set=set(),
function_definition_list=[],
- lambda_number_list=[],
+ function_name_iterators={},
operator_set=set(),
symbol_list=[],
string_literal_list=[],