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 NormalPushStatement = collections.namedtuple(
44 'NormalPushStatement',
50 NormalFunctionCallExpression = collections.namedtuple(
51 'NormalFunctionCallExpression',
54 'function_expression',
59 NormalArrayVariableInitializationStatement = collections.namedtuple(
60 'NormalArrayVariableInitializationStatement',
67 NormalSymbolArrayVariableInitializationStatement = collections.namedtuple(
68 'NormalSymbolArrayVariableInitializationStatement',
75 NormalVariableInitializationStatement = collections.namedtuple(
76 'NormalVariableInitializationStatement',
83 NormalExpressionStatement = collections.namedtuple(
84 'NormalExpressionStatement',
90 NormalAssignmentStatement = collections.namedtuple(
91 'NormalAssignmentStatement',
98 NormalIfElseExpression = collections.namedtuple(
99 'NormalIfElseExpression',
101 'condition_expression',
103 'else_statement_list',
107 NormalProgram = collections.namedtuple(
114 def normalize_integer_literal_expression(counter, expression):
118 NormalIntegerLiteralExpression(integer=expression.integer),
121 def normalize_lambda_expression(counter, expression):
122 variable = '${}'.format(counter)
124 _, statement_list = normalize_statement_list(
126 expression.statement_list,
132 NormalVariableInitializationStatement(
134 expression=NormalLambdaExpression(
135 name=expression.name,
136 argument_name_list=expression.argument_name_list,
137 statement_list=statement_list,
141 NormalVariableExpression(variable=variable),
144 NormalListConstructExpression = collections.namedtuple(
145 'NormalListConstructExpression',
151 NormalListAppendStatement = collections.namedtuple(
152 'NormalListAppendStatement',
159 def normalize_list_literal_expression(counter, expression):
160 list_variable = '${}'.format(counter)
165 list_expression = NormalVariableExpression(variable=list_variable)
167 for item_expression in expression.item_expression_list:
168 counter, item_expression_prestatements, normalized = normalize_expression(
173 for p in item_expression_prestatements:
174 prestatements.append(p)
176 prestatements.append(
178 expression=normalized,
182 prestatements.append(NormalVariableInitializationStatement(
183 variable=list_variable,
184 expression=NormalListConstructExpression(allocate=len(expression.item_expression_list)),
189 tuple(prestatements),
193 def normalize_string_literal_expression(counter, expression):
197 NormalStringLiteralExpression(string=expression.string),
200 NormalStructureLiteralExpression = collections.namedtuple(
201 'NormalStructureLiteralExpression',
204 'symbol_list_variable',
205 'value_list_variable',
209 def normalize_structure_literal_expression(counter, expression):
211 field_symbol_array = []
212 field_value_array = []
214 for symbol_expression_pair in expression.fields:
215 counter, field_prestatements, field_expression = normalize_expression(
217 symbol_expression_pair.expression,
220 for p in field_prestatements:
221 prestatements.append(p)
223 field_symbol_array.append(symbol_expression_pair.symbol)
224 field_value_array.append(field_expression)
226 symbol_array_variable = '${}'.format(counter)
229 prestatements.append(
230 NormalSymbolArrayVariableInitializationStatement(
231 variable=symbol_array_variable,
232 symbol_list=tuple(field_symbol_array),
236 value_array_variable = '${}'.format(counter)
239 prestatements.append(
240 NormalArrayVariableInitializationStatement(
241 variable=value_array_variable,
242 items=tuple(field_value_array),
246 variable = '${}'.format(counter)
248 prestatements.append(
249 NormalVariableInitializationStatement(
251 expression=NormalStructureLiteralExpression(
252 field_count=len(expression.fields),
253 symbol_list_variable=symbol_array_variable,
254 value_list_variable=value_array_variable,
261 tuple(prestatements),
262 NormalVariableExpression(variable=variable),
266 def normalize_symbol_expression(counter, expression):
270 NormalSymbolExpression(symbol=expression.symbol),
273 def normalize_function_call_expression(counter, expression):
276 for argument in expression.argument_list:
277 counter, argument_prestatements, normalized_argument = normalize_expression(counter, argument)
279 for s in argument_prestatements:
280 prestatements.append(s)
282 prestatements.append(
284 expression=normalized_argument,
288 counter, function_prestatements, function_expression = normalize_expression(
293 for ps in function_prestatements:
294 prestatements.append(ps)
296 result_variable = '${}'.format(counter)
298 prestatements.append(
299 NormalVariableInitializationStatement(
300 variable=result_variable,
301 expression=NormalFunctionCallExpression(
302 metadata=expression.metadata,
303 function_expression=function_expression,
304 argument_count=len(expression.argument_list),
311 tuple(prestatements),
312 NormalVariableExpression(variable=result_variable),
315 def normalize_if_expression(counter, expression):
316 counter, condition_prestatements, condition_expression = normalize_expression(
318 expression.condition_expression,
321 counter, if_statement_list = normalize_statement_list(
323 expression.if_statement_list,
325 counter, else_statement_list = normalize_statement_list(
327 expression.else_statement_list,
332 condition_prestatements,
333 NormalIfElseExpression(
334 condition_expression=condition_expression,
335 if_statement_list=if_statement_list,
336 else_statement_list=else_statement_list,
340 def normalize_expression(counter, expression):
342 desugaring.DesugaredFunctionCallExpression: normalize_function_call_expression,
343 desugaring.DesugaredIfExpression: normalize_if_expression,
344 desugaring.DesugaredIntegerLiteralExpression: normalize_integer_literal_expression,
345 desugaring.DesugaredLambdaExpression: normalize_lambda_expression,
346 desugaring.DesugaredListLiteralExpression: normalize_list_literal_expression,
347 desugaring.DesugaredStringLiteralExpression: normalize_string_literal_expression,
348 desugaring.DesugaredStructureLiteralExpression: normalize_structure_literal_expression,
349 desugaring.DesugaredSymbolExpression: normalize_symbol_expression,
350 }[type(expression)](counter, expression)
352 def normalize_expression_statement(counter, statement):
353 # TODO Normalized will be a NormalVariableExpression, which will go unused
354 # for expression statements in every case except when it's a return
355 # statement. This cases warnings on C compilation. We should only generate
356 # this variable when it will be used on return.
357 counter, prestatements, normalized = normalize_expression(counter, statement.expression)
362 NormalExpressionStatement(expression=normalized),
365 def normalize_assignment_statement(counter, statement):
366 counter, prestatements, normalized_expression = normalize_expression(counter, statement.expression)
370 NormalAssignmentStatement(
371 target=statement.target,
372 expression=normalized_expression,
376 def normalize_statement(counter, statement):
378 desugaring.DesugaredAssignmentStatement: normalize_assignment_statement,
379 desugaring.DesugaredExpressionStatement: normalize_expression_statement,
380 }[type(statement)](counter, statement)
382 @util.force_generator(tuple)
383 def normalize_statement_list(counter, statement_list):
384 result_statement_list = []
386 for statement in statement_list:
387 counter, prestatements, normalized = normalize_statement(counter, statement)
388 for s in prestatements:
389 result_statement_list.append(s)
390 result_statement_list.append(normalized)
394 result_statement_list,
397 def normalize(program):
398 _, statement_list = normalize_statement_list(0, program.statement_list)
400 return NormalProgram(
401 statement_list=statement_list,