def data_segment():
seg_num = find.attribute(seg_links["system"], "first_data_segment")
number = 1
while seg_num != 0:
print(f"Segment #{number}:")
show.segment_body(seg_num)
next_num = find.attribute(seg_num, "next_segment")
seg_num = next_num
number += 1
def tape():
segment = 0
while segment < len(memory):
seg_type = find.attribute(segment, "type")
seg_end = find.attribute(segment, "segment_end")
if seg_end == 0:
break
print(f"{segment} - {seg_end - 1}\t{seg_end - segment}\t\t"
f"{seg_end - segment - header_length}\t\t{seg_types[seg_type]}")
segment = seg_end
def segment_extending():
"""Проверка на расширение сегментов"""
segment_nums = setting.initialisation("program.yovc")
list_num = add.list_segment()
namespace_num = find.attribute(seg_links["system"], "target_namespace")
data_num = find.attribute(seg_links["system"], "first_data_segment")
extend.data_segment(data_num)
extend.namespace(namespace_num)
extend.list_segment(list_num)
view.tape()
def relative_links(num):
data_begin = find.attribute(num, "data_begin")
data_end = find.attribute(num, "segment_end")
index = data_begin
while index < data_end:
obj_type, obj_value = read.entity(index)
if obj_type == "link":
write.entity(index, "link", data_begin + obj_value)
index += memory_control.determine_object_size(obj_type, obj_value)
elif obj_type == "chars":
index += memory_control.determine_object_size(obj_type, obj_value)
else:
index += 2
def stack(num):
top = find.attribute(num, "first_empty_cell")
data_begin = find.attribute(num, "data_begin")
if top == data_begin:
stack_type = find.attribute(num, "type")
raise LowerCommandError(f"Стек {seg_types[stack_type]} пуст при "
f"попытке извлечения")
last_cell = find.attribute(num, "last_full_cell")
free_cells = find.attribute(num, "free_cells")
obj_type, obj_value = read.entity(last_cell)
write.entity(last_cell, "none", None)
change_stack(num, top - types_length["link"],
last_cell - types_length["link"],
free_cells + types_length["link"])
return obj_type, obj_value
def equate_operation_working():
"""Проверка работы команды приравнивания"""
setting.initialisation("program.yovc")
objects.Create(["chars", "Крутой язык"])
str_num = make.string_segment("Ё")
objects.Find(["link", str_num])
name_num = pull.memory_stack()
value_num = pull.memory_stack()
objects.Equate(name_num, value_num)
namespace_num = find.attribute(seg_links["system"], "target_namespace")
view.namespace_items(namespace_num)
console.Output(name_num)
list_num = make.list_segment([0, 1, 2, 3, 4, 5])
index_num = make.entity("number", 3)
objects.Sub_object(["link", list_num], ["link", index_num])
elem_num = pull.memory_stack()
objects.Create(["array", [6, 7, 8]])
value_num = pull.memory_stack()
objects.Equate(elem_num, value_num)
console.Output(elem_num)
objects.Sub_object(["link", list_num], ["link", index_num])
str_num = make.string_segment("array")
objects.Find(["link", str_num])
name_num = pull.memory_stack()
elem_num = pull.memory_stack()
objects.Equate(name_num, elem_num)
view.namespace_items(namespace_num)
console.Output(name_num)
def get_last(num):
if not find.is_last(num):
next_num = find.attribute(num, "next_segment")
last_num = get_last(next_num)
else:
last_num = num
return last_num
def data_segment(num, obj_type, value):
top = find.attribute(num, "first_empty_cell")
obj_size = memory_control.determine_object_size(obj_type, value)
place = check_free_place(num, obj_size)
if place >= 0:
write.entity(top, obj_type, value)
change_data(num, top + obj_size, place)
index = top
else:
if not find.is_last(num):
next_num = find.attribute(num, "next_segment")
index = data_segment(next_num, obj_type, value)
else:
new_num = extend.data_segment(num)
index = data_segment(new_num, obj_type, value)
return index
def Call(arg):
arg_type, arg_value = arg
if arg_type == "link":
target_cell = find.attribute(seg_links["system"], "target_cell")
append.call_stack("link", target_cell + 4)
else:
raise UndefinedArgument(f"Поведение команды Cal с аргументом типа"
f"{arg_type} не определено")
def string_segment_element(num, index):
while num != 0:
element_type, element = find.string_segment_element(num, index)
if element_type == "link":
return element_type, element
index = element
num = find.attribute(num, "next_segment")
return "none", 0
def namespace_items(num, last=False):
data_begin, data_end = data_range(num)
if last:
top = find.attribute(num, "first_empty_cell")
data_end = top
for i in range(data_begin, data_end, 2):
link_type, link = read.entity(i)
draw.dictionary_item(link)
def list_segment(num):
result = []
while num != 0:
next_num = find.attribute(num, "next_segment")
last = True if next_num == 0 else False
result += find.list_segment(num, last=last)
num = next_num
return result
def stack(num, obj_type, value):
check_type("stack", obj_type)
obj_size = memory_control.determine_object_size(obj_type, value)
top = find.attribute(num, "first_empty_cell")
place = check_free_place(num, obj_size)
check_stack_overflow(num, place)
write.entity(top, obj_type, value)
change_stack(num, top + obj_size, top, place)
def namespace_element(num, key):
number = num
while number != 0:
value_type, value = namespace_key(number, key)
if value_type is not None:
return value_type, value
number = find.attribute(number, "next_segment")
new_num = item.write_namespace_name(num, key)
return "link", new_num
def program_code(num):
data_begin = find.attribute(num, "data_begin")
index = data_begin
obj_type, command = read.entity(index)
while obj_type != "none":
display.command_with_args(index)
com_name, args = read.command_with_args(index)
index += memory_control.determine_object_size("command_with_args", args)
obj_type, command = read.entity(index)
def namespace(num):
number = 1
while num != 0:
print(f"Segment #{number}:", end=" ")
next_num = find.attribute(num, "next_segment")
last = True if next_num == 0 else False
show.namespace(num, last=last)
num = next_num
number += 1
def entity(num):
kind = read.kind(num)
if kind == "segment":
kind = seg_types[find.attribute(num, "type")]
if kind not in read_segment_dictionary:
raise LowerCommandError(f"Неподдерживаемый тип сегмента для чтения"
f" {kind}")
return kind, read_segment_dictionary[kind](num)
else:
return read.entity(num)
def namespace_key(num, key):
data_begin, data_end = find.data_range(num)
top = find.attribute(num, "first_empty_cell")
need_key_type, need_key = key
for i in range(data_begin, top, 2):
item_type, item_value = read.entity(i)
key_type, key_link = find.dictionary_item_key(item_value)
key_value_type, key_value = entity(key_link)
if key_value_type == need_key_type and key_value == need_key:
return "link", item_value + 6
return None, None
def Find(arg):
arg_type, arg_value = arg
if arg_type == "link":
key = get.entity(arg_value)
# потом: сделать механизм восходящего поиска
seg_num = find.attribute(seg_links["system"], "target_namespace")
res_type, res_num = get.namespace_element(seg_num, key)
append.memory_stack("link", res_num)
else:
raise UndefinedArgument(f"Поведение команды Fnd с аргументом типа "
f"{arg_type} не определено")
def program_writing():
"""Проверка на запись программы"""
add.system_area()
add.memory_stack()
add.call_stack()
add.data_segment()
add.program("program.yovc")
view.tape()
program = find.attribute(seg_links["system"], "main_program")
show.attribute(seg_links["system"], "target_cell")
show.program_code(program)
def segment_body(num):
data_begin, data_end = data_range(num)
top = find.attribute(num, "first_empty_cell")
index = data_begin
obj_type, obj_value = read.entity(index)
while index < top:
print(index, end=" ")
display.entity(index)
index += memory_control.determine_object_size(obj_type, obj_value)
if index < data_end:
obj_type, obj_value = read.entity(index)
print()
def namespace_putting():
"""Проверка на заполнение пространства имён"""
real_namespace_size = minimal_data_length["namespace"]
minimal_data_length["namespace"] = 4
setting.initialisation("program.yovc")
prog_num = find.attribute(seg_links["system"], "main_program")
num = add.namespace(prog_num)
put.namespace(num, "link_list", [i for i in range(40)])
view.tape()
print(get.namespace(num))
view.namespace(num)
minimal_data_length["namespace"] = real_namespace_size
def data_segment_putting():
"""Проверка на заполнение сегмента данных"""
real_data_segment_size = minimal_data_length["data_segment"]
minimal_data_length["data_segment"] = 4
setting.initialisation("program.yovc")
num = find.attribute(seg_links["system"], "first_data_segment")
put.data_segment(num, "chars", "Эта строка не влезет в маленький сегмент")
put.data_segment(num, "dictionary_item", [15, 20, 25])
put.data_segment(num, "number", 255)
view.tape()
view.data_segment()
minimal_data_length["data_segment"] = real_data_segment_size
def find_operation_working():
"""Проверка работы команды поиска"""
real_namespace_size = minimal_data_length["namespace"]
minimal_data_length["namespace"] = 2
setting.initialisation("program.yovc")
prog_num = find.attribute(seg_links["system"], "main_program")
name_num = find.attribute(prog_num, "namespace")
view.namespace_items(name_num)
str_num = make.string_segment("J")
objects.Find(["link", str_num])
value_link = pull.memory_stack()
draw.link_on_link(value_link)
view.namespace_items(name_num)
item.write_namespace_name(name_num, ["string_segment", "Yo"],
value=["number", 1])
str_num = make.string_segment("Yo")
view.tape()
view.data_segment()
objects.Find(["link", str_num])
view.namespace_items(name_num)
value_link = pull.memory_stack()
draw.link_on_link(value_link)
minimal_data_length["namespace"] = real_namespace_size
def string_segment(num, obj_type, value):
check_type("string", obj_type)
last_num = get_last(num)
obj_size = memory_control.determine_object_size(obj_type, value)
top = find.attribute(last_num, "first_empty_cell")
place = check_free_place(last_num, obj_size)
if place >= 0:
write.char_list(top, value)
change_data(last_num, top + obj_size, place)
else:
part_1, part_2 = split_cells(obj_size, place, value)
write.char_list(top, part_1)
fill_segment(last_num)
new_num = extend.string_segment(last_num)
string_segment(num, obj_type, part_2)
def stack_taking_putting():
"""Проверка на заполнение и опустошение стека"""
real_memory_stack_size = minimal_data_length["memory_stack"]
minimal_data_length["memory_stack"] = 8
setting.initialisation("program.yovc")
num = find.attribute(seg_links["system"], "memory_stack")
data = [5, 10, 15, 20, 25]
print("Заполнение:")
for i in range(len(data)):
try:
put.stack(num, "link", data[i])
show.segment_body(num)
except LowerCommandError as error:
print(error)
print("Извлечение:")
for i in range(len(data)):
try:
obj_type, obj_value = take.stack(num)
show.segment_body(num)
except LowerCommandError as error:
print(error)
show.segment_body(num)
minimal_data_length["memory_stack"] = real_memory_stack_size
def data_range(num):
data_begin = find.attribute(num, "data_begin")
data_end = find.attribute(num, "segment_end")
return data_begin, data_end
def check_free_place(num, obj_size):
free_cells = find.attribute(num, "free_cells")
place = free_cells - obj_size
return place
def cells_stream(num):
data_begin = find.attribute(num, "data_begin")
data_end = find.attribute(num, "segment_end")
for i in range(data_begin, data_end, 2):
cells = [read.cell(i), read.cell(i + 1)]
print(i, *cells)
def fill_segment(num):
data_end = find.attribute(num, "segment_end")
change_data(num, data_end, 0)
