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 CProgram = collections.namedtuple(
122 'standard_libraries',
123 'string_literal_list',
128 EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING = {
131 '<=': 'lessThanOrEqual',
132 '>=': 'greaterThanOrEqual',
137 def transform_comparison_level_expression(accumulators, expression):
138 # Transform expressions like 1 < 2 < 3 into expressions like 1 < 2 && 2 < 3
139 if isinstance(expression.left, parsing.FurInfixExpression) and expression.left.order == 'comparison_level':
140 left = transform_comparison_level_expression(
147 right = transform_expression(
152 # TODO Don't evaluate the middle expression twice
153 return CFunctionCallForFurInfixOperator(
156 right=CFunctionCallForFurInfixOperator(
157 name=EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING[expression.operator],
163 return CFunctionCallForFurInfixOperator(
164 name=EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING[expression.operator],
165 left=transform_expression(accumulators, expression.left),
166 right=transform_expression(accumulators, expression.right),
172 'print': ['stdio.h'],
176 def transform_variable_expression(accumulators, expression):
177 return CVariableExpression(variable=expression.variable)
179 def transform_infix_expression(accumulators, expression):
180 if expression.order == 'comparison_level':
181 return transform_comparison_level_expression(accumulators, expression)
183 INFIX_OPERATOR_TO_FUNCTION_NAME = {
187 '//': 'integerDivide',
188 '%': 'modularDivide',
193 return CFunctionCallForFurInfixOperator(
194 name=INFIX_OPERATOR_TO_FUNCTION_NAME[expression.operator],
195 left=transform_expression(accumulators, expression.left),
196 right=transform_expression(accumulators, expression.right),
199 def transform_expression(accumulators, expression):
200 if isinstance(expression, parsing.FurParenthesizedExpression):
201 # Parentheses can be removed because everything in the C output is explicitly parenthesized
202 return transform_expression(accumulators, expression.internal)
204 if isinstance(expression, parsing.FurNegationExpression):
205 return transform_negation_expression(accumulators, expression)
207 if isinstance(expression, parsing.FurFunctionCallExpression):
208 return transform_function_call_expression(accumulators, expression)
210 if isinstance(expression, parsing.FurSymbolExpression):
211 if expression.value in ['true', 'false']:
212 return CConstantExpression(value=expression.value)
214 if expression.value not in accumulators.symbol_list:
215 symbol_list.append(expression.value)
217 return CSymbolExpression(
218 symbol=expression.value,
219 symbol_list_index=accumulators.symbol_list.index(expression.value),
222 if isinstance(expression, parsing.FurStringLiteralExpression):
223 value = expression.value
226 index = accumulators.string_literal_list.index(value)
228 index = len(accumulators.string_literal_list)
229 accumulators.string_literal_list.append(value)
231 return CStringLiteral(index=index, value=value)
233 LITERAL_TYPE_MAPPING = {
234 parsing.FurIntegerLiteralExpression: CIntegerLiteral,
237 if type(expression) in LITERAL_TYPE_MAPPING:
238 return LITERAL_TYPE_MAPPING[type(expression)](value=expression.value)
240 # TODO Handle all possible types in this form
242 parsing.FurInfixExpression: transform_infix_expression, # TODO Shouldn't need this
243 normalization.NormalFunctionCallExpression: transform_function_call_expression,
244 normalization.NormalInfixExpression: transform_infix_expression,
245 normalization.NormalNegationExpression: transform_negation_expression,
246 normalization.NormalVariableExpression: transform_variable_expression,
247 }[type(expression)](accumulators, expression)
249 def transform_symbol_assignment_statement(accumulators, assignment_statement):
250 # TODO Check that target is not a builtin
251 if assignment_statement.target not in accumulators.symbol_list:
252 accumulators.symbol_list.append(assignment_statement.target)
254 return CSymbolAssignmentStatement(
255 target=assignment_statement.target,
256 target_symbol_list_index=accumulators.symbol_list.index(assignment_statement.target),
257 expression=transform_expression(
259 assignment_statement.expression,
263 def transform_negation_expression(accumulators, expression):
264 return CNegationExpression(
265 value=transform_expression(accumulators, expression.internal_expression),
268 def transform_function_call_expression(accumulators, function_call):
269 if function_call.function.value in BUILTINS.keys():
270 # TODO Check that the builtin is actually callable
271 accumulators.builtin_set.add(function_call.function.value)
273 # TODO Use the symbol from SYMBOL LIST
274 return CFunctionCallExpression(
275 name=function_call.function.value,
276 argument_count=function_call.argument_count,
277 argument_items=transform_expression(accumulators, function_call.argument_items),
282 def transform_expression_statement(accumulators, statement):
284 parsing.FurFunctionCallExpression: transform_function_call_expression,
285 normalization.NormalFunctionCallExpression: transform_function_call_expression,
286 }[type(statement.expression)](accumulators, statement.expression)
288 return CExpressionStatement(
289 expression=expression,
292 def transform_if_else_statement(accumulators, statement):
293 return CIfElseStatement(
294 condition_expression=transform_expression(accumulators, statement.condition_expression),
295 if_statements=tuple(transform_statement(accumulators, s) for s in statement.if_statements),
296 else_statements=tuple(transform_statement(accumulators, s) for s in statement.else_statements),
299 def transform_array_variable_initialization_statement(accumulators, statement):
300 return CArrayVariableInitializationStatement(
301 variable=statement.variable,
302 items=tuple(transform_expression(accumulators, i) for i in statement.items),
305 def transform_variable_initialization_statement(accumulators, statement):
306 return CVariableInitializationStatement(
307 variable=statement.variable,
308 expression=transform_expression(accumulators, statement.expression),
311 def transform_variable_reassignment_statement(accumulators, statement):
312 return CVariableReassignmentStatement(
313 variable=statement.variable,
314 expression=transform_expression(accumulators, statement.expression),
317 def transform_statement(accumulators, statement):
319 parsing.FurAssignmentStatement: transform_symbol_assignment_statement,
320 parsing.FurExpressionStatement: transform_expression_statement,
321 normalization.NormalExpressionStatement: transform_expression_statement,
322 normalization.NormalIfElseStatement: transform_if_else_statement,
323 normalization.NormalArrayVariableInitializationStatement: transform_array_variable_initialization_statement,
324 normalization.NormalVariableInitializationStatement: transform_variable_initialization_statement,
325 normalization.NormalVariableReassignmentStatement: transform_variable_reassignment_statement,
326 }[type(statement)](accumulators, statement)
329 Accumulators = collections.namedtuple(
334 'string_literal_list',
338 def transform(program):
339 accumulators = Accumulators(
342 string_literal_list=[],
346 transform_statement(accumulators, statement) for statement in program.statement_list
349 standard_library_set = set()
350 for builtin in accumulators.builtin_set:
351 for standard_library in BUILTINS[builtin]:
352 standard_library_set.add(standard_library)
355 builtin_set=accumulators.builtin_set,
356 statements=statement_list,
357 standard_libraries=standard_library_set,
358 string_literal_list=accumulators.string_literal_list,
359 symbol_list=accumulators.symbol_list,
363 if __name__ == '__main__':