def math_operations_working():
"""Проверка работы математических операций"""
setting.initialisation("program.yovc")
number_1 = 97
number_2 = -65
num_1 = append.data_segment("number", number_1)
num_2 = append.data_segment("number", number_2)
print(f"Negative: - {number_1}")
math.Negative(["link", num_1])
draw.memory_stack_link()
print(f"Add: {number_1} + {number_2}")
math.Add(["link", num_1], ["link", num_2])
draw.memory_stack_link()
print(f"Increment: {number_1}++")
math.Increment(["link", num_1])
draw.memory_stack_link()
print(f"Decrement: {number_1}--")
math.Decrement(["link", num_1])
draw.memory_stack_link()
print(f"Subtract: {number_1} - {number_2}")
math.Subtract(["link", num_1], ["link", num_2])
draw.memory_stack_link()
print(f"Multiply: {number_1} * {number_2}")
math.Multiply(["link", num_1], ["link", num_2])
draw.memory_stack_link()
print(f"Divide: {number_1} / {number_2}")
math.Divide(["link", num_1], ["link", num_2])
draw.memory_stack_link()
print(f"Modulo: {number_1} % {number_2}")
math.Modulo(["link", num_1], ["link", num_2])
draw.memory_stack_link()
def comparison_operations_working():
"""Проверка работы операций сравнения"""
setting.initialisation("program.yovc")
value_1 = 53
value_2 = 4
num_1 = append.data_segment("number", value_1)
num_2 = append.data_segment("number", value_2)
print(f"Equal: {value_1} == {value_2}")
comparison.Equal(["link", num_1], ["link", num_2])
draw.memory_stack_link()
print(f"Great: {value_1} > {value_2}")
comparison.Great(["link", num_1], ["link", num_2])
draw.memory_stack_link()
print(f"Less: {value_1} < {value_2}")
comparison.Less(["link", num_1], ["link", num_2])
draw.memory_stack_link()
def Create(arg):
arg_type, arg_value = arg
if arg_type == "none":
res_num = append.data_segment(arg_type, arg_value)
elif arg_type == "logic":
res_num = append.data_segment(arg_type, arg_value)
elif arg_type == "number":
res_num = append.data_segment(arg_type, arg_value)
elif arg_type == "chars":
res_num = make.string_segment(arg_value)
elif arg_type == "array":
res_num = make.list_segment(arg_value)
else:
raise UndefinedArgument(f"Создание объекта командой Crt типа "
f"{arg_type} не определено")
append.memory_stack("link", res_num)
def subobject_operation_working():
"""Проверка работы операции нахождения элемента по индексу"""
real_string_segment_size = minimal_data_length["string_segment"]
minimal_data_length["string_segment"] = 4
real_list_segment_size = minimal_data_length["list_segment"]
minimal_data_length["list_segment"] = 4
setting.initialisation("program.yovc")
str_num = add.string_segment()
put.string_segment(str_num, "char_list",
"Эта строка не влезет в маленький сегмент")
list_num = add.list_segment()
put.list_segment(list_num, "link_list", [i for i in range(40)])
view.tape()
print(get.string_segment(str_num))
view.string_segment(str_num)
print(get.list_segment(list_num))
view.list_segment(list_num)
index = append.data_segment("number", 25)
objects.Sub_object(["link", str_num], ["link", index])
kind, element_link = pull.memory_stack()
display.entity(element_link)
objects.Sub_object(["link", list_num], ["link", index])
kind, element_link = pull.memory_stack()
display.entity(element_link)
minimal_data_length["string_segment"] = real_string_segment_size
minimal_data_length["list_segment"] = real_list_segment_size
def memory_stack_operations_working():
"""Проверка работы операций стека памяти"""
setting.initialisation("program.yovc")
value = 248
stack.Push(["number", value])
display.entity(438)
stack.Pop(["link", 438])
display.entity(438)
print()
number_1 = 97
number_2 = -65
num_1 = append.data_segment("number", number_1)
num_2 = append.data_segment("number", number_2)
math.Add(["link", num_1], ["link", num_2])
display.entity(440)
stack.Pop(["link", 440])
display.entity(440)
def Not(arg):
arg_type, obj_type, value = link.unpack(arg)
if obj_type == "logic":
value = not value
num = append.data_segment("logic", value)
append.memory_stack("link", num)
else:
raise UndefinedBehaviour(f"Для типа {obj_type} не определена операция "
f"логического НЕ Not")
def negative_command_working():
"""Проверка работы команды Negative"""
setting.initialisation("program.yovc")
number = -255
print("number", number)
num = append.data_segment("number", number)
math.Negative(num)
kind, number = link.memory_stack_get()
print(kind, number)
def Negative(arg):
arg_type, obj_type, value = link.unpack(arg)
if obj_type == "number":
value = -value
num = append.data_segment("number", value)
append.memory_stack("link", num)
else:
raise UndefinedBehaviour(f"Для типа {obj_type} не определена операция "
f"инверсии Neg")
def Increment(arg):
arg_type, obj_type, value = link.unpack(arg)
if obj_type == "number":
value += 1
num = append.data_segment("number", value)
append.memory_stack("link", num)
else:
raise UndefinedBehaviour(f"Для типа {obj_type} не определена операция "
f"инкремента Inc")
def jumps_operations_working():
"""Проверка работы операций переходов"""
setting.initialisation("program.yovc")
show.attribute(seg_links["system"], "target_cell")
jumps.Jump(["link", 12])
print("Jump:")
show.attribute(seg_links["system"], "target_cell")
true_num = append.data_segment("logic", True)
false_num = append.data_segment("logic", False)
print("Jump_if true:")
jumps.Jump_if(["link", 16], ["link", true_num])
show.attribute(seg_links["system"], "target_cell")
print("Jump_if false:")
jumps.Jump_if(["link", 25], ["link", false_num])
show.attribute(seg_links["system"], "target_cell")
print("End:")
jumps.End()
show.attribute(seg_links["system"], "target_cell")
def Multiply(left, right):
left_arg_type, left_type, left_value = link.unpack(left)
right_arg_type, right_type, right_value = link.unpack(right)
if left_type == "number" and right_type == "number":
value = left_value * right_value
num = append.data_segment("number", value)
append.memory_stack("link", num)
else:
raise UndefinedBehaviour(f"Для типов {left_type} и {right_type} "
f"операция умножения Mul не определена")
def Subtract(left, right):
left_arg_type, left_type, left_value = link.unpack(left)
right_arg_type, right_type, right_value = link.unpack(right)
if left_type == "number" and right_type == "number":
value = left_value - right_value
num = append.data_segment("number", value)
append.memory_stack("link", num)
else:
raise UndefinedBehaviour(f"Для типов {left_type} и {right_type} "
f"операция вычитания Sub не определена")
def Equal(left, right):
left_arg_type, left_type, left_value = link.unpack(left)
right_arg_type, right_type, right_value = link.unpack(right)
if left_type == "number" and right_type == "number":
value = left_value == right_value
num = append.data_segment("logic", value)
append.memory_stack("link", num)
else:
raise UndefinedBehaviour(f"Для типов {left_type} и {right_type} "
f"операция сравнения Eql не определена")
def logic_operations_working():
"""Проверка работы логических операций"""
setting.initialisation("program.yovc")
value_1 = True
value_2 = False
num_1 = append.data_segment("logic", value_1)
num_2 = append.data_segment("logic", value_2)
print(f"Not: not {value_1}")
logic.Not(["link", num_1])
draw.memory_stack_link()
print(f"And: {value_1} and {value_2}")
logic.And(["link", num_1], ["link", num_2])
draw.memory_stack_link()
print(f"Or: {value_1} or {value_2}")
logic.Or(["link", num_1], ["link", num_2])
draw.memory_stack_link()
print(f"Xor: {value_1} xor {value_2}")
logic.Xor(["link", num_1], ["link", num_2])
draw.memory_stack_link()
def Push(arg):
arg_type, arg_value = arg
if arg_type == "none":
append.memory_stack("link", 0)
elif arg_type == "number":
num = append.data_segment("number", arg_value)
append.memory_stack("link", num)
else:
raise UndefinedArgument(f"Поведение команды Psh с аргументом типа "
f"{arg_type} не определено")
def Xor(left, right):
left_arg_type, left_type, left_value = link.unpack(left)
right_arg_type, right_type, right_value = link.unpack(right)
if left_type == "logic" and right_type == "logic":
value = left_value + right_value == 1
num = append.data_segment("logic", value)
append.memory_stack("link", num)
else:
raise UndefinedBehaviour(f"Для типов {left_type} и {right_type} "
f"операция логического ЛИБО XOR не определена")
def entity(obj_type, value):
if obj_type == "string_segment":
num = string_segment(value)
elif obj_type == "list_segment":
num = list_segment(value)
elif obj_type in types:
num = append.data_segment(obj_type, value)
else:
raise LowerCommandError(f"Неподдерживаемый тип для сегментной записи"
f" {obj_type}")
return num
def Divide(left, right):
left_arg_type, left_type, left_value = link.unpack(left)
right_arg_type, right_type, right_value = link.unpack(right)
if left_type == "number" and right_type == "number":
if right_value == 0:
raise UndefinedBehaviour("Результат деления на ноль не определён")
value = int(left_value / right_value)
num = append.data_segment("number", value)
append.memory_stack("link", num)
else:
raise UndefinedBehaviour(f"Для типов {left_type} и {right_type} "
f"операция деления Div не определена")
def write_namespace_name(num, key, value=None):
key_type, key_value = key
key_num = make.entity(key_type, key_value)
if value is not None:
value_type, value_value = value
value_num = make.entity(value_type, value_value)
else:
value_num = make.entity("none", 0)
item_num = append.data_segment("dictionary_item",
[num, key_num, value_num])
put.namespace(num, "link_list", [item_num])
return item_num + 6
def Modulo(left, right):
left_arg_type, left_type, left_value = link.unpack(left)
right_arg_type, right_type, right_value = link.unpack(right)
if left_type == "number" and right_type == "number":
if right_value == 0:
raise UndefinedBehaviour("Результат остатка деления на ноль не "
"определён")
value = left_value % right_value
num = append.data_segment("number", value)
append.memory_stack("link", num)
else:
raise UndefinedBehaviour(
f"Для типов {left_type} и {right_type} операция остаток от деления "
f"Mod не определена")
def Length(arg):
arg_type, arg_value = arg
if arg_type == "link":
kind = find.kind(arg_value)
if kind == "link":
kind, arg_value = get.entity(arg_value)
kind = find.kind(arg_value)
if kind == "string_segment":
length = get.string_segment_length(arg_value)
elif kind == "list_segment":
length = get.list_segment_length(arg_value)
else:
raise UndefinedBehaviour(f"Получение длины командой Len для "
f"типа {kind} не определено")
num = append.data_segment("number", length)
append.memory_stack("link", num)
else:
raise UndefinedArgument(f"Поведение команды Len с аргументом типа "
f"{arg_type} не определено")
def Sub_object(parent, index):
par_type, par_value = parent
ind_arg_type, ind_type, ind_value = link.unpack(index)
if ind_type == "link":
ind_type, ind_value = link.get_link(ind_value)
if ind_type != "number":
raise UndefinedBehaviour(f"Получение элемента командой Sob с индексом"
f"типа {ind_type} не определено")
if ind_value < 0:
raise UndefinedBehaviour(f"Получение элемента командой Sob с "
f"отрицательным индексом не определено")
if ind_value == 0:
raise UndefinedBehaviour(f"Получение элемента командой Sob с "
f"нулевым индексом не определено")
if par_type == "link":
kind, link_value = read.entity(par_value)
if kind == "link":
kind = find.kind(link_value)
par_value = link_value
if kind == "string_segment":
elem_type, elem_value = get.string_segment_element(
par_value, ind_value)
elif kind == "list_segment":
elem_type, elem_value = get.list_segment_element(
par_value, ind_value)
else:
raise UndefinedBehaviour(f"Получение элемента командой Sob для "
f"типа {kind} не определено")
if elem_type == "none":
num = append.data_segment("none", 0)
append.memory_stack("link", num)
elif elem_type == "link":
append.memory_stack("link", elem_value)
else:
raise LowerCommandError(f"Поиск элемента не может возращать объект"
f"типа {elem_type}")
else:
raise UndefinedArgument(f"Поведение команды Sob с аргументом типа"
f"{par_type} не определено")
