6 NormalVariableExpression = collections.namedtuple(
7 'NormalVariableExpression',
13 NormalIntegerLiteralExpression = collections.namedtuple(
14 'NormalIntegerLiteralExpression',
20 NormalLambdaExpression = collections.namedtuple(
21 'NormalLambdaExpression',
29 NormalStringLiteralExpression = collections.namedtuple(
30 'NormalStringLiteralExpression',
36 NormalSymbolExpression = collections.namedtuple(
37 'NormalSymbolExpression',
43 NormalSymbolLiteralExpression = collections.namedtuple(
44 'NormalSymbolLiteralExpression',
50 NormalPushStatement = collections.namedtuple(
51 'NormalPushStatement',
57 NormalFunctionCallExpression = collections.namedtuple(
58 'NormalFunctionCallExpression',
61 'function_expression',
66 NormalVariableInitializationStatement = collections.namedtuple(
67 'NormalVariableInitializationStatement',
74 NormalExpressionStatement = collections.namedtuple(
75 'NormalExpressionStatement',
81 NormalAssignmentStatement = collections.namedtuple(
82 'NormalAssignmentStatement',
89 NormalIfElseExpression = collections.namedtuple(
90 'NormalIfElseExpression',
92 'condition_expression',
94 'else_statement_list',
98 NormalProgram = collections.namedtuple(
105 def normalize_integer_literal_expression(counter, expression):
109 NormalIntegerLiteralExpression(integer=expression.integer),
112 def normalize_lambda_expression(counter, expression):
113 variable = '${}'.format(counter)
115 _, statement_list = normalize_statement_list(
117 expression.statement_list,
123 NormalVariableInitializationStatement(
125 expression=NormalLambdaExpression(
126 name=expression.name,
127 argument_name_list=expression.argument_name_list,
128 statement_list=statement_list,
132 NormalVariableExpression(variable=variable),
135 NormalListConstructExpression = collections.namedtuple(
136 'NormalListConstructExpression',
142 NormalListAppendStatement = collections.namedtuple(
143 'NormalListAppendStatement',
150 def normalize_list_literal_expression(counter, expression):
151 list_variable = '${}'.format(counter)
156 for item_expression in expression.item_expression_list:
157 counter, item_expression_prestatements, normalized = normalize_expression(
162 for p in item_expression_prestatements:
163 prestatements.append(p)
165 prestatements.append(
167 expression=normalized,
173 tuple(prestatements),
174 NormalListConstructExpression(allocate=len(expression.item_expression_list)),
177 def normalize_string_literal_expression(counter, expression):
181 NormalStringLiteralExpression(string=expression.string),
184 NormalStructureLiteralExpression = collections.namedtuple(
185 'NormalStructureLiteralExpression',
191 def normalize_structure_literal_expression(counter, expression):
194 for field in expression.fields:
195 counter, field_expression_prestatements, field_expression = normalize_expression(
200 for p in field_expression_prestatements:
201 prestatements.append(p)
203 prestatements.append(NormalPushStatement(
204 expression=field_expression,
207 prestatements.append(NormalPushStatement(
208 expression=NormalSymbolLiteralExpression(
215 tuple(prestatements),
216 NormalStructureLiteralExpression(
217 field_count=len(expression.fields),
221 def normalize_symbol_expression(counter, expression):
225 NormalSymbolExpression(symbol=expression.symbol),
228 def normalize_function_call_expression(counter, expression):
231 for argument in expression.argument_list:
232 counter, argument_prestatements, normalized_argument = normalize_expression(counter, argument)
234 for s in argument_prestatements:
235 prestatements.append(s)
237 prestatements.append(
239 expression=normalized_argument,
243 counter, function_prestatements, function_expression = normalize_expression(
248 for ps in function_prestatements:
249 prestatements.append(ps)
251 result_variable = '${}'.format(counter)
253 prestatements.append(
254 NormalVariableInitializationStatement(
255 variable=result_variable,
256 expression=NormalFunctionCallExpression(
257 metadata=expression.metadata,
258 function_expression=function_expression,
259 argument_count=len(expression.argument_list),
266 tuple(prestatements),
267 NormalVariableExpression(variable=result_variable),
270 def normalize_if_expression(counter, expression):
271 counter, condition_prestatements, condition_expression = normalize_expression(
273 expression.condition_expression,
276 counter, if_statement_list = normalize_statement_list(
278 expression.if_statement_list,
280 counter, else_statement_list = normalize_statement_list(
282 expression.else_statement_list,
287 condition_prestatements,
288 NormalIfElseExpression(
289 condition_expression=condition_expression,
290 if_statement_list=if_statement_list,
291 else_statement_list=else_statement_list,
295 def normalize_expression(counter, expression):
297 desugaring.DesugaredFunctionCallExpression: normalize_function_call_expression,
298 desugaring.DesugaredIfExpression: normalize_if_expression,
299 desugaring.DesugaredIntegerLiteralExpression: normalize_integer_literal_expression,
300 desugaring.DesugaredLambdaExpression: normalize_lambda_expression,
301 desugaring.DesugaredListLiteralExpression: normalize_list_literal_expression,
302 desugaring.DesugaredStringLiteralExpression: normalize_string_literal_expression,
303 desugaring.DesugaredStructureLiteralExpression: normalize_structure_literal_expression,
304 desugaring.DesugaredSymbolExpression: normalize_symbol_expression,
305 }[type(expression)](counter, expression)
307 def normalize_expression_statement(counter, statement):
308 # TODO Normalized will be a NormalVariableExpression, which will go unused
309 # for expression statements in every case except when it's a return
310 # statement. This cases warnings on C compilation. We should only generate
311 # this variable when it will be used on return.
312 counter, prestatements, normalized = normalize_expression(counter, statement.expression)
317 NormalExpressionStatement(expression=normalized),
320 def normalize_assignment_statement(counter, statement):
321 counter, prestatements, normalized_expression = normalize_expression(counter, statement.expression)
325 NormalAssignmentStatement(
326 target=statement.target,
327 expression=normalized_expression,
331 def normalize_statement(counter, statement):
333 desugaring.DesugaredAssignmentStatement: normalize_assignment_statement,
334 desugaring.DesugaredExpressionStatement: normalize_expression_statement,
335 }[type(statement)](counter, statement)
337 @util.force_generator(tuple)
338 def normalize_statement_list(counter, statement_list):
339 result_statement_list = []
341 for statement in statement_list:
342 counter, prestatements, normalized = normalize_statement(counter, statement)
343 for s in prestatements:
344 result_statement_list.append(s)
345 result_statement_list.append(normalized)
349 result_statement_list,
352 def normalize(program):
353 _, statement_list = normalize_statement_list(0, program.statement_list)
355 return NormalProgram(
356 statement_list=statement_list,