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 for item_expression in expression.item_expression_list:
166 counter, item_expression_prestatements, normalized = normalize_expression(
171 for p in item_expression_prestatements:
172 prestatements.append(p)
174 prestatements.append(
176 expression=normalized,
182 tuple(prestatements),
183 NormalListConstructExpression(allocate=len(expression.item_expression_list)),
186 def normalize_string_literal_expression(counter, expression):
190 NormalStringLiteralExpression(string=expression.string),
193 NormalStructureLiteralExpression = collections.namedtuple(
194 'NormalStructureLiteralExpression',
197 'symbol_list_variable',
198 'value_list_variable',
202 def normalize_structure_literal_expression(counter, expression):
204 field_symbol_array = []
205 field_value_array = []
207 for symbol_expression_pair in expression.fields:
208 counter, field_prestatements, field_expression = normalize_expression(
210 symbol_expression_pair.expression,
213 for p in field_prestatements:
214 prestatements.append(p)
216 field_symbol_array.append(symbol_expression_pair.symbol)
217 field_value_array.append(field_expression)
219 symbol_array_variable = '${}'.format(counter)
222 prestatements.append(
223 NormalSymbolArrayVariableInitializationStatement(
224 variable=symbol_array_variable,
225 symbol_list=tuple(field_symbol_array),
229 value_array_variable = '${}'.format(counter)
232 prestatements.append(
233 NormalArrayVariableInitializationStatement(
234 variable=value_array_variable,
235 items=tuple(field_value_array),
239 variable = '${}'.format(counter)
241 prestatements.append(
242 NormalVariableInitializationStatement(
244 expression=NormalStructureLiteralExpression(
245 field_count=len(expression.fields),
246 symbol_list_variable=symbol_array_variable,
247 value_list_variable=value_array_variable,
254 tuple(prestatements),
255 NormalVariableExpression(variable=variable),
259 def normalize_symbol_expression(counter, expression):
263 NormalSymbolExpression(symbol=expression.symbol),
266 def normalize_function_call_expression(counter, expression):
269 for argument in expression.argument_list:
270 counter, argument_prestatements, normalized_argument = normalize_expression(counter, argument)
272 for s in argument_prestatements:
273 prestatements.append(s)
275 prestatements.append(
277 expression=normalized_argument,
281 counter, function_prestatements, function_expression = normalize_expression(
286 for ps in function_prestatements:
287 prestatements.append(ps)
289 result_variable = '${}'.format(counter)
291 prestatements.append(
292 NormalVariableInitializationStatement(
293 variable=result_variable,
294 expression=NormalFunctionCallExpression(
295 metadata=expression.metadata,
296 function_expression=function_expression,
297 argument_count=len(expression.argument_list),
304 tuple(prestatements),
305 NormalVariableExpression(variable=result_variable),
308 def normalize_if_expression(counter, expression):
309 counter, condition_prestatements, condition_expression = normalize_expression(
311 expression.condition_expression,
314 counter, if_statement_list = normalize_statement_list(
316 expression.if_statement_list,
318 counter, else_statement_list = normalize_statement_list(
320 expression.else_statement_list,
325 condition_prestatements,
326 NormalIfElseExpression(
327 condition_expression=condition_expression,
328 if_statement_list=if_statement_list,
329 else_statement_list=else_statement_list,
333 def normalize_expression(counter, expression):
335 desugaring.DesugaredFunctionCallExpression: normalize_function_call_expression,
336 desugaring.DesugaredIfExpression: normalize_if_expression,
337 desugaring.DesugaredIntegerLiteralExpression: normalize_integer_literal_expression,
338 desugaring.DesugaredLambdaExpression: normalize_lambda_expression,
339 desugaring.DesugaredListLiteralExpression: normalize_list_literal_expression,
340 desugaring.DesugaredStringLiteralExpression: normalize_string_literal_expression,
341 desugaring.DesugaredStructureLiteralExpression: normalize_structure_literal_expression,
342 desugaring.DesugaredSymbolExpression: normalize_symbol_expression,
343 }[type(expression)](counter, expression)
345 def normalize_expression_statement(counter, statement):
346 # TODO Normalized will be a NormalVariableExpression, which will go unused
347 # for expression statements in every case except when it's a return
348 # statement. This cases warnings on C compilation. We should only generate
349 # this variable when it will be used on return.
350 counter, prestatements, normalized = normalize_expression(counter, statement.expression)
355 NormalExpressionStatement(expression=normalized),
358 def normalize_assignment_statement(counter, statement):
359 counter, prestatements, normalized_expression = normalize_expression(counter, statement.expression)
363 NormalAssignmentStatement(
364 target=statement.target,
365 expression=normalized_expression,
369 def normalize_statement(counter, statement):
371 desugaring.DesugaredAssignmentStatement: normalize_assignment_statement,
372 desugaring.DesugaredExpressionStatement: normalize_expression_statement,
373 }[type(statement)](counter, statement)
375 @util.force_generator(tuple)
376 def normalize_statement_list(counter, statement_list):
377 result_statement_list = []
379 for statement in statement_list:
380 counter, prestatements, normalized = normalize_statement(counter, statement)
381 for s in prestatements:
382 result_statement_list.append(s)
383 result_statement_list.append(normalized)
387 result_statement_list,
390 def normalize(program):
391 _, statement_list = normalize_statement_list(0, program.statement_list)
393 return NormalProgram(
394 statement_list=statement_list,