6 NormalBuiltinExpression = collections.namedtuple(
7 'NormalBuiltinExpression',
13 NormalVariableExpression = collections.namedtuple(
14 'NormalVariableExpression',
20 NormalIntegerLiteralExpression = collections.namedtuple(
21 'NormalIntegerLiteralExpression',
27 NormalLambdaExpression = collections.namedtuple(
28 'NormalLambdaExpression',
36 NormalStringLiteralExpression = collections.namedtuple(
37 'NormalStringLiteralExpression',
43 NormalSymbolExpression = collections.namedtuple(
44 'NormalSymbolExpression',
50 NormalSymbolLiteralExpression = collections.namedtuple(
51 'NormalSymbolLiteralExpression',
57 NormalPushStatement = collections.namedtuple(
58 'NormalPushStatement',
64 NormalFunctionCallExpression = collections.namedtuple(
65 'NormalFunctionCallExpression',
68 'function_expression',
73 NormalVariableInitializationStatement = collections.namedtuple(
74 'NormalVariableInitializationStatement',
81 NormalExpressionStatement = collections.namedtuple(
82 'NormalExpressionStatement',
88 NormalAssignmentStatement = collections.namedtuple(
89 'NormalAssignmentStatement',
96 NormalIfElseExpression = collections.namedtuple(
97 'NormalIfElseExpression',
99 'condition_expression',
101 'else_statement_list',
105 NormalProgram = collections.namedtuple(
112 def normalize_builtin_expression(counter, expression):
116 NormalBuiltinExpression(symbol=expression.symbol),
119 def normalize_integer_literal_expression(counter, expression):
123 NormalIntegerLiteralExpression(integer=expression.integer),
126 def normalize_lambda_expression(counter, expression):
127 variable = '${}'.format(counter)
129 _, statement_list = normalize_statement_list(
131 expression.statement_list,
137 NormalVariableInitializationStatement(
139 expression=NormalLambdaExpression(
140 name=expression.name,
141 argument_name_list=expression.argument_name_list,
142 statement_list=statement_list,
146 NormalVariableExpression(variable=variable),
149 NormalListConstructExpression = collections.namedtuple(
150 'NormalListConstructExpression',
156 def normalize_list_literal_expression(counter, expression):
157 list_variable = '${}'.format(counter)
162 for item_expression in expression.item_expression_list:
163 counter, item_expression_prestatements, normalized = normalize_expression(
168 for p in item_expression_prestatements:
169 prestatements.append(p)
171 prestatements.append(
173 expression=normalized,
179 tuple(prestatements),
180 NormalListConstructExpression(allocate=len(expression.item_expression_list)),
183 def normalize_string_literal_expression(counter, expression):
187 NormalStringLiteralExpression(string=expression.string),
190 NormalStructureLiteralExpression = collections.namedtuple(
191 'NormalStructureLiteralExpression',
197 def normalize_structure_literal_expression(counter, expression):
200 for field in expression.fields:
201 counter, field_expression_prestatements, field_expression = normalize_expression(
206 for p in field_expression_prestatements:
207 prestatements.append(p)
209 prestatements.append(NormalPushStatement(
210 expression=field_expression,
213 prestatements.append(NormalPushStatement(
214 expression=NormalSymbolLiteralExpression(
221 tuple(prestatements),
222 NormalStructureLiteralExpression(
223 field_count=len(expression.fields),
227 def normalize_symbol_expression(counter, expression):
231 NormalSymbolExpression(symbol=expression.symbol),
234 def normalize_symbol_literal_expression(counter, expression):
238 NormalSymbolLiteralExpression(symbol=expression.symbol),
241 def normalize_function_call_expression(counter, expression):
244 for argument in expression.argument_list:
245 counter, argument_prestatements, normalized_argument = normalize_expression(counter, argument)
247 for s in argument_prestatements:
248 prestatements.append(s)
250 prestatements.append(
252 expression=normalized_argument,
256 counter, function_prestatements, function_expression = normalize_expression(
261 for ps in function_prestatements:
262 prestatements.append(ps)
266 tuple(prestatements),
267 NormalFunctionCallExpression(
268 metadata=expression.metadata,
269 function_expression=function_expression,
270 argument_count=len(expression.argument_list),
274 def normalize_if_expression(counter, expression):
275 counter, condition_prestatements, condition_expression = normalize_expression(
277 expression.condition_expression,
280 counter, if_statement_list = normalize_statement_list(
282 expression.if_statement_list,
284 counter, else_statement_list = normalize_statement_list(
286 expression.else_statement_list,
291 condition_prestatements,
292 NormalIfElseExpression(
293 condition_expression=condition_expression,
294 if_statement_list=if_statement_list,
295 else_statement_list=else_statement_list,
299 def normalize_expression(counter, expression):
301 desugaring.DesugaredBuiltinExpression: normalize_builtin_expression,
302 desugaring.DesugaredFunctionCallExpression: normalize_function_call_expression,
303 desugaring.DesugaredIfExpression: normalize_if_expression,
304 desugaring.DesugaredIntegerLiteralExpression: normalize_integer_literal_expression,
305 desugaring.DesugaredLambdaExpression: normalize_lambda_expression,
306 desugaring.DesugaredListLiteralExpression: normalize_list_literal_expression,
307 desugaring.DesugaredStringLiteralExpression: normalize_string_literal_expression,
308 desugaring.DesugaredStructureLiteralExpression: normalize_structure_literal_expression,
309 desugaring.DesugaredSymbolExpression: normalize_symbol_expression,
310 desugaring.DesugaredSymbolLiteralExpression: normalize_symbol_literal_expression,
311 }[type(expression)](counter, expression)
313 def normalize_expression_statement(counter, statement):
314 # TODO Normalized will be a NormalVariableExpression, which will go unused
315 # for expression statements in every case except when it's a return
316 # statement. This cases warnings on C compilation. We should only generate
317 # this variable when it will be used on return.
318 counter, prestatements, normalized = normalize_expression(counter, statement.expression)
323 NormalExpressionStatement(expression=normalized),
326 def normalize_assignment_statement(counter, statement):
327 counter, prestatements, normalized_expression = normalize_expression(counter, statement.expression)
331 NormalAssignmentStatement(
332 target=statement.target,
333 expression=normalized_expression,
337 def normalize_statement(counter, statement):
339 desugaring.DesugaredAssignmentStatement: normalize_assignment_statement,
340 desugaring.DesugaredExpressionStatement: normalize_expression_statement,
341 }[type(statement)](counter, statement)
343 @util.force_generator(tuple)
344 def normalize_statement_list(counter, statement_list):
345 result_statement_list = []
347 for statement in statement_list:
348 counter, prestatements, normalized = normalize_statement(counter, statement)
349 for s in prestatements:
350 result_statement_list.append(s)
351 result_statement_list.append(normalized)
355 result_statement_list,
358 def normalize(program):
359 _, statement_list = normalize_statement_list(0, program.statement_list)
361 return NormalProgram(
362 statement_list=statement_list,