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',
67 CSymbolAssignmentStatement = collections.namedtuple(
68 'CSymbolAssignmentStatement',
71 'target_symbol_list_index',
76 CVariableInitializationStatement = collections.namedtuple(
77 'CVariableInitializationStatement',
84 CVariableReassignmentStatement = collections.namedtuple(
85 'CVariableReassignmentStatement',
92 CExpressionStatement = collections.namedtuple(
93 'CExpressionStatement',
99 CIfElseStatement = collections.namedtuple(
102 'condition_expression',
108 CProgram = collections.namedtuple(
113 'standard_libraries',
114 'string_literal_list',
119 EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING = {
122 '<=': 'lessThanOrEqual',
123 '>=': 'greaterThanOrEqual',
128 def transform_comparison_level_expression(accumulators, expression):
129 # Transform expressions like 1 < 2 < 3 into expressions like 1 < 2 && 2 < 3
130 if isinstance(expression.left, parsing.FurInfixExpression) and expression.left.order == 'comparison_level':
131 left = transform_comparison_level_expression(
138 right = transform_expression(
143 # TODO Don't evaluate the middle expression twice
144 return CFunctionCallForFurInfixOperator(
147 right=CFunctionCallForFurInfixOperator(
148 name=EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING[expression.operator],
154 return CFunctionCallForFurInfixOperator(
155 name=EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING[expression.operator],
156 left=transform_expression(accumulators, expression.left),
157 right=transform_expression(accumulators, expression.right),
163 'print': ['stdio.h'],
167 def transform_variable_expression(accumulators, expression):
168 return CVariableExpression(variable=expression.variable)
170 def transform_infix_expression(accumulators, expression):
171 if expression.order == 'comparison_level':
172 return transform_comparison_level_expression(accumulators, expression)
174 INFIX_OPERATOR_TO_FUNCTION_NAME = {
178 '//': 'integerDivide',
179 '%': 'modularDivide',
184 return CFunctionCallForFurInfixOperator(
185 name=INFIX_OPERATOR_TO_FUNCTION_NAME[expression.operator],
186 left=transform_expression(accumulators, expression.left),
187 right=transform_expression(accumulators, expression.right),
190 def transform_expression(accumulators, expression):
191 if isinstance(expression, parsing.FurParenthesizedExpression):
192 # Parentheses can be removed because everything in the C output is explicitly parenthesized
193 return transform_expression(accumulators, expression.internal)
195 if isinstance(expression, parsing.FurNegationExpression):
196 return transform_negation_expression(accumulators, expression)
198 if isinstance(expression, parsing.FurFunctionCallExpression):
199 return transform_function_call_expression(accumulators, expression)
201 if isinstance(expression, parsing.FurSymbolExpression):
202 if expression.value in ['true', 'false']:
203 return CConstantExpression(value=expression.value)
205 if expression.value not in accumulators.symbol_list:
206 symbol_list.append(expression.value)
208 return CSymbolExpression(
209 symbol=expression.value,
210 symbol_list_index=accumulators.symbol_list.index(expression.value),
213 if isinstance(expression, parsing.FurStringLiteralExpression):
214 value = expression.value
217 index = accumulators.string_literal_list.index(value)
219 index = len(accumulators.string_literal_list)
220 accumulators.string_literal_list.append(value)
222 return CStringLiteral(index=index, value=value)
224 LITERAL_TYPE_MAPPING = {
225 parsing.FurIntegerLiteralExpression: CIntegerLiteral,
228 if type(expression) in LITERAL_TYPE_MAPPING:
229 return LITERAL_TYPE_MAPPING[type(expression)](value=expression.value)
231 # TODO Handle all possible types in this form
233 parsing.FurInfixExpression: transform_infix_expression, # TODO Shouldn't need this
234 normalization.NormalFunctionCallExpression: transform_function_call_expression,
235 normalization.NormalInfixExpression: transform_infix_expression,
236 normalization.NormalNegationExpression: transform_negation_expression,
237 normalization.NormalVariableExpression: transform_variable_expression,
238 }[type(expression)](accumulators, expression)
240 def transform_symbol_assignment_statement(accumulators, assignment_statement):
241 # TODO Check that target is not a builtin
242 if assignment_statement.target not in accumulators.symbol_list:
243 accumulators.symbol_list.append(assignment_statement.target)
245 return CSymbolAssignmentStatement(
246 target=assignment_statement.target,
247 target_symbol_list_index=accumulators.symbol_list.index(assignment_statement.target),
248 expression=transform_expression(
250 assignment_statement.expression,
254 def transform_negation_expression(accumulators, expression):
255 return CNegationExpression(
256 value=transform_expression(accumulators, expression.internal_expression),
259 def transform_function_call_expression(accumulators, function_call):
260 # TODO Function should be a full expression
261 if function_call.function.value in BUILTINS.keys():
262 # TODO Check that the builtin is actually callable
263 accumulators.builtin_set.add(function_call.function.value)
265 return CFunctionCallExpression(
266 name='builtin$' + function_call.function.value,
268 transform_expression(accumulators, arg)
269 for arg in function_call.arguments
275 def transform_expression_statement(accumulators, statement):
277 parsing.FurFunctionCallExpression: transform_function_call_expression,
278 normalization.NormalFunctionCallExpression: transform_function_call_expression,
279 }[type(statement.expression)](accumulators, statement.expression)
281 return CExpressionStatement(
282 expression=expression,
285 def transform_if_else_statement(accumulators, statement):
286 return CIfElseStatement(
287 condition_expression=transform_expression(accumulators, statement.condition_expression),
288 if_statements=tuple(transform_statement(accumulators, s) for s in statement.if_statements),
289 else_statements=tuple(transform_statement(accumulators, s) for s in statement.else_statements),
292 def transform_variable_initialization_statement(accumulators, statement):
293 return CVariableInitializationStatement(
294 variable=statement.variable,
295 expression=transform_expression(accumulators, statement.expression),
298 def transform_variable_reassignment_statement(accumulators, statement):
299 return CVariableReassignmentStatement(
300 variable=statement.variable,
301 expression=transform_expression(accumulators, statement.expression),
304 def transform_statement(accumulators, statement):
306 parsing.FurAssignmentStatement: transform_symbol_assignment_statement,
307 parsing.FurExpressionStatement: transform_expression_statement,
308 normalization.NormalExpressionStatement: transform_expression_statement,
309 normalization.NormalIfElseStatement: transform_if_else_statement,
310 normalization.NormalVariableInitializationStatement: transform_variable_initialization_statement,
311 normalization.NormalVariableReassignmentStatement: transform_variable_reassignment_statement,
312 }[type(statement)](accumulators, statement)
315 Accumulators = collections.namedtuple(
320 'string_literal_list',
324 def transform(program):
325 accumulators = Accumulators(
328 string_literal_list=[],
332 transform_statement(accumulators, statement) for statement in program.statement_list
335 standard_library_set = set()
336 for builtin in accumulators.builtin_set:
337 for standard_library in BUILTINS[builtin]:
338 standard_library_set.add(standard_library)
341 builtin_set=accumulators.builtin_set,
342 statements=statement_list,
343 standard_libraries=standard_library_set,
344 string_literal_list=accumulators.string_literal_list,
345 symbol_list=accumulators.symbol_list,
349 if __name__ == '__main__':