def if_expression(
test: TranslatedExpression,
then: TranslatedExpression,
else_do: Optional[TranslatedExpression],
) -> TranslatedExpression:
test_condition = convert_to_condition(test)
then_expression = convert_to_expression(then)
else_expression = (convert_to_expression(else_do)
if else_do is not None else Constant(0))
true_label = TempManager.new_label()
false_label = TempManager.new_label()
join_label = TempManager.new_label()
result = TempManager.new_temp()
patch_true_labels(test_condition.trues, true_label)
patch_false_labels(test_condition.trues, false_label)
sequence = Sequence([
test_condition.statement,
Label(true_label),
Move(Temporary(result), then_expression),
Jump(Name(join_label), [join_label]),
Label(false_label),
Move(Temporary(result), else_expression),
Label(join_label),
])
return Expression(EvaluateSequence(sequence, Temporary(result)))
def sequence_expression(
sequence: List[TranslatedExpression]) -> TranslatedExpression:
result = convert_to_expression(sequence[0])
for line in sequence[1:]:
result = EvaluateSequence(StatementExpression(result),
convert_to_expression(line))
return Expression(result)
def record_expression(
field_list: List[TranslatedExpression]) -> TranslatedExpression:
result = TempManager.new_temp()
creation_sequence = [
Move(
Temporary(result),
frame.external_call("init_record",
[Constant(len(field_list) * frame.word_size)]),
)
]
for index, field_expression in enumerate(field_list):
field_allocation = Move(
Memory(
BinaryOperation(
BinaryOperator.plus,
Temporary(result),
Constant(index * frame.word_size),
)),
convert_to_expression(field_expression),
)
creation_sequence.append(field_allocation)
return Expression(
EvaluateSequence(Sequence(creation_sequence), Temporary(result)))
def simple_variable(access: Access, level: Level) -> TranslatedExpression:
result = Temporary(frame.frame_pointer())
current_level = level
while current_level is not access.level:
static_link_access = current_level.formals()[0]
result = frame.access_to_exp(static_link_access.access, result)
current_level = current_level.parent
return Expression(frame.access_to_exp(access.access, result))
def let_expression(
declaration_list: List[TranslatedExpression],
body_expression: TranslatedExpression) -> TranslatedExpression:
declaration_sequence = [
convert_to_statement(declaration) for declaration in declaration_list
]
return Expression(
EvaluateSequence(Sequence(declaration_sequence),
convert_to_expression(body_expression)))
def arithmetic_operation_expression(
operator: ast.Oper, left: TranslatedExpression,
right: TranslatedExpression) -> TranslatedExpression:
return Expression(
BinaryOperation(
convert_arithmetic_operator(operator),
convert_to_expression(left),
convert_to_expression(right),
))
def array_expression(
size: TranslatedExpression,
initial_value: TranslatedExpression) -> TranslatedExpression:
return Expression(
frame.external_call(
"init_array",
[
convert_to_expression(size),
convert_to_expression(initial_value)
],
))
def field_variable(variable: TranslatedExpression,
field_index: int) -> TranslatedExpression:
return Expression(
Memory(
BinaryOperation(
BinaryOperator.plus,
convert_to_expression(variable),
BinaryOperation(
BinaryOperator.mul,
Constant(field_index),
Constant(frame.word_size),
),
)))
def subscript_variable(
variable: TranslatedExpression,
subscript: TranslatedExpression) -> TranslatedExpression:
return Expression(
Memory(
BinaryOperation(
BinaryOperator.plus,
convert_to_expression(variable),
BinaryOperation(
BinaryOperator.mul,
convert_to_expression(subscript),
Constant(frame.word_size),
),
)))
def call_expression(
function_label: TempLabel,
function_level: RealLevel,
caller_level: RealLevel,
argument_list: List[TranslatedExpression],
) -> TranslatedExpression:
argument_expressions = [
convert_to_expression(argument) for argument in argument_list
]
if function_label in BaseEnvironmentManager.standard_library_functions:
return Expression(
frame.external_call(function_label, argument_expressions))
static_link_expression = Temporary(frame.frame_pointer())
current_level = caller_level
while current_level is not function_level.parent:
current_static_link = current_level.formals()[0]
static_link_expression = frame.access_to_exp(
current_static_link.access, static_link_expression)
current_level = current_level.parent
return Expression(
Call(Name(function_label),
[static_link_expression] + argument_expressions))
def string_expression(string: str) -> TranslatedExpression:
string_label = TempManager.new_label()
FragmentManager.add_fragment(StringFragment(string_label, string))
return Expression(Name(string_label))
def integer_expression(integer: int) -> TranslatedExpression:
return Expression(Constant(integer))
def nil_expression() -> TranslatedExpression:
return Expression(Constant(0))