],
)
-NormalVariableReassignmentStatement = collections.namedtuple(
- 'NormalVariableReassignmentStatement',
- [
- 'variable',
- 'expression',
- ],
-)
-
NormalExpressionStatement = collections.namedtuple(
'NormalExpressionStatement',
[
],
)
-NormalIfElseStatement = collections.namedtuple(
- 'NormalIfElseStatement',
+NormalIfElseExpression = collections.namedtuple(
+ 'NormalIfElseExpression',
[
'condition_expression',
'if_statement_list',
)
def normalize_integer_literal_expression(counter, expression):
- variable = '${}'.format(counter)
return (
- counter + 1,
- (
- NormalVariableInitializationStatement(
- variable=variable,
- expression=NormalIntegerLiteralExpression(integer=expression.integer),
- ),
- ),
- NormalVariableExpression(variable=variable),
+ counter,
+ (),
+ NormalIntegerLiteralExpression(integer=expression.integer),
)
def normalize_lambda_expression(counter, expression):
_, statement_list = normalize_statement_list(
0,
expression.statement_list,
- assign_result_to='result',
)
return (
)
def normalize_string_literal_expression(counter, expression):
- variable = '${}'.format(counter)
return (
- counter + 1,
- (
- NormalVariableInitializationStatement(
- variable=variable,
- expression=NormalStringLiteralExpression(string=expression.string),
- ),
- ),
- NormalVariableExpression(variable=variable),
+ counter,
+ (),
+ NormalStringLiteralExpression(string=expression.string),
)
NormalStructureLiteralExpression = collections.namedtuple(
def normalize_symbol_expression(counter, expression):
- variable = '${}'.format(counter)
return (
- counter + 1,
- (
- NormalVariableInitializationStatement(
- variable=variable,
- expression=NormalSymbolExpression(symbol=expression.symbol),
- ),
- ),
- NormalVariableExpression(variable=variable),
+ counter,
+ (),
+ NormalSymbolExpression(symbol=expression.symbol),
)
def normalize_function_call_expression(counter, expression):
for s in argument_prestatements:
prestatements.append(s)
- variable = '${}'.format(counter)
- prestatements.append(
- NormalVariableInitializationStatement(
- variable=variable,
- expression=normalized_argument,
- )
- )
prestatements.append(
NormalPushStatement(
- expression=NormalVariableExpression(
- variable=variable,
- ),
+ expression=normalized_argument,
),
)
- counter += 1
counter, function_prestatements, function_expression = normalize_expression(
counter,
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
-
result_variable = '${}'.format(counter)
prestatements.append(
expression.condition_expression,
)
- result_variable = '${}'.format(counter)
- counter += 1
-
counter, if_statement_list = normalize_statement_list(
counter,
expression.if_statement_list,
- assign_result_to=result_variable,
)
counter, else_statement_list = normalize_statement_list(
counter,
expression.else_statement_list,
- assign_result_to=result_variable,
)
return (
counter,
- condition_prestatements + (
- NormalVariableInitializationStatement(
- variable=result_variable,
- expression=NormalVariableExpression(variable='builtin$nil'),
- ),
- NormalIfElseStatement(
- condition_expression=condition_expression,
- if_statement_list=if_statement_list,
- else_statement_list=else_statement_list,
- ),
+ condition_prestatements,
+ NormalIfElseExpression(
+ condition_expression=condition_expression,
+ if_statement_list=if_statement_list,
+ else_statement_list=else_statement_list,
),
- NormalVariableExpression(variable=result_variable),
)
def normalize_expression(counter, expression):
}[type(statement)](counter, statement)
@util.force_generator(tuple)
-def normalize_statement_list(counter, statement_list, **kwargs):
- assign_result_to = kwargs.pop('assign_result_to', None)
-
- assert len(kwargs) == 0
-
+def normalize_statement_list(counter, statement_list):
result_statement_list = []
for statement in statement_list:
result_statement_list.append(s)
result_statement_list.append(normalized)
- # TODO The way we fix the last statement is really confusing
- last_statement = result_statement_list[-1]
-
- if isinstance(last_statement, NormalExpressionStatement) and isinstance(last_statement.expression, NormalVariableExpression):
- if assign_result_to is not None:
- result_expression = result_statement_list.pop().expression
- result_statement_list.append(
- NormalVariableReassignmentStatement(
- variable=assign_result_to,
- expression=result_expression,
- )
- )
-
return (
counter,
result_statement_list,