converter_RPN.py

from typing import List, Tuple, Any, Optional
from table_manager import TableManager

# Определяем тип Token для аннотаций
Token = Tuple[str, Any, object]


class RPNConverter:
    """Класс для преобразования программы в ПОЛИЗ (польскую инверсную запись)"""

    def __init__(self, table_manager: TableManager):
        self.table_manager = table_manager
        self.P = []  # массив для ПОЛИЗа: список кортежей (n, k)
        self.free = 1  # номер первого свободного элемента (начинаем с 1)
        self.label_positions = {}  # метка -> позиция в P
        self.waiting_labels = []  # (позиция_в_P, имя_метки)
        self.label_counter = 0  # счетчик для генерации уникальных меток

        # Включаем дебаг
        self.DEBUG = True
        self.debug_step = 0

        # Дополнительные операции для ПОЛИЗа (БЕЗ точки!)
        self.special_operators = {
            "!": 25,  # безусловный переход
            "!F": 26,  # условный переход "по лжи"
            "~": 27,  # операция ввода (read)
            "$": 28,  # операция вывода (write)
        }

        # Добавляем только нужные специальные операции в таблицу операторов
        for op, code in self.special_operators.items():
            if op not in self.table_manager.operators_table:
                self.table_manager.operators_table[op] = code

    def debug_print(self, *args, level="INFO"):
        """Расширенный вывод для отладки"""
        if self.DEBUG:
            self.debug_step += 1
            print(f"[ПЕРЕВОД В ПОЛИЗ:{self.debug_step:04d}] {level:8} ->", *args)

    def convert(self, tokens: List[Token]) -> List[Tuple[int, int]]:
        """Преобразование списка токенов в ПОЛИЗ"""
        self.debug_print("НАЧАЛО ПРЕОБРАЗОВАНИЯ В ПОЛИЗ", level="START")

        # Сбрасываем состояние конвертера
        self.P = []
        self.free = 1
        self.label_positions = {}
        self.waiting_labels = []
        self.label_counter = 0

        # ВАЖНО: очищаем таблицу адресов при каждом новом преобразовании
        self.table_manager.addresses_table = {}

        from syntax_analyzer import SyntaxAnalyzer

        syntax_analyzer = SyntaxAnalyzer(tokens, self.table_manager)
        syntax_analyzer.set_rpn_converter(self)
        syntax_analyzer.enable_rpn_generation()

        try:
            is_valid, errors, semantic_errors = syntax_analyzer.analyze()
            self.table_manager.update_tables_display()

            # ВАЖНО: заполняем ожидающие метки ПЕРЕД добавлением пустой команды
            self.fill_waiting_labels()

            # ДОБАВЛЯЕМ ПУСТУЮ КОМАНДУ В КОНЕЦ для переходов
            self.debug_print(
                "Добавление пустой команды в конце для переходов", level="INFO"
            )
            # Добавляем только если еще нет пустой команды в конце
            if not self.P or self.P[-1] != (0, 0):
                self.put_lex(0, 0)  # Пустая команда-заглушка

            if not is_valid:
                error_messages = errors + semantic_errors
                raise ValueError(f"Ошибки анализа: {', '.join(error_messages[:3])}")

        except Exception as e:
            self.fill_waiting_labels()
            # Все равно добавляем пустую команду
            if not self.P or self.P[-1] != (0, 0):
                self.put_lex(0, 0)
            raise

        return self.get_rpn()

    def put_lex(self, table_num: int, code_num: int):
        """Запись лексемы в массив P"""
        self.debug_print(
            f"Добавление в ПОЛИЗ: ({table_num},{code_num})", level="PUT_LEX"
        )
        self.P.append((table_num, code_num))
        self.free += 1

    def put_l(self, token_type: str, token_value: str):
        """Запись текущей лексемы в массив P"""
        self.debug_print(
            f"put_l: тип={token_type}, значение={token_value}", level="PUT_L"
        )

        if token_type == "KEYWORD":
            code = self.table_manager.keywords_table.get(token_value)
            if code:
                self.put_lex(1, code)
        elif token_type == "OPERATOR":
            code = self.table_manager.operators_table.get(token_value)
            if code:
                self.put_lex(2, code)
        elif token_type == "IDENTIFIER":
            info = self.table_manager.get_identifier_info(token_value)
            if info:
                self.put_lex(4, info["index"])
            else:
                self.debug_print(
                    f"Идентификатор не найден: {token_value}", level="WARNING"
                )
        elif token_type == "CONSTANT":
            code = self.table_manager.constants_table.get(token_value)
            if code:
                self.put_lex(3, code)
            else:
                self.debug_print(
                    f"Константа не найдена: {token_value}", level="WARNING"
                )
        else:
            self.debug_print(f"Неизвестный тип токена: {token_type}", level="WARNING")

    def put_l5(self, identifier_name: str):
        """Запись адреса переменной (таблица 5)"""
        self.debug_print(f"put_l5: адрес переменной {identifier_name}", level="PUT_L5")
        addr_index = self.table_manager.add_address(identifier_name)
        self.put_lex(5, addr_index)

    def make_label(self, position: int) -> Tuple[int, int]:
        """Создание лексемы-метки (0, position)"""
        return (0, position)

    def add_waiting_label(self, position: int, label_name: str):
        """Добавление ожидающей заполнения метки"""
        self.debug_print(
            f"Ожидающая метка: {label_name} на позиции {position}",
            level="LABEL",
        )
        self.waiting_labels.append((position, label_name))

    def set_label_position(self, label_name: str, position: int):
        """Установка позиции для метки"""
        self.debug_print(
            f"Установка позиции метки {label_name} = {position}",
            level="LABEL",
        )
        self.label_positions[label_name] = position

    def fill_waiting_labels(self):
        """Заполнение позиций ожидающих меток"""
        self.debug_print(
            f"Заполнение {len(self.waiting_labels)} ожидающих меток", level="LABEL"
        )

        # Создаем копию, чтобы не менять список во время итерации
        waiting_labels_copy = list(self.waiting_labels)

        for pos, label_name in waiting_labels_copy:
            if label_name in self.label_positions:
                label_pos = self.label_positions[label_name]
                self.debug_print(
                    f"Заполняем метку {label_name} -> позиция {label_pos}",
                    level="LABEL",
                )
                if label_pos < 0 or label_pos >= len(self.P):
                    self.debug_print(
                        f"ОШИБКА: Метка {label_name} указывает на некорректную позицию {label_pos}",
                        level="ERROR",
                    )
                    if label_pos >= len(self.P):
                        label_pos = len(self.P)+1  # Указываем на конец программы
                        self.debug_print(
                            f"Исправлена метка {label_name}: -> позиция {label_pos} (конец программы)",
                            level="FIX",
                        )

                self.P[pos] = self.make_label(label_pos)
            else:
                self.debug_print(f"Метка {label_name} не определена!", level="ERROR")
                # Устанавливаем метку на конец программы
                self.P[pos] = (0, len(self.P))

        # Очищаем список ожидающих меток после заполнения
        self.waiting_labels = []

    def generate_label(self) -> str:
        """Генерация уникального имени метки"""
        used_labels = set(self.label_positions.keys())
        for pos, label in self.waiting_labels:
            used_labels.add(label)

        self.label_counter += 1
        label_name = f"L{self.label_counter}"

        while label_name in used_labels:
            self.label_counter += 1
            label_name = f"L{self.label_counter}"

        self.debug_print(f"Сгенерирована метка: {label_name}", level="LABEL")
        return label_name

    def process_if_statement(
        self,
        condition_result: bool,
        then_label: str,
        else_label: str = None,
        end_label: str = None,
    ):
        """Обработка оператора if с генерацией правильного ПОЛИЗа"""
        self.debug_print(
            f"Обработка IF: условие={condition_result}, then={then_label}, else={else_label}, end={end_label}",
            level="IF",
        )

        # Если условие ложно, переходим к else или к концу
        if not condition_result and else_label:
            self.put_lex(2, self.special_operators["!"])  # безусловный переход
            self.add_waiting_label(len(self.P) - 1, else_label)

        # Затем код для then-ветки
        if then_label:
            self.set_label_position(then_label, len(self.P))
            # Код then-ветки будет добавлен синтаксическим анализатором

        # Если есть else, добавляем переход к концу после then
        if else_label and end_label:
            self.put_lex(2, self.special_operators["!"])  # безусловный переход
            self.add_waiting_label(len(self.P) - 1, end_label)

            # Устанавливаем метку else
            self.set_label_position(else_label, len(self.P))

        # Если есть end_label, устанавливаем его позицию
        if end_label:
            self.set_label_position(end_label, len(self.P))

    def get_rpn(self) -> List[Tuple[int, int]]:
        """Получение готового ПОЛИЗа"""
        self.debug_print("Получение финального ПОЛИЗа", level="GET_RPN")

        self.fill_waiting_labels()

        # ДОБАВЛЯЕМ ПУСТУЮ КОМАНДУ В КОНЕЦ для переходов
        self.debug_print(
            "Добавление пустой команды в конце для переходов", level="INFO"
        )
        # Добавляем только если еще нет пустой команды в конце
        if not self.P or self.P[-1] != (0, 0):
            self.put_lex(0, 0)  # Пустая команда-заглушка

        self.debug_print(f"Итоговый ПОЛИЗ: {len(self.P)} элементов", level="FINISH")

        if self.DEBUG:
            print("\n" + "=" * 60)
            print("ПОЛИЗ программа:")
            print("=" * 60)
            for i, (table_num, code_num) in enumerate(self.P):
                if table_num == 0 and code_num == 0 and i == len(self.P) - 1:
                    print(
                        f"{i+1:4d}: ({table_num}, {code_num:3d})  # <КОНЕЦ ПРОГРАММЫ>"
                    )
                elif table_num == 0:
                    print(
                        f"{i+1:4d}: ({table_num}, {code_num:3d})  # метка({code_num})"
                    )
                elif table_num == 1:
                    for kw, code in self.table_manager.keywords_table.items():
                        if code == code_num:
                            print(f"{i+1:4d}: ({table_num}, {code_num:3d})  # {kw}")
                            break
                elif table_num == 2:
                    for op, code in self.table_manager.operators_table.items():
                        if code == code_num:
                            if code_num == 25:
                                print(
                                    f"{i+1:4d}: ({table_num}, {code_num:3d})  # {op} (безусловный переход)"
                                )
                            elif code_num == 26:
                                print(
                                    f"{i+1:4d}: ({table_num}, {code_num:3d})  # {op} (условный переход по лжи)"
                                )
                            else:
                                print(f"{i+1:4d}: ({table_num}, {code_num:3d})  # {op}")
                            break
                elif table_num == 3:
                    for const, code in self.table_manager.constants_table.items():
                        if code == code_num:
                            print(f"{i+1:4d}: ({table_num}, {code_num:3d})  # {const}")
                            break
                elif table_num == 4:
                    for name, info in self.table_manager.identifiers_table.items():
                        if info["index"] == code_num:
                            print(f"{i+1:4d}: ({table_num}, {code_num:3d})  # {name}")
                            break
                elif table_num == 5:
                    addr_name = self.table_manager.get_address_name(code_num)
                    if addr_name:
                        print(
                            f"{i+1:4d}: ({table_num}, {code_num:3d})  # адр({addr_name})"
                        )
                    else:
                        print(
                            f"{i+1:4d}: ({table_num}, {code_num:3d})  # адр({code_num})"
                        )
                else:
                    print(f"{i+1:4d}: ({table_num}, {code_num:3d})")
            print("=" * 60)

        return self.P