syntax_analyzer.py

from semantic_analyzer import SemanticAnalyzer
from converter_RPN import RPNConverter
from typing import List, Tuple, Optional, Any

Token = Tuple[str, Any, object]


class SyntaxAnalyzer:
    DEBUG = True
    analysis_step = 0

    def __init__(self, tokens: List[Token], table_manager=None):
        self.tokens = tokens
        self.table_manager = table_manager
        self.semantic_analyzer = SemanticAnalyzer(table_manager)
        self.rpn_converter = None  # Будет установлен позже
        self.position = 0
        self.current = tokens[0] if tokens else None
        self.errors = []
        self.generate_rpn = False  # Флаг для включения генерации ПОЛИЗа

    def set_rpn_converter(self, converter):
        """Установка RPN конвертера"""
        self.rpn_converter = converter

    def enable_rpn_generation(self):
        """Включение генерации ПОЛИЗа"""
        self.generate_rpn = True

    def get_rpn_result(self):
        """Получение результата перевода в ПОЛИЗ"""
        return self.rpn_converter.get_rpn()

    def dprint(self, *args, level="INFO"):
        """Расширенный вывод для отладки с нумерацией шагов"""
        if self.DEBUG:
            self.analysis_step += 1
            current_tok = (
                f"{self.current[0]}:{self.current[1]}" if self.current else "EOF"
            )
            pos = self._pos()
            print(
                f"[СИНТАКСИС:{self.analysis_step:04d}] {level:8} {current_tok:20} @ {pos:3} ->",
                *args,
            )

    def analyze(self) -> Tuple[bool, List[str], List[str]]:
        """Запускает синтаксический и семантический анализ"""
        self.dprint("НАЧАЛО АНАЛИЗА ПРОГРАММЫ", level="START")
        semantic_errors = []

        try:
            success = self.PROGRAM()
            self.semantic_analyzer.check_stack_empty()
            semantic_errors = self.semantic_analyzer.get_errors()
            self.semantic_analyzer.print_summary()

            self.dprint(
                f"ЗАВЕРШЕНИЕ АНАЛИЗА. Синтаксических ошибок: {len(self.errors)}, Семантических ошибок: {len(semantic_errors)}",
                level="FINISH",
            )

            return (
                (len(self.errors) == 0 and len(semantic_errors) == 0),
                self.errors,
                semantic_errors,
            )

        except Exception as e:
            self.errors.append(f"Критическая ошибка: {e}")
            import traceback

            self.dprint(f"КРИТИЧЕСКАЯ ОШИБКА: {traceback.format_exc()}", level="ERROR")
            return False, self.errors, semantic_errors

    def PROGRAM(self):
        self.dprint("ВХОД В ПРОГРАММУ", level="RULE")

        if not self.expect(expected_value="{"):
            return False

        max_steps = 1000  # Защита от бесконечного цикла
        step_count = 0

        # Обрабатываем описания и операторы до }
        while (
            self.current and not self.EQ(expected_value="}") and step_count < max_steps
        ):
            step_count += 1
            tv = self.tok_text()

            if tv == "dim":
                self.dprint("ОБНАРУЖЕНО ОПИСАНИЕ (dim)", level="RULE")
                self.DESCR()
            elif self.OPER_start():
                self.dprint("ОБНАРУЖЕН ОПЕРАТОР", level="RULE")
                self.OPER()
            else:
                self.err_proc("Ожидается описание (dim) или оператор")
                self.sync()
                continue

            # Проверяем точку с запятой после оператора/описания
            if self.current and not self.EQ(expected_value="}"):
                if not self.expect(expected_value=";"):
                    return False

        if step_count >= max_steps:
            self.err_proc(
                "Превышено максимальное количество шагов анализа - возможен бесконечный цикл"
            )
            return False

        if not self.expect(expected_value="}"):
            return False

        self.dprint("ПРОГРАММА УСПЕШНО ПРОАНАЛИЗИРОВАНА", level="RULE_SUCCESS")
        return True

    def DESCR(self):
        self.dprint("ВХОД В ОПИСАНИЕ (DESCR)", level="RULE")

        if not self.expect(expected_value="dim"):
            return

        # Начало семантического анализа описаний
        self.semantic_analyzer.start_description()

        # Первый идентификатор
        if self.current and self.current[0] == "IDENTIFIER":
            identifier_name = self.current[1]
            self.dprint(f"ОБНАРУЖЕН ИДЕНТИФИКАТОР: '{identifier_name}'", level="RULE")
            self.semantic_analyzer.add_identifier_to_description(identifier_name)
            self.gl()
        else:
            self.err_proc("Ожидается идентификатор")
            return

        # Дополнительные идентификаторы через запятую
        while self.EQ(expected_value=","):
            self.dprint("ОБНАРУЖЕНА ЗАПЯТАЯ", level="RULE")
            self.gl()
            if self.current and self.current[0] == "IDENTIFIER":
                identifier_name = self.current[1]
                self.dprint(
                    f"ОБНАРУЖЕН ИДЕНТИФИКАТОР: '{identifier_name}'", level="RULE"
                )
                self.semantic_analyzer.add_identifier_to_description(identifier_name)
                self.gl()
            else:
                self.err_proc("Ожидается идентификатор после ','")
                return

        # Определение типа
        var_type = None
        if self.EQ(expected_value="integer"):
            var_type = "integer"
            self.dprint("ОПРЕДЕЛЕН ТИП: integer", level="RULE")
            self.gl()
        elif self.EQ(expected_value="real"):
            var_type = "real"
            self.dprint("ОПРЕДЕЛЕН ТИП: real", level="RULE")
            self.gl()
        elif self.EQ(expected_value="boolean"):
            var_type = "boolean"
            self.dprint("ОПРЕДЕЛЕН ТИП: boolean", level="RULE")
            self.gl()
        else:
            self.err_proc("Ожидается тип (integer|real|boolean)")
            return

        # Завершение семантического анализа описаний
        if var_type:
            self.semantic_analyzer.finish_description(var_type)
            self.dprint(f"ЗАВЕРШЕНО ОПИСАНИЕ С ТИПОМ: {var_type}", level="RULE_SUCCESS")

    def OPER_start(self) -> bool:
        tv = self.tok_text()
        if not self.current:
            return False
        return (self.current[0] == "IDENTIFIER") or tv in (
            "if",
            "for",
            "while",
            "read",
            "write",
            "[",
        )

    def OPER(self):
        if not self.current:
            return

        tv = self.tok_text()

        if self.EQ(expected_value=";"):
            self.gl()
            return

        if tv == "[":
            self.dprint("ОБНАРУЖЕН СОСТАВНОЙ ОПЕРАТОР", level="RULE")
            self.COMP()
            return

        if self.current[0] == "IDENTIFIER":
            self.dprint("ОБНАРУЖЕНО ПРИСВАИВАНИЕ", level="RULE")
            self.ASSIGN()
            return

        if tv == "if":
            self.dprint("ОБНАРУЖЕН УСЛОВНЫЙ ОПЕРАТОР", level="RULE")
            self.IF()
            return

        if tv == "for":
            self.dprint("ОБНАРУЖЕН ЦИКЛ FOR", level="RULE")
            self.FOR()
            return

        if tv == "while":
            self.dprint("ОБНАРУЖЕН ЦИКЛ WHILE", level="RULE")
            self.WHILE()
            return

        if tv == "read":
            self.dprint("ОБНАРУЖЕН ОПЕРАТОР ВВОДА", level="RULE")
            self.READ()
            return

        if tv == "write":
            self.dprint("ОБНАРУЖЕН ОПЕРАТОР ВЫВОДА", level="RULE")
            self.WRITE()
            return

        self.err_proc("Неизвестный оператор")
        self.sync()

    def COMP(self):
        self.dprint("ВХОД В СОСТАВНОЙ ОПЕРАТОР (COMP)", level="RULE")

        if not self.expect(expected_value="["):
            return

        first = True
        error_count = 0
        max_errors = 5  # Ограничиваем количество ошибок в одном блоке

        while (
            self.current
            and not self.EQ(expected_value="]")
            and error_count < max_errors
        ):
            if not first:
                if self.EQ(expected_value=":"):
                    self.dprint("ОБНАРУЖЕН РАЗДЕЛИТЕЛЬ :", level="RULE")
                    self.gl()
                elif not self.tok_after_newline():
                    self.err_proc("Ожидается ':' или перевод строки между операторами")
                    error_count += 1
                    self.sync()
                    continue

            if self.OPER_start():
                self.OPER()
            else:
                if self.EQ(expected_value="]"):
                    break
                self.err_proc("Ожидается оператор внутри блока")
                error_count += 1
                self.sync()
                continue

            first = False

        if error_count >= max_errors:
            self.err_proc(
                "Слишком много ошибок в составном операторе - пропускаем блок"
            )
            # Пропускаем до закрывающей скобки
            while self.current and not self.EQ(expected_value="]"):
                self.gl()

        if not self.expect(expected_value="]"):
            return

        self.dprint("ЗАВЕРШЕНИЕ СОСТАВНОГО ОПЕРАТОРА", level="RULE_SUCCESS")

    def ASSIGN(self):
        if not (self.current and self.current[0] == "IDENTIFIER"):
            self.err_proc("Ожидается идентификатор в присваивании")
            return

        identifier_name = self.current[1]
        self.dprint(f"ОБРАБОТКА ПРИСВАИВАНИЯ ДЛЯ: '{identifier_name}'", level="RULE")

        # Генерация ПОЛИЗа: адрес переменной (таблица 5)
        if self.generate_rpn:
            self.rpn_converter.put_l5(identifier_name)

        self.gl()

        if not self.expect(expected_value="as"):
            return

        # Анализ выражения
        self.EXPR()

        # Генерация ПОЛИЗа: операция присваивания
        if self.generate_rpn:
            self.rpn_converter.put_lex(2, self.table_manager.operators_table[":="])

        # Семантический анализ: проверка соответствия типов в присваивании
        self.semantic_analyzer.check_assignment(identifier_name)

        self.dprint(
            f"ЗАВЕРШЕНО ПРИСВАИВАНИЕ ДЛЯ: '{identifier_name}'", level="RULE_SUCCESS"
        )

    def IF(self):
        if not self.expect(expected_value="if"):
            return

        self.dprint("ОБРАБОТКА УСЛОВНОГО ОПЕРАТОРА", level="RULE")

        # Анализ условия
        self.EXPR()

        # Семантический анализ: проверка булевского типа условия
        self.semantic_analyzer.check_condition()

        # Генерация ПОЛИЗа: условный переход "по лжи"
        if self.generate_rpn and self.rpn_converter:
            label_else = self.rpn_converter.generate_label()
            # Место для метки перехода (заполним позже)
            jump_pos = len(self.rpn_converter.P)
            self.rpn_converter.put_lex(0, 0)
            # Запоминаем позицию метки для заполнения
            self.rpn_converter.add_waiting_label(jump_pos, label_else)

            # Условный переход !F
            self.rpn_converter.put_lex(2, 26)  # !F

        if not self.expect(expected_value="then"):
            return

        # Код ветки then
        self.OPER()  # Ветка then

        # Безусловный переход после then (чтобы пропустить else)
        if self.generate_rpn and self.rpn_converter:
            label_end = self.rpn_converter.generate_label()
            # Место для метки перехода (заполним позже)
            jump_pos2 = len(self.rpn_converter.P)
            self.rpn_converter.put_lex(0, 0)
            # Запоминаем позицию метки для заполнения
            self.rpn_converter.add_waiting_label(jump_pos2, label_end)

            self.rpn_converter.put_lex(2, 25)  # ! (безусловный переход)
            

            # Устанавливаем позицию метки else
            self.rpn_converter.set_label_position(label_else, len(self.rpn_converter.P)+1)

        if self.EQ(expected_value="else"):
            self.dprint("ОБНАРУЖЕНА ВЕТКА ELSE", level="RULE")
            self.gl()

            # Устанавливаем позицию метки else перед веткой else
            if self.generate_rpn and self.rpn_converter:
                self.rpn_converter.set_label_position(
                    label_else, len(self.rpn_converter.P)+1
                )

            # Код ветки else
            self.OPER()  # Ветка else

            # Устанавливаем позицию конца if
            if self.generate_rpn and self.rpn_converter:
                self.rpn_converter.set_label_position(
                    label_end, len(self.rpn_converter.P)+1
                )
        else:
            # Только then ветка
            if self.generate_rpn and self.rpn_converter:
                # Устанавливаем позицию else (после безусловного перехода)
                self.rpn_converter.set_label_position(
                    label_else, len(self.rpn_converter.P)+1
                )
                # Метка end совпадает с else
                self.rpn_converter.set_label_position(
                    label_end, len(self.rpn_converter.P)+1
                )

        self.dprint("ЗАВЕРШЕН УСЛОВНЫЙ ОПЕРАТОР", level="RULE_SUCCESS")

    def FOR(self):
        if not self.expect(expected_value="for"):
            return

        self.dprint("ОБРАБОТКА ЦИКЛ FOR", level="RULE")

        # Идентификатор цикла
        if not (self.current and self.current[0] == "IDENTIFIER"):
            self.err_proc("Ожидается идентификатор в заголовке цикла for")
            return

        identifier_name = self.current[1]

        # Генерация ПОЛИЗа: адрес переменной цикла ДЛЯ НАЧАЛЬНОГО ПРИСВАИВАНИЯ
        if self.generate_rpn:
            self.rpn_converter.put_l5(identifier_name)

        self.gl()

        if not self.expect(expected_value="as"):
            return

        # Начальное значение
        self.EXPR()

        # Извлекаем тип начального значения из стека
        self.semantic_analyzer.check_expression_type("integer")

        # Генерация ПОЛИЗа: операция присваивания начального значения
        if self.generate_rpn:
            self.rpn_converter.put_lex(2, self.table_manager.operators_table[":="])

        # Метка начала цикла (для проверки условия)
        if self.generate_rpn:
            label_start = self.rpn_converter.generate_label()
            start_pos = len(self.rpn_converter.P)+1
            self.rpn_converter.set_label_position(label_start, start_pos)

        if not self.expect(expected_value="to"):
            return

        # ПРОСТОЙ ИСПРАВЛЕННЫЙ ВАРИАНТ:
        # Разбираем выражение для верхней границы
        result = self.EXPR(put=False)

        # Извлекаем тип верхней границы из стека
        self.semantic_analyzer.check_expression_type("integer")

        if not self.expect(expected_value="do"):
            return

        # Генерация ПОЛИЗа для условия цикла i <= верхняя_граница
        if self.generate_rpn:
            # ВАЖНО: Сейчас в стеке значение верхней границы (n)
            # Нам нужно: i, n для сравнения i <= n

            # Сначала загружаем i
            info = self.table_manager.get_identifier_info(identifier_name)
            if info:
                self.rpn_converter.put_lex(4, info["index"])  # ЗНАЧЕНИЕ i
                self.rpn_converter.put_lex(*result)  # ЗНАЧЕНИЕ n

            # Теперь в стеке: [..., n, i] где i на вершине
            # Операция <= будет сравнивать i <= n, что ПРАВИЛЬНО!
            self.rpn_converter.put_lex(2, self.table_manager.operators_table["<="])

            # Условный переход "по лжи" за цикл
            label_end = self.rpn_converter.generate_label()
            
            # Место для метки перехода (заполним позже)
            jump_pos = len(self.rpn_converter.P)
            self.rpn_converter.put_lex(0, 0)
            # Запоминаем позицию метки для заполнения
            self.rpn_converter.add_waiting_label(jump_pos, label_end)
            # Условный переход !F (если i > n, то выходим)
            self.rpn_converter.put_lex(2, 26)  # !F

        # Тело цикла
        self.OPER()

        # Генерация ПОЛИЗа: инкремент переменной цикла
        if self.generate_rpn:
            # i := i + 1
            self.rpn_converter.put_l5(identifier_name)  # адрес i
            info = self.table_manager.get_identifier_info(identifier_name)
            if info:
                self.rpn_converter.put_lex(4, info["index"])  # значение i
            # Константа 1
            const_index = self.table_manager.add_constant("1")
            self.rpn_converter.put_lex(3, const_index)
            self.rpn_converter.put_lex(2, self.table_manager.operators_table["+"])
            self.rpn_converter.put_lex(2, self.table_manager.operators_table[":="])

            
            # Ссылка на метку начала цикла
            self.rpn_converter.put_lex(0, 0)
            # Запоминаем позицию для заполнения
            jump_pos2 = len(self.rpn_converter.P) - 1
            self.rpn_converter.add_waiting_label(jump_pos2, label_start)
            # Безусловный переход в начало цикла (к проверке условия)
            self.rpn_converter.put_lex(2, 25)  # ! (безусловный переход)

            # Устанавливаем позицию конца цикла
            self.rpn_converter.set_label_position(label_end, len(self.rpn_converter.P)+1)

        self.dprint("ЗАВЕРШЕН ЦИКЛ FOR", level="RULE_SUCCESS")

    def WHILE(self):
        if not self.expect(expected_value="while"):
            return

        self.dprint("ОБРАБОТКА ЦИКЛА WHILE", level="RULE")

        # Метка начала условия (для возврата)
        if self.generate_rpn:
            label_start = self.rpn_converter.generate_label()
            self.rpn_converter.set_label_position(
                label_start, len(self.rpn_converter.P)+1
            )

        # Условие
        self.EXPR()

        # Семантический анализ: проверка булевского типа условия
        self.semantic_analyzer.check_condition()

        # Генерация ПОЛИЗа: условный переход "по лжи" за цикл
        if self.generate_rpn:
            label_end = self.rpn_converter.generate_label()
            
            # Место для метки перехода
            jump_pos = len(self.rpn_converter.P)
            self.rpn_converter.put_lex(0, 0)
            self.rpn_converter.add_waiting_label(jump_pos, label_end)
            # Условный переход !F
            self.rpn_converter.put_lex(2, 26)  # !F

        if not self.expect(expected_value="do"):
            return

        # Тело цикла
        self.OPER()

        # Генерация ПОЛИЗа: безусловный переход в начало цикла
        if self.generate_rpn:
            
            # Ссылка на метку начала цикла
            self.rpn_converter.put_lex(0, 0)
            # Запоминаем позицию для заполнения
            jump_pos2 = len(self.rpn_converter.P) - 1
            self.rpn_converter.add_waiting_label(jump_pos2, label_start)
            
            self.rpn_converter.put_lex(2, 25)  # ! (безусловный переход)

            # Устанавливаем позицию конца цикла
            self.rpn_converter.set_label_position(label_end, len(self.rpn_converter.P)+1)

        self.dprint("ЗАВЕРШЕН ЦИКЛ WHILE", level="RULE_SUCCESS")

    def READ(self):
        if not self.expect(expected_value="read"):
            return

        self.dprint("ОБРАБОТКА ОПЕРАТОРА ВВОДА", level="RULE")

        if not self.expect(expected_value="("):
            return

        # Первый идентификатор
        if self.current and self.current[0] == "IDENTIFIER":
            identifier_name = self.current[1]

            # Генерация ПОЛИЗа: адрес переменной и операция R
            if self.generate_rpn:
                self.rpn_converter.put_l5(identifier_name)
                self.rpn_converter.put_lex(2, self.rpn_converter.special_operators["~"])

            # Проверяем описанность идентификатора
            if not self.semantic_analyzer.is_identifier_described(identifier_name):
                self.semantic_analyzer.add_error(
                    f"Идентификатор '{identifier_name}' не описан"
                )

            self.gl()
        else:
            self.err_proc("Ожидается идентификатор в read")
            return

        # Дополнительные идентификаторы
        while self.EQ(expected_value=","):
            self.dprint("ОБНАРУЖЕНА ЗАПЯТАЯ В READ", level="RULE")
            self.gl()
            if self.current and self.current[0] == "IDENTIFIER":
                identifier_name = self.current[1]

                # Генерация ПОЛИЗа для дополнительного идентификатора
                if self.generate_rpn:
                    self.rpn_converter.put_l5(identifier_name)
                    self.rpn_converter.put_lex(
                        2, self.rpn_converter.special_operators["~"]
                    )

                if not self.semantic_analyzer.is_identifier_described(identifier_name):
                    self.semantic_analyzer.add_error(
                        f"Идентификатор '{identifier_name}' не описан"
                    )

                self.gl()
            else:
                self.err_proc("Ожидается идентификатор после ',' в read")
                return

        if not self.expect(expected_value=")"):
            return

        self.dprint("ЗАВЕРШЕН ОПЕРАТОР ВВОДА", level="RULE_SUCCESS")

    def WRITE(self):
        if not self.expect(expected_value="write"):
            return

        self.dprint("ОБРАБОТКА ОПЕРАТОРА ВЫВОДА", level="RULE")

        if not self.expect(expected_value="("):
            return

        # Первое выражение
        self.EXPR()

        # СЕМАНТИЧЕСКИЙ АНАЛИЗ: проверяем write и очищаем стек
        self.semantic_analyzer.process_write_statement()

        # Генерация ПОЛИЗа: операция W
        if self.generate_rpn:
            self.rpn_converter.put_lex(2, self.rpn_converter.special_operators["$"])

        # Дополнительные выражения
        while self.EQ(expected_value=","):
            self.dprint("ОБНАРУЖЕНА ЗАПЯТАЯ В WRITE", level="RULE")
            self.gl()
            self.EXPR()

            # СЕМАНТИЧЕСКИЙ АНАЛИЗ: проверяем каждое выражение write
            self.semantic_analyzer.process_write_statement()

            # Генерация ПОЛИЗа для дополнительного выражения
            if self.generate_rpn:
                self.rpn_converter.put_lex(2, self.rpn_converter.special_operators["$"])

        if not self.expect(expected_value=")"):
            return

        self.dprint("ЗАВЕРШЕН ОПЕРАТОР ВЫВОДА", level="RULE_SUCCESS")

    def EXPR(self, put=True):
        """Разбор выражения: <логическое_выражение>"""
        self.dprint("ВХОД В ВЫРАЖЕНИЕ (EXPR)", level="RULE")
        result = None
        # Вызываем RELATION для разбора отношений (x >= 10, x <= 20, x = 15)
        result = self.RELATION(put) if result is None else result

        # Затем обрабатываем логические операции между отношениями
        while self.is_logicop():
            op_value = self.tok_text()
            self.dprint(f"ОБНАРУЖЕНА ЛОГИЧЕСКАЯ ОПЕРАЦИЯ: '{op_value}'", level="RULE")
            self.gl()  # Пропускаем оператор
            result = self.RELATION(put) if result is None else result

            # Генерация ПОЛИЗа: логическая операция
            if self.generate_rpn:
                op_code = self.table_manager.operators_table.get(op_value)
                if op_code:
                    self.rpn_converter.put_lex(2, op_code)

            # Семантический анализ логической операции
            self.semantic_analyzer.process_operation(op_value)

        self.dprint("ВЫХОД ИЗ ВЫРАЖЕНИЯ (EXPR)", level="RULE_SUCCESS")
        return result

    def LOGIC(self, put=True):
        """Разбор логического выражения: <отношение> {and|or <отношение>}"""
        self.dprint("ВХОД В ЛОГИЧЕСКОЕ ВЫРАЖЕНИЕ (LOGIC)", level="RULE")
        result = None
        result = self.RELATION(put) if result is None else result

        while self.is_logicop():
            op_value = self.tok_text()
            self.dprint(f"ОБНАРУЖЕНА ЛОГИЧЕСКАЯ ОПЕРАЦИЯ: '{op_value}'", level="RULE")
            self.gl()  # Пропускаем оператор
            result = self.RELATION(put) if result is None else result

            # Генерация ПОЛИЗа: логическая операция
            if self.generate_rpn:
                op_code = self.table_manager.operators_table.get(op_value)
                if op_code:
                    self.rpn_converter.put_lex(2, op_code)

            # Семантический анализ логической операции
            self.semantic_analyzer.process_operation(op_value)

        self.dprint("ВЫХОД ИЗ ЛОГИЧЕСКОГО ВЫРАЖЕНИЯ (LOGIC)", level="RULE_SUCCESS")
        return result

    def RELATION(self, put=True):
        """Разбор отношения: <операнд> {<операции_отношения> <операнд>}"""
        self.dprint("ВХОД В ОТНОШЕНИЕ (RELATION)", level="RULE")
        result = None
        result = self.OPERAND(put) if result is None else result

        while self.is_relop():
            op_value = self.tok_text()
            self.dprint(f"ОБНАРУЖЕНА ОПЕРАЦИЯ ОТНОШЕНИЯ: '{op_value}'", level="RULE")
            self.gl()  # Пропускаем оператор отношения
            result = self.OPERAND(put) if result is None else result

            # Генерация ПОЛИЗа: операция отношения
            if self.generate_rpn:
                op_code = self.table_manager.operators_table.get(op_value)
                if op_code:
                    self.rpn_converter.put_lex(2, op_code)

            # Семантический анализ операции сравнения
            self.semantic_analyzer.process_operation(op_value)

        self.dprint("ВЫХОД ИЗ ОТНОШЕНИЯ (RELATION)", level="RULE_SUCCESS")
        return result

    def OPERAND(self, put=True):
        """Разбор операнда: <слагаемое> {<операции_сложения> <слагаемое>}"""
        self.dprint("ВХОД В ОПЕРАНД (OPERAND)", level="RULE")
        result = None
        result = self.SUMM(put) if result is None else result

        while self.is_addop():
            op_value = self.tok_text()
            self.dprint(f"ОБНАРУЖЕНА ОПЕРАЦИЯ СЛОЖЕНИЯ: '{op_value}'", level="RULE")
            self.gl()  # Пропускаем оператор сложения
            result = self.SUMM(put) if result is None else result

            # Генерация ПОЛИЗа: операция сложения/вычитания
            if self.generate_rpn:
                op_code = self.table_manager.operators_table.get(op_value)
                if op_code:
                    self.rpn_converter.put_lex(2, op_code)

            # Семантический анализ операции сложения/вычитания
            self.semantic_analyzer.process_operation(op_value)

        self.dprint("ВЫХОД ИЗ ОПЕРАНДА (OPERAND)", level="RULE_SUCCESS")
        return result

    def SUMM(self, put=True):
        """Разбор слагаемого: <множитель> {<операции_умножения> <множитель>}"""
        self.dprint("ВХОД В СЛАГАЕМОЕ (SUMM)", level="RULE")
        result = None
        result = self.MULT(put) if result is None else result

        # ИЗМЕНЕНО: убрана проверка is_mulop() для "and"
        while self.is_mulop():
            op_value = self.tok_text()
            # ДОБАВЛЕНО: пропускаем "and" и "or" - они обрабатываются в LOGIC
            if op_value in ["and", "or"]:
                break

            self.dprint(f"ОБНАРУЖЕНА ОПЕРАЦИЯ УМНОЖЕНИЯ: '{op_value}'", level="RULE")
            self.gl()  # Пропускаем оператор умножения
            result = self.MULT(put) if result is None else result

            # Генерация ПОЛИЗа: операция умножения/деления
            if self.generate_rpn:
                op_code = self.table_manager.operators_table.get(op_value)
                if op_code:
                    self.rpn_converter.put_lex(2, op_code)

            # Семантический анализ операции умножения/деления
            self.semantic_analyzer.process_operation(op_value)

        self.dprint("ВЫХОД ИЗ СЛАГАЕМОГО (SUMM)", level="RULE_SUCCESS")
        return result

    def MULT(self, put=True):
        """Разбор множителя"""
        result = None
        self.dprint("ВХОД В МНОЖИТЕЛЬ (MULT)", level="RULE")
        tv = self.tok_text()

        if tv == "(":
            self.dprint("ОБНАРУЖЕНА ОТКРЫВАЮЩАЯ СКОБКА", level="RULE")
            self.gl()
            self.EXPR()
            if not self.expect(expected_value=")"):
                return result
            self.dprint("ЗАКРЫТИЕ СКОБКИ", level="RULE_SUCCESS")
            return result

        if tv == "not":
            self.dprint("ОБНАРУЖЕНА УНАРНАЯ ОПЕРАЦИЯ 'not'", level="RULE")
            self.gl()
            result = self.MULT(put) if result is None else result

            # Генерация ПОЛИЗа: унарная операция not
            if self.generate_rpn:
                op_code = self.table_manager.operators_table.get("not")
                if op_code:
                    if put:
                        self.rpn_converter.put_lex(2, op_code)
                    else:
                        result = (2, op_code)

            # Семантический анализ операции NOT
            self.semantic_analyzer.process_unary_operation("not")
            return result

        if self.current and self.current[0] == "IDENTIFIER":
            identifier_name = self.current[1]
            self.dprint(f"ОБНАРУЖЕН ИДЕНТИФИКАТОР: '{identifier_name}'", level="RULE")

            # Генерация ПОЛИЗа: значение переменной (таблица 4)
            if self.generate_rpn:
                info = self.table_manager.get_identifier_info(identifier_name)
                if info:
                    if put:
                        self.rpn_converter.put_lex(4, info["index"])
                    else:
                        result = (4, info["index"])

            # Семантический анализ
            self.semantic_analyzer.process_identifier(identifier_name)
            self.gl()
            return result

        if self.current and self.current[0] == "CONSTANT":
            constant_value = self.current[1]
            self.dprint(f"ОБНАРУЖЕНА КОНСТАНТА: '{constant_value}'", level="RULE")

            # Генерация ПОЛИЗа: константа (таблица 3)
            if self.generate_rpn:
                const_index = self.table_manager.constants_table.get(constant_value)
                if const_index:
                    self.rpn_converter.put_lex(3, const_index)

            # Семантический анализ
            self.semantic_analyzer.process_constant(constant_value)
            self.gl()
            return result

        if tv in ("true", "false"):
            self.dprint(f"ОБНАРУЖЕНА ЛОГИЧЕСКАЯ КОНСТАНТА: '{tv}'", level="RULE")

            # Генерация ПОЛИЗа: логическая константа (таблица 1)
            if self.generate_rpn:
                kw_code = self.table_manager.keywords_table.get(tv)
                if kw_code:
                    self.rpn_converter.put_lex(1, kw_code)

            # Семантический анализ
            self.semantic_analyzer.process_constant(tv)
            self.gl()
            return result

        self.err_proc("Ожидается идентификатор, константа, 'not' или '('")
        self.sync()

    def is_relop(self):
        tv = self.tok_text()
        return tv in (">", "<", "=", "<=", ">=", "<>")

    def is_addop(self):
        tv = self.tok_text()
        # ИЗМЕНЕНО: убрано "or" - оно логическая операция
        return tv in ("+", "-")

    def is_mulop(self):
        tv = self.tok_text()
        # ИЗМЕНЕНО: убраны "and" и "or" - они логические операции
        return tv in ("*", "/")

    def is_logicop(self):
        tv = self.tok_text()
        return tv in ("and", "or")

    # Служебные методы
    def _pos(self):
        return self.current[2] if self.current else "EOF"

    def gl(self):
        self.position += 1
        self.current = (
            self.tokens[self.position] if self.position < len(self.tokens) else None
        )
        return self.current

    def tok_text(self):
        if not self.current:
            return None
        typ, val, *_ = self.current
        if isinstance(val, str):
            return val.lower()
        return str(val).lower()

    def tok_after_newline(self, token=None):
        t = token if token is not None else self.current
        if not t:
            return False
        if len(t) >= 4:
            return bool(t[3])
        return False

    def EQ(self, expected_type=None, expected_value=None):
        if self.current is None:
            return False
        if expected_type and self.current[0] != expected_type:
            return False
        if expected_value is not None:
            tv = self.tok_text()
            return tv == expected_value.lower() if tv is not None else False
        return True

    def expect(self, expected_type=None, expected_value=None, msg=None):
        if self.EQ(expected_type, expected_value):
            self.gl()
            return True
        got = (self.current[0], self.tok_text()) if self.current else ("EOF", "EOF")
        if msg is None:
            exp = expected_value if expected_value is not None else expected_type
            msg = f"Ожидалось {exp}, но найдено {got[1]} (тип {got[0]})"
        self.err_proc(msg)
        self.sync()
        return False

    def err_proc(self, message):
        position = self._pos()
        full = f"Синтаксическая ошибка на позиции {position}: {message}"
        self.errors.append(full)
        self.dprint(f"ОШИБКА: {message}", level="ERROR")

    def sync(self):
        sync_tokens = {";", "}", "]", "else", "then", "do", ":", ","}
        self.dprint("ВХОД В СИНХРОНИЗАЦИЮ", level="SYNC")

        # Пропускаем текущий проблемный токен
        if self.current:
            self.dprint(f"Пропускаем проблемный токен: {self.current}", level="SYNC")
            self.gl()

        while self.current:
            tv = self.tok_text()
            if tv in sync_tokens:
                self.dprint(f"СИНХРОНИЗАЦИЯ НАЙДЕНА НА: '{tv}'", level="SYNC")
                # НЕ пропускаем синхронизирующий токен - он будет обработан вызывающим кодом
                break
            if tv in ("dim", "if", "for", "while", "read", "write", "["):
                self.dprint(
                    f"СИНХРОНИЗАЦИЯ НАЙДЕНА НА КЛЮЧЕВОМ СЛОВЕ: '{tv}'", level="SYNC"
                )
                break
            # Продолжаем пропускать токены до синхронизации
            self.dprint(f"Пропускаем токен: {self.current}", level="SYNC")
            self.gl()

        self.dprint(f"ЗАВЕРШЕНИЕ СИНХРОНИЗАЦИИ НА: {self.current}", level="SYNC")