NormalFunctionCallExpression = collections.namedtuple(
'NormalFunctionCallExpression',
[
- 'function',
+ 'function_expression',
'argument_count',
'argument_items',
],
)
def normalize_symbol_expression(counter, expression):
- # TODO Store this in a C variable
+ variable = '${}'.format(counter)
return (
- counter,
- (),
- NormalSymbolExpression(symbol=expression.symbol),
+ counter + 1,
+ (NormalVariableInitializationStatement(
+ variable=variable,
+ expression=NormalSymbolExpression(symbol=expression.symbol),
+ ),),
+ NormalVariableExpression(variable=variable),
)
def normalize_function_call_expression(counter, expression):
for ps in function_prestatements:
prestatements.append(ps)
+ if not isinstance(function_expression, NormalVariableExpression):
+ function_variable = '${}'.format(counter)
+
+ prestatements.append(NormalVariableInitializationStatement(
+ variable=function_variable,
+ expression=function_expression,
+ ))
+
+ function_expression = NormalVariableExpression(variable=function_variable)
+ counter += 1
+
return (
counter,
tuple(prestatements),
NormalFunctionCallExpression(
- function=function_expression,
+ function_expression=function_expression,
argument_count=len(arguments),
argument_items=NormalVariableExpression(variable=arguments_variable),
),
}[type(expression)](counter, expression)
def normalize_expression_statement(counter, statement):
+ # TODO Normalized will be a NormalVariableExpression, which will go unused
+ # for expression statements in every case except when it's a return
+ # statement. This cases warnings on C compilation. We should only generate
+ # this variable when it will be used on return.
counter, prestatements, normalized = normalize_expression(counter, statement.expression)
return (
yield normalized
def normalize(program):
-
return NormalProgram(
statement_list=normalize_statement_list(program.statement_list),
)