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 def normalize_list_literal_expression(counter, expression):
143 list_variable = '${}'.format(counter)
148 for item_expression in expression.item_expression_list:
149 counter, item_expression_prestatements, normalized = normalize_expression(
154 for p in item_expression_prestatements:
155 prestatements.append(p)
157 prestatements.append(
159 expression=normalized,
165 tuple(prestatements),
166 NormalListConstructExpression(allocate=len(expression.item_expression_list)),
169 def normalize_string_literal_expression(counter, expression):
173 NormalStringLiteralExpression(string=expression.string),
176 NormalStructureLiteralExpression = collections.namedtuple(
177 'NormalStructureLiteralExpression',
183 def normalize_structure_literal_expression(counter, expression):
186 for field in expression.fields:
187 counter, field_expression_prestatements, field_expression = normalize_expression(
192 for p in field_expression_prestatements:
193 prestatements.append(p)
195 prestatements.append(NormalPushStatement(
196 expression=field_expression,
199 prestatements.append(NormalPushStatement(
200 expression=NormalSymbolLiteralExpression(
207 tuple(prestatements),
208 NormalStructureLiteralExpression(
209 field_count=len(expression.fields),
213 def normalize_symbol_expression(counter, expression):
217 NormalSymbolExpression(symbol=expression.symbol),
220 def normalize_function_call_expression(counter, expression):
223 for argument in expression.argument_list:
224 counter, argument_prestatements, normalized_argument = normalize_expression(counter, argument)
226 for s in argument_prestatements:
227 prestatements.append(s)
229 prestatements.append(
231 expression=normalized_argument,
235 counter, function_prestatements, function_expression = normalize_expression(
240 for ps in function_prestatements:
241 prestatements.append(ps)
243 result_variable = '${}'.format(counter)
245 prestatements.append(
246 NormalVariableInitializationStatement(
247 variable=result_variable,
248 expression=NormalFunctionCallExpression(
249 metadata=expression.metadata,
250 function_expression=function_expression,
251 argument_count=len(expression.argument_list),
258 tuple(prestatements),
259 NormalVariableExpression(variable=result_variable),
262 def normalize_if_expression(counter, expression):
263 counter, condition_prestatements, condition_expression = normalize_expression(
265 expression.condition_expression,
268 counter, if_statement_list = normalize_statement_list(
270 expression.if_statement_list,
272 counter, else_statement_list = normalize_statement_list(
274 expression.else_statement_list,
279 condition_prestatements,
280 NormalIfElseExpression(
281 condition_expression=condition_expression,
282 if_statement_list=if_statement_list,
283 else_statement_list=else_statement_list,
287 def normalize_expression(counter, expression):
289 desugaring.DesugaredFunctionCallExpression: normalize_function_call_expression,
290 desugaring.DesugaredIfExpression: normalize_if_expression,
291 desugaring.DesugaredIntegerLiteralExpression: normalize_integer_literal_expression,
292 desugaring.DesugaredLambdaExpression: normalize_lambda_expression,
293 desugaring.DesugaredListLiteralExpression: normalize_list_literal_expression,
294 desugaring.DesugaredStringLiteralExpression: normalize_string_literal_expression,
295 desugaring.DesugaredStructureLiteralExpression: normalize_structure_literal_expression,
296 desugaring.DesugaredSymbolExpression: normalize_symbol_expression,
297 }[type(expression)](counter, expression)
299 def normalize_expression_statement(counter, statement):
300 # TODO Normalized will be a NormalVariableExpression, which will go unused
301 # for expression statements in every case except when it's a return
302 # statement. This cases warnings on C compilation. We should only generate
303 # this variable when it will be used on return.
304 counter, prestatements, normalized = normalize_expression(counter, statement.expression)
309 NormalExpressionStatement(expression=normalized),
312 def normalize_assignment_statement(counter, statement):
313 counter, prestatements, normalized_expression = normalize_expression(counter, statement.expression)
317 NormalAssignmentStatement(
318 target=statement.target,
319 expression=normalized_expression,
323 def normalize_statement(counter, statement):
325 desugaring.DesugaredAssignmentStatement: normalize_assignment_statement,
326 desugaring.DesugaredExpressionStatement: normalize_expression_statement,
327 }[type(statement)](counter, statement)
329 @util.force_generator(tuple)
330 def normalize_statement_list(counter, statement_list):
331 result_statement_list = []
333 for statement in statement_list:
334 counter, prestatements, normalized = normalize_statement(counter, statement)
335 for s in prestatements:
336 result_statement_list.append(s)
337 result_statement_list.append(normalized)
341 result_statement_list,
344 def normalize(program):
345 _, statement_list = normalize_statement_list(0, program.statement_list)
347 return NormalProgram(
348 statement_list=statement_list,