],
)
+NormalIntegerLiteralExpression = collections.namedtuple(
+ 'NormalIntegerLiteralExpression',
+ [
+ 'integer',
+ ],
+)
+
+NormalStringLiteralExpression = collections.namedtuple(
+ 'NormalStringLiteralExpression',
+ [
+ 'string',
+ ],
+)
+
+NormalSymbolExpression = collections.namedtuple(
+ 'NormalSymbolExpression',
+ [
+ 'symbol',
+ ],
+)
+
NormalNegationExpression = collections.namedtuple(
'NormalNegationExpression',
[
NormalFunctionCallExpression = collections.namedtuple(
'NormalFunctionCallExpression',
[
- 'function',
+ 'function_expression',
'argument_count',
'argument_items',
],
],
)
-# TODO Get rid of this
def fake_normalization(counter, thing):
return (counter, (), thing)
+def normalize_integer_literal_expression(counter, expression):
+ # TODO Store this in a C variable
+ return (
+ counter,
+ (),
+ NormalIntegerLiteralExpression(integer=expression.integer),
+ )
+
+def normalize_string_literal_expression(counter, expression):
+ # TODO Store this in a C variable
+ return (
+ counter,
+ (),
+ NormalStringLiteralExpression(string=expression.string),
+ )
+
+def normalize_symbol_expression(counter, expression):
+ variable = '${}'.format(counter)
+ return (
+ counter + 1,
+ (NormalVariableInitializationStatement(
+ variable=variable,
+ expression=NormalSymbolExpression(symbol=expression.symbol),
+ ),),
+ NormalVariableExpression(variable=variable),
+ )
+
def normalize_function_call_expression(counter, expression):
assert isinstance(expression, parsing.FurFunctionCallExpression)
items=tuple(arguments),
))
+ counter, function_prestatements, function_expression = normalize_expression(
+ counter,
+ expression.function,
+ )
+
+ for ps in function_prestatements:
+ prestatements.append(ps)
+
+ if not isinstance(function_expression, NormalVariableExpression):
+ function_variable = '${}'.format(counter)
+
+ prestatements.append(NormalVariableInitializationStatement(
+ variable=function_variable,
+ expression=function_expression,
+ ))
+
+ function_expression = NormalVariableExpression(variable=function_variable)
+ counter += 1
+
return (
counter,
tuple(prestatements),
NormalFunctionCallExpression(
- function=expression.function, # TODO Normalize the function
+ function_expression=function_expression,
argument_count=len(arguments),
argument_items=NormalVariableExpression(variable=arguments_variable),
),
counter,
left_prestatements + right_prestatements + root_prestatements,
NormalInfixExpression(
- order=expression.order, # TODO Do we need this?
+ order=expression.order,
operator=expression.operator,
left=NormalVariableExpression(variable=left_variable),
right=NormalVariableExpression(variable=right_variable),
counter, result_prestatements, result_expression = (
counter,
left_prestatements + right_prestatements + root_prestatements,
- # TODO Implement short-circuiting
NormalInfixExpression(
- order=expression.order, # TODO Do we need this?
+ order=expression.order,
operator=expression.operator,
left=NormalVariableExpression(variable=left_variable),
right=NormalVariableExpression(variable=right_variable),
NormalVariableExpression: fake_normalization,
parsing.FurFunctionCallExpression: normalize_function_call_expression,
parsing.FurInfixExpression: normalize_infix_expression,
- parsing.FurIntegerLiteralExpression: fake_normalization,
+ parsing.FurIntegerLiteralExpression: normalize_integer_literal_expression,
parsing.FurNegationExpression: normalize_negation_expression,
- parsing.FurStringLiteralExpression: fake_normalization,
- parsing.FurSymbolExpression: fake_normalization,
+ parsing.FurStringLiteralExpression: normalize_string_literal_expression,
+ parsing.FurSymbolExpression: normalize_symbol_expression,
}[type(expression)](counter, expression)
def normalize_expression_statement(counter, statement):
- # TODO Verify all expression types are supported and just call normalize_expression
- counter, prestatements, normalized = {
- parsing.FurFunctionCallExpression: normalize_function_call_expression,
- parsing.FurSymbolExpression: normalize_expression,
- parsing.FurInfixExpression: normalize_expression,
- parsing.FurIntegerLiteralExpression: normalize_expression,
- }[type(statement.expression)](counter, statement.expression)
+ # TODO Normalized will be a NormalVariableExpression, which will go unused
+ # for expression statements in every case except when it's a return
+ # statement. This cases warnings on C compilation. We should only generate
+ # this variable when it will be used on return.
+ counter, prestatements, normalized = normalize_expression(counter, statement.expression)
return (
counter,
yield normalized
def normalize(program):
-
return NormalProgram(
statement_list=normalize_statement_list(program.statement_list),
)