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 NormalVariableReassignmentStatement = collections.namedtuple(
84 'NormalVariableReassignmentStatement',
91 NormalExpressionStatement = collections.namedtuple(
92 'NormalExpressionStatement',
98 NormalAssignmentStatement = collections.namedtuple(
99 'NormalAssignmentStatement',
106 NormalIfElseStatement = collections.namedtuple(
107 'NormalIfElseStatement',
109 'condition_expression',
111 'else_statement_list',
115 NormalProgram = collections.namedtuple(
122 def normalize_integer_literal_expression(counter, expression):
126 NormalIntegerLiteralExpression(integer=expression.integer),
129 def normalize_lambda_expression(counter, expression):
130 variable = '${}'.format(counter)
132 _, statement_list = normalize_statement_list(
134 expression.statement_list,
135 assign_result_to='result',
141 NormalVariableInitializationStatement(
143 expression=NormalLambdaExpression(
144 name=expression.name,
145 argument_name_list=expression.argument_name_list,
146 statement_list=statement_list,
150 NormalVariableExpression(variable=variable),
153 NormalListConstructExpression = collections.namedtuple(
154 'NormalListConstructExpression',
160 NormalListAppendStatement = collections.namedtuple(
161 'NormalListAppendStatement',
168 def normalize_list_literal_expression(counter, expression):
169 list_variable = '${}'.format(counter)
173 NormalVariableInitializationStatement(
174 variable=list_variable,
175 expression=NormalListConstructExpression(allocate=len(expression.item_expression_list)),
179 list_expression = NormalVariableExpression(variable=list_variable)
181 for item_expression in expression.item_expression_list:
182 counter, item_expression_prestatements, normalized = normalize_expression(
187 for p in item_expression_prestatements:
188 prestatements.append(p)
190 prestatements.append(
191 NormalListAppendStatement(
192 list_expression=list_expression,
193 item_expression=normalized,
199 tuple(prestatements),
203 def normalize_string_literal_expression(counter, expression):
207 NormalStringLiteralExpression(string=expression.string),
210 NormalStructureLiteralExpression = collections.namedtuple(
211 'NormalStructureLiteralExpression',
214 'symbol_list_variable',
215 'value_list_variable',
219 def normalize_structure_literal_expression(counter, expression):
221 field_symbol_array = []
222 field_value_array = []
224 for symbol_expression_pair in expression.fields:
225 counter, field_prestatements, field_expression = normalize_expression(
227 symbol_expression_pair.expression,
230 for p in field_prestatements:
231 prestatements.append(p)
233 field_symbol_array.append(symbol_expression_pair.symbol)
234 field_value_array.append(field_expression)
236 symbol_array_variable = '${}'.format(counter)
239 prestatements.append(
240 NormalSymbolArrayVariableInitializationStatement(
241 variable=symbol_array_variable,
242 symbol_list=tuple(field_symbol_array),
246 value_array_variable = '${}'.format(counter)
249 prestatements.append(
250 NormalArrayVariableInitializationStatement(
251 variable=value_array_variable,
252 items=tuple(field_value_array),
256 variable = '${}'.format(counter)
258 prestatements.append(
259 NormalVariableInitializationStatement(
261 expression=NormalStructureLiteralExpression(
262 field_count=len(expression.fields),
263 symbol_list_variable=symbol_array_variable,
264 value_list_variable=value_array_variable,
271 tuple(prestatements),
272 NormalVariableExpression(variable=variable),
276 def normalize_symbol_expression(counter, expression):
280 NormalSymbolExpression(symbol=expression.symbol),
283 def normalize_function_call_expression(counter, expression):
286 for argument in expression.argument_list:
287 counter, argument_prestatements, normalized_argument = normalize_expression(counter, argument)
289 for s in argument_prestatements:
290 prestatements.append(s)
292 prestatements.append(
294 expression=normalized_argument,
298 counter, function_prestatements, function_expression = normalize_expression(
303 for ps in function_prestatements:
304 prestatements.append(ps)
306 result_variable = '${}'.format(counter)
308 prestatements.append(
309 NormalVariableInitializationStatement(
310 variable=result_variable,
311 expression=NormalFunctionCallExpression(
312 metadata=expression.metadata,
313 function_expression=function_expression,
314 argument_count=len(expression.argument_list),
321 tuple(prestatements),
322 NormalVariableExpression(variable=result_variable),
325 def normalize_if_expression(counter, expression):
326 counter, condition_prestatements, condition_expression = normalize_expression(
328 expression.condition_expression,
331 result_variable = '${}'.format(counter)
334 counter, if_statement_list = normalize_statement_list(
336 expression.if_statement_list,
337 assign_result_to=result_variable,
339 counter, else_statement_list = normalize_statement_list(
341 expression.else_statement_list,
342 assign_result_to=result_variable,
347 condition_prestatements + (
348 NormalVariableInitializationStatement(
349 variable=result_variable,
350 expression=NormalVariableExpression(variable='builtin$nil'),
352 NormalIfElseStatement(
353 condition_expression=condition_expression,
354 if_statement_list=if_statement_list,
355 else_statement_list=else_statement_list,
358 NormalVariableExpression(variable=result_variable),
361 def normalize_expression(counter, expression):
363 desugaring.DesugaredFunctionCallExpression: normalize_function_call_expression,
364 desugaring.DesugaredIfExpression: normalize_if_expression,
365 desugaring.DesugaredIntegerLiteralExpression: normalize_integer_literal_expression,
366 desugaring.DesugaredLambdaExpression: normalize_lambda_expression,
367 desugaring.DesugaredListLiteralExpression: normalize_list_literal_expression,
368 desugaring.DesugaredStringLiteralExpression: normalize_string_literal_expression,
369 desugaring.DesugaredStructureLiteralExpression: normalize_structure_literal_expression,
370 desugaring.DesugaredSymbolExpression: normalize_symbol_expression,
371 }[type(expression)](counter, expression)
373 def normalize_expression_statement(counter, statement):
374 # TODO Normalized will be a NormalVariableExpression, which will go unused
375 # for expression statements in every case except when it's a return
376 # statement. This cases warnings on C compilation. We should only generate
377 # this variable when it will be used on return.
378 counter, prestatements, normalized = normalize_expression(counter, statement.expression)
383 NormalExpressionStatement(expression=normalized),
386 def normalize_assignment_statement(counter, statement):
387 counter, prestatements, normalized_expression = normalize_expression(counter, statement.expression)
391 NormalAssignmentStatement(
392 target=statement.target,
393 expression=normalized_expression,
397 def normalize_statement(counter, statement):
399 desugaring.DesugaredAssignmentStatement: normalize_assignment_statement,
400 desugaring.DesugaredExpressionStatement: normalize_expression_statement,
401 }[type(statement)](counter, statement)
403 @util.force_generator(tuple)
404 def normalize_statement_list(counter, statement_list, **kwargs):
405 assign_result_to = kwargs.pop('assign_result_to', None)
407 assert len(kwargs) == 0
409 result_statement_list = []
411 for statement in statement_list:
412 counter, prestatements, normalized = normalize_statement(counter, statement)
413 for s in prestatements:
414 result_statement_list.append(s)
415 result_statement_list.append(normalized)
417 # TODO The way we fix the last statement is really confusing
418 last_statement = result_statement_list[-1]
420 if isinstance(last_statement, NormalExpressionStatement) and isinstance(last_statement.expression, NormalVariableExpression):
421 if assign_result_to is not None:
422 result_expression = result_statement_list.pop().expression
423 result_statement_list.append(
424 NormalVariableReassignmentStatement(
425 variable=assign_result_to,
426 expression=result_expression,
432 result_statement_list,
435 def normalize(program):
436 _, statement_list = normalize_statement_list(0, program.statement_list)
438 return NormalProgram(
439 statement_list=statement_list,