6 CIntegerLiteral = collections.namedtuple(
13 CStringLiteral = collections.namedtuple(
21 CConstantExpression = collections.namedtuple(
22 'CConstantExpression',
28 CVariableExpression = collections.namedtuple(
29 'CVariableExpression',
35 CSymbolExpression = collections.namedtuple(
43 CNegationExpression = collections.namedtuple(
44 'CNegationExpression',
50 CFunctionCallForFurInfixOperator = collections.namedtuple(
51 'CFunctionCallForFurInfixOperator',
59 CFunctionCallExpression = collections.namedtuple(
60 'CFunctionCallExpression',
68 CSymbolAssignmentStatement = collections.namedtuple(
69 'CSymbolAssignmentStatement',
72 'target_symbol_list_index',
77 CArrayVariableInitializationStatement = collections.namedtuple(
78 'CArrayVariableInitializationStatement',
85 CVariableInitializationStatement = collections.namedtuple(
86 'CVariableInitializationStatement',
93 CVariableReassignmentStatement = collections.namedtuple(
94 'CVariableReassignmentStatement',
101 CExpressionStatement = collections.namedtuple(
102 'CExpressionStatement',
108 CIfElseStatement = collections.namedtuple(
111 'condition_expression',
117 CFunctionDeclaration = collections.namedtuple(
118 'CFunctionDeclaration',
124 CFunctionDefinition = collections.namedtuple(
125 'CFunctionDefinition',
128 'argument_name_list',
133 CProgram = collections.namedtuple(
137 'function_definition_list',
138 'operator_declarations',
140 'standard_libraries',
141 'string_literal_list',
149 'print': ['stdio.h'],
153 def transform_variable_expression(accumulators, expression):
154 return CVariableExpression(variable=expression.variable)
156 def transform_string_literal(accumulators, expression):
157 value = expression.value
160 index = accumulators.string_literal_list.index(value)
162 index = len(accumulators.string_literal_list)
163 accumulators.string_literal_list.append(value)
165 return CStringLiteral(index=index, value=value)
167 def transform_symbol_expression(accumulators, expression):
168 if expression.value in ['true', 'false']:
169 return CConstantExpression(value=expression.value)
172 symbol_list_index = accumulators.symbol_list.index(expression.value)
174 symbol_list_index = len(accumulators.symbol_list)
175 accumulators.symbol_list.append(expression.value)
177 return CSymbolExpression(
178 symbol=expression.value,
179 symbol_list_index=symbol_list_index,
182 CInfixDeclaration = collections.namedtuple(
192 INFIX_OPERATOR_TO_DECLARATION = {
193 '+': CInfixDeclaration(name='add', in_type='integer', out_type='integer', operator='+'),
194 '-': CInfixDeclaration(name='subtract', in_type='integer', out_type='integer', operator='-'),
195 '*': CInfixDeclaration(name='multiply', in_type='integer', out_type='integer', operator='*'),
196 '//': CInfixDeclaration(name='integerDivide', in_type='integer', out_type='integer', operator='/'),
197 '%': CInfixDeclaration(name='modularDivide', in_type='integer', out_type='integer', operator='%'),
198 'and': CInfixDeclaration(name='and', in_type='boolean', out_type='boolean', operator='&&'),
199 'or': CInfixDeclaration(name='or', in_type='boolean', out_type='boolean', operator='||'),
200 '==': CInfixDeclaration(name='equals', in_type='integer', out_type='boolean', operator='=='),
201 '!=': CInfixDeclaration(name='notEquals', in_type='integer', out_type='boolean', operator='!='),
202 '<=': CInfixDeclaration(name='lessThanOrEqual', in_type='integer', out_type='boolean', operator='<='),
203 '>=': CInfixDeclaration(name='greaterThanOrEqual', in_type='integer', out_type='boolean', operator='>='),
204 '<': CInfixDeclaration(name='lessThan', in_type='integer', out_type='boolean', operator='<'),
205 '>': CInfixDeclaration(name='greaterThan', in_type='integer', out_type='boolean', operator='>'),
208 def transform_comparison_level_expression(accumulators, expression):
209 accumulators.operator_set.add(INFIX_OPERATOR_TO_DECLARATION[expression.operator])
211 # Transform expressions like 1 < 2 < 3 into expressions like 1 < 2 && 2 < 3
212 if isinstance(expression.left, parsing.FurInfixExpression) and expression.left.order == 'comparison_level':
213 left = transform_comparison_level_expression(
220 right = transform_expression(
225 # TODO Don't evaluate the middle expression twice
226 return CFunctionCallForFurInfixOperator(
229 right=CFunctionCallForFurInfixOperator(
230 name=INFIX_OPERATOR_TO_DECLARATION[expression.operator].name,
236 return CFunctionCallForFurInfixOperator(
237 name=INFIX_OPERATOR_TO_DECLARATION[expression.operator].name,
238 left=transform_expression(accumulators, expression.left),
239 right=transform_expression(accumulators, expression.right),
242 def transform_infix_expression(accumulators, expression):
243 if expression.order == 'comparison_level':
244 return transform_comparison_level_expression(accumulators, expression)
246 accumulators.operator_set.add(INFIX_OPERATOR_TO_DECLARATION[expression.operator])
248 return CFunctionCallForFurInfixOperator(
249 name=INFIX_OPERATOR_TO_DECLARATION[expression.operator].name,
250 left=transform_expression(accumulators, expression.left),
251 right=transform_expression(accumulators, expression.right),
254 def transform_integer_literal_expression(accumulators, expression):
255 return CIntegerLiteral(value=expression.value)
257 def transform_negation_expression(accumulators, expression):
258 return CNegationExpression(
259 value=transform_expression(accumulators, expression.internal_expression),
262 def transform_expression(accumulators, expression):
263 # TODO Clean up handlers for parsing expressions
265 parsing.FurFunctionCallExpression: transform_function_call_expression,
266 parsing.FurInfixExpression: transform_infix_expression,
267 parsing.FurIntegerLiteralExpression: transform_integer_literal_expression,
268 parsing.FurNegationExpression: transform_negation_expression,
269 parsing.FurStringLiteralExpression: transform_string_literal,
270 parsing.FurSymbolExpression: transform_symbol_expression,
271 normalization.NormalFunctionCallExpression: transform_function_call_expression,
272 normalization.NormalInfixExpression: transform_infix_expression,
273 normalization.NormalNegationExpression: transform_negation_expression,
274 normalization.NormalVariableExpression: transform_variable_expression,
275 }[type(expression)](accumulators, expression)
277 def transform_symbol_assignment_statement(accumulators, assignment_statement):
278 # TODO Check that target is not a builtin
280 symbol_list_index = accumulators.symbol_list.index(assignment_statement.target)
282 symbol_list_index = len(accumulators.symbol_list)
283 accumulators.symbol_list.append(assignment_statement.target)
285 return CSymbolAssignmentStatement(
286 target=assignment_statement.target,
287 target_symbol_list_index=symbol_list_index,
288 expression=transform_expression(
290 assignment_statement.expression,
294 def transform_function_call_expression(accumulators, function_call):
295 if isinstance(function_call.function, parsing.FurSymbolExpression):
296 # TODO Move this check to transformation of symbol expressions so we can have builtins that aren't functions
297 if function_call.function.value in BUILTINS.keys():
298 # TODO Check that the builtin is actually callable
299 accumulators.builtin_set.add(function_call.function.value)
301 # TODO Use the symbol from SYMBOL LIST
302 return CFunctionCallExpression(
303 name=transform_expression(accumulators, function_call.function),
304 argument_count=function_call.argument_count,
305 argument_items=transform_expression(accumulators, function_call.argument_items),
308 def transform_expression_statement(accumulators, statement):
309 return CExpressionStatement(
310 expression=transform_expression(accumulators, statement.expression),
313 def transform_if_else_statement(accumulators, statement):
314 return CIfElseStatement(
315 condition_expression=transform_expression(accumulators, statement.condition_expression),
316 if_statements=tuple(transform_statement(accumulators, s) for s in statement.if_statements),
317 else_statements=tuple(transform_statement(accumulators, s) for s in statement.else_statements),
320 def transform_array_variable_initialization_statement(accumulators, statement):
321 return CArrayVariableInitializationStatement(
322 variable=statement.variable,
323 items=tuple(transform_expression(accumulators, i) for i in statement.items),
326 def transform_variable_initialization_statement(accumulators, statement):
327 return CVariableInitializationStatement(
328 variable=statement.variable,
329 expression=transform_expression(accumulators, statement.expression),
332 def transform_variable_reassignment_statement(accumulators, statement):
333 return CVariableReassignmentStatement(
334 variable=statement.variable,
335 expression=transform_expression(accumulators, statement.expression),
338 def transform_function_definition_statement(accumulators, statement):
339 # TODO Allow defining the same function in different contexts
340 if any(fd.name == statement.name for fd in accumulators.function_definition_list):
341 raise Exception('A function with name "{}" already exists'.format(statement.name))
343 # TODO Add argument names to the symbol table
344 accumulators.function_definition_list.append(CFunctionDefinition(
346 argument_name_list=statement.argument_name_list,
347 statement_list=tuple(transform_statement(accumulators, s) for s in statement.statement_list)
350 return CFunctionDeclaration(name=statement.name)
352 def transform_statement(accumulators, statement):
354 parsing.FurExpressionStatement: transform_expression_statement,
355 normalization.NormalArrayVariableInitializationStatement: transform_array_variable_initialization_statement,
356 normalization.NormalAssignmentStatement: transform_symbol_assignment_statement,
357 normalization.NormalExpressionStatement: transform_expression_statement,
358 normalization.NormalFunctionDefinitionStatement: transform_function_definition_statement,
359 normalization.NormalIfElseStatement: transform_if_else_statement,
360 normalization.NormalVariableInitializationStatement: transform_variable_initialization_statement,
361 normalization.NormalVariableReassignmentStatement: transform_variable_reassignment_statement,
362 }[type(statement)](accumulators, statement)
365 Accumulators = collections.namedtuple(
369 'function_definition_list',
372 'string_literal_list',
376 def transform(program):
377 accumulators = Accumulators(
379 function_definition_list=[],
382 string_literal_list=[],
386 transform_statement(accumulators, statement) for statement in program.statement_list
389 standard_library_set = set()
390 for builtin in accumulators.builtin_set:
391 for standard_library in BUILTINS[builtin]:
392 standard_library_set.add(standard_library)
395 builtin_set=accumulators.builtin_set,
396 function_definition_list=accumulators.function_definition_list,
397 operator_declarations=tuple(sorted(accumulators.operator_set)),
398 statements=statement_list,
399 standard_libraries=standard_library_set,
400 string_literal_list=accumulators.string_literal_list,
401 symbol_list=accumulators.symbol_list,
405 if __name__ == '__main__':