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 CVariableAssignmentStatement = collections.namedtuple(
77 'CVariableAssignmentStatement',
84 CExpressionStatement = collections.namedtuple(
85 'CExpressionStatement',
91 CProgram = collections.namedtuple(
97 'string_literal_list',
102 EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING = {
105 '<=': 'lessThanOrEqual',
106 '>=': 'greaterThanOrEqual',
111 def transform_equality_level_expression(accumulators, expression):
112 # Transform expressions like 1 < 2 < 3 into expressions like 1 < 2 && 2 < 3
113 if isinstance(expression.left, parsing.FurInfixExpression) and expression.left.order == 'equality_level':
114 left = transform_equality_level_expression(
121 right = transform_expression(
126 # TODO Don't evaluate the middle expression twice
127 return CFunctionCallForFurInfixOperator(
130 right=CFunctionCallForFurInfixOperator(
131 name=EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING[expression.operator],
137 return CFunctionCallForFurInfixOperator(
138 name=EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING[expression.operator],
139 left=transform_expression(accumulators, expression.left),
140 right=transform_expression(accumulators, expression.right),
146 'print': ['stdio.h'],
150 def transform_variable_expression(accumulators, expression):
151 return CVariableExpression(variable=expression.variable)
153 def transform_infix_expression(accumulators, expression):
154 if expression.order == 'equality_level':
155 return transform_equality_level_expression(accumulators, expression)
157 INFIX_OPERATOR_TO_FUNCTION_NAME = {
161 '//': 'integerDivide',
162 '%': 'modularDivide',
167 return CFunctionCallForFurInfixOperator(
168 name=INFIX_OPERATOR_TO_FUNCTION_NAME[expression.operator],
169 left=transform_expression(accumulators, expression.left),
170 right=transform_expression(accumulators, expression.right),
173 def transform_expression(accumulators, expression):
174 if isinstance(expression, parsing.FurParenthesizedExpression):
175 # Parentheses can be removed because everything in the C output is explicitly parenthesized
176 return transform_expression(accumulators, expression.internal)
178 if isinstance(expression, parsing.FurNegationExpression):
179 return transform_negation_expression(accumulators, expression)
181 if isinstance(expression, parsing.FurFunctionCallExpression):
182 return transform_function_call_expression(accumulators, expression)
184 if isinstance(expression, parsing.FurSymbolExpression):
185 if expression.value in ['true', 'false']:
186 return CConstantExpression(value=expression.value)
188 if expression.value not in accumulators.symbol_list:
189 symbol_list.append(expression.value)
191 return CSymbolExpression(
192 symbol=expression.value,
193 symbol_list_index=accumulators.symbol_list.index(expression.value),
196 if isinstance(expression, parsing.FurStringLiteralExpression):
197 value = expression.value
200 index = accumulators.string_literal_list.index(value)
202 index = len(accumulators.string_literal_list)
203 accumulators.string_literal_list.append(value)
205 return CStringLiteral(index=index, value=value)
207 LITERAL_TYPE_MAPPING = {
208 parsing.FurIntegerLiteralExpression: CIntegerLiteral,
211 if type(expression) in LITERAL_TYPE_MAPPING:
212 return LITERAL_TYPE_MAPPING[type(expression)](value=expression.value)
214 # TODO Handle all possible types in this form
216 parsing.FurInfixExpression: transform_infix_expression, # TODO Shouldn't need this
217 normalization.NormalFunctionCallExpression: transform_function_call_expression,
218 normalization.NormalInfixExpression: transform_infix_expression,
219 normalization.NormalVariableExpression: transform_variable_expression,
220 }[type(expression)](accumulators, expression)
222 def transform_symbol_assignment_statement(accumulators, assignment_statement):
223 # TODO Check that target is not a builtin
224 if assignment_statement.target not in accumulators.symbol_list:
225 accumulators.symbol_list.append(assignment_statement.target)
227 return CSymbolAssignmentStatement(
228 target=assignment_statement.target,
229 target_symbol_list_index=accumulators.symbol_list.index(assignment_statement.target),
230 expression=transform_expression(
232 assignment_statement.expression,
236 def transform_negation_expression(accumulators, negation_expression):
237 return CNegationExpression(
238 value=transform_expression(accumulators, negation_expression.value),
241 def transform_function_call_expression(accumulators, function_call):
242 # TODO Function should be a full expression
243 if function_call.function.value in BUILTINS.keys():
244 # TODO Check that the builtin is actually callable
245 accumulators.builtin_set.add(function_call.function.value)
247 return CFunctionCallExpression(
248 name='builtin$' + function_call.function.value,
250 transform_expression(accumulators, arg)
251 for arg in function_call.arguments
257 def transform_expression_statement(accumulators, statement):
259 parsing.FurFunctionCallExpression: transform_function_call_expression,
260 normalization.NormalFunctionCallExpression: transform_function_call_expression,
261 }[type(statement.expression)](accumulators, statement.expression)
263 return CExpressionStatement(
264 expression=expression,
267 def transform_variable_assignment_statement(accumulators, statement):
268 return CVariableAssignmentStatement(
269 variable=statement.variable,
270 expression=transform_expression(accumulators, statement.expression),
273 def transform_statement(accumulators, statement):
275 parsing.FurAssignmentStatement: transform_symbol_assignment_statement,
276 parsing.FurExpressionStatement: transform_expression_statement,
277 normalization.NormalVariableAssignmentStatement: transform_variable_assignment_statement,
278 normalization.NormalExpressionStatement: transform_expression_statement,
279 }[type(statement)](accumulators, statement)
282 Accumulators = collections.namedtuple(
287 'string_literal_list',
291 def transform(program):
292 accumulators = Accumulators(
295 string_literal_list=[],
299 transform_statement(accumulators, statement) for statement in program.statement_list
302 standard_library_set = set()
303 for builtin in accumulators.builtin_set:
304 for standard_library in BUILTINS[builtin]:
305 standard_library_set.add(standard_library)
308 builtin_set=accumulators.builtin_set,
309 statements=statement_list,
310 standard_libraries=standard_library_set,
311 string_literal_list=accumulators.string_literal_list,
312 symbol_list=accumulators.symbol_list,
316 if __name__ == '__main__':