.gitignore

@@ -4,6 +4,4 @@
 /build_temp
 /DebugVarEdit_GUI.build
 /DebugVarEdit_GUI.dist
-/DebugVarEdit_GUI.onefile-build
+/DebugVarEdit_GUI.onefile-build
-/parse_xml/build/
-/parse_xml/Src/__pycache__/

README.md

@@ -1,11 +1,4 @@
 # DebugTools - Просмотр переменных по указателям
-## Содержание
-1. [Описание модуля](#программный-модуль-debugtools)
-2. [Описание приложения для настройки](#debugvaredit---настройка-переменных)
-3. [Описание терминалки для считывания](#debugvarterminal---считывание-переменных-для-tms)
-4. [Для разработчиков](#для-разработчиков)
-
-# Программный модуль DebugTools
 Модуль состоит из трех файлов:
 - **debug_tools.c** - реализация считывания переменных
 - **debug_tools.h** - объявление всякого для считывания переменных
@@ -16,26 +9,11 @@
 Для чтения переменных можно использовать функции:
 
 ```c
-/* Читает значение переменной по индексу */
 int Debug_ReadVar(int var_ind, int32_t *return_long);
-/* Читает имя переменной по индексу */
+int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr);
-int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr, int *length);
-/* Читает возвращаемый тип (IQ) переменной по индексу */
-int Debug_ReadVarReturnType(int var_ind, int *vartype);
-/* Читает тип переменной по индексу */
-int Debug_ReadVarType(int var_ind, int *vartype);
-
-
-/* Читает значение переменной с нижнего уровня */
-int Debug_LowLevel_ReadVar(int32_t *return_long);
-/* Инициализирует отладку нижнего уровня */
-int Debug_LowLevel_Initialize(DateTime_t *external_date);
-/* Читает возвращаемый тип (IQ) низкоуровнено заданной переменной */
-int Debug_LowLevel_ReadVarReturnType(int *vartype);
-/* Читает тип низкоуровнено заданной переменной.*/
-int Debug_LowLevel_ReadVarType(int *vartype);
 ```
 
+
 Переменные доступные для чтения определяются в **debug_vars.c** (их можно прописывать вручную или генерировать через **DebugVarEdit**):
 
 ```c
@@ -54,26 +32,6 @@ DebugVar_t dbg_vars[] = {\
 };
 ```
 
-## LowLevel - Просмотр абсолютно любых переменных
-Также присутствует утилита `parse_xml.exe`, которая генерирует `.xml` файл с всеми переменными в программе и их адрессами
-Для её подключения:
--  В Pre-Build Steps добавить следующую команду. Это удаление `debug_tools.obj` файла для его перекомпиялции с актуальной датой компиляции
-``` 
-cmd /c del /Q "${CWD}\Src\DebugTools\debug_tools.obj" 
-```
--  В Post-Build Steps добавить следующую команду. Это:
-    - формирование с помощью утилиты компилятора `ofd2000` `.xml` файла с полной отладочной информацией.
-    - формирование отладочной информации в текстовом файле (для получения таймштампа)  
-    - запуск утилиты `parse_xml.exe` для формирования итогового `<projname>_allVars.xml` с информацией о переменных и адресах
-
-``` 
-"${CG_TOOL_ROOT}/bin/ofd2000" --obj_display=symbols --dwarf --dwarf_display=all --xml --xml_indent=1 --output="${BuildArtifactFileBaseName}_ofd_dump.xml" "${BuildArtifactFilePath}"
-"${CG_TOOL_ROOT}/bin/ofd2000" "${BuildArtifactFilePath}" > ${CCS_PROJECT_DIR}/bin/temp.txt
-"${CCS_PROJECT_DIR}/Src/DebugTools/parse_xml/parse_xml.exe" ${BuildArtifactFileBaseName}_ofd_dump.xml ${CCS_PROJECT_DIR}/bin/temp.txt ${BuildArtifactFileBaseName}_allVars.xml" 
-```
-После, с использованием терминалки можно прочитать любые переменные по адресам. (должен совпадать таймштапм в прошивке и `.xml` файла, иначе контроллер ответит ошибкой)
-
-
 # DebugVarEdit - Настройка переменных
 **DebugVarEdit** — графическое приложение для Windows, предназначенное для настройки и генерации отладочных переменных (`debug_vars.c`) на основе исходного C-проекта. Работает с `makefile` проекта, сохраняет изменения в XML и позволяет удобно редактировать переменные и их типы через интерфейс.
 
@@ -155,68 +113,6 @@ cmd /c del /Q "${CWD}\Src\DebugTools\debug_tools.obj"
 ```
 
 ---
-
-
-# DebugVarTerminal - Считывание переменных (для TMS)
-**DebugVarTerminal** — терминалка для считывания переменных по RS-232 протоколу RS_Functions.
-Программа — один исполняемый файл `DebugVarTerminal.exe`, не требующий установки и дополнительных зависимостей.
-> Требуется Windows 7 или новее.
-
----
-
-## Как использовать приложение
-
-1. Запустите **DebugVarTerminal.exe.**
-
-2. Выберите COM Port и скорость Baud. Нажмиите **Open**
-
-3. Для считывания переменных заданных в `*debug_vars.c`:
-   - Откройте вкладку **Watch**.
-   - Выберите стартовый индекс переменной и количество переменных для считывания.
-   - Нажмите одну из кнопок:
-      - **Update Service** - считывает информацию об именах и возвращаемых IQ типах переемнных
-      - **Read Value(s)** - считывает и форматирует значения переменных в соответствии с IQ типами
-      - **Start Polling** - начать опрос выбранных переменных с заданным интервалом. При старте опроса, имя и тип переменных считываются автоматически
-
-4. Для считывания переменных по адресам:
-   - Откройте вкладку **LowLevel**.
-   - Выберите `projname_allVars.xml` в папке bin рядом с бинарником. Из него подгрузятся все доступные для считывания переменные
-   - Выберите переменные кнопкной **Выбрать переменные**
-   - Задайте IQ тип и возвращаемый IQ тип если требуется
-   - Нажмите одну из кнопок:
-      - **Read Once** - считывает выбранные переменные один раз
-      - **Start Polling** - начать опрос выбранных переменных с заданным интервалом
-
-5. Запись в CSV:
-   - Можно записывавать считываемые переменные в CSV файл, с разделителем `;`
-   - Нажмите кнопку **Начать запись в CSV**
-   - Когда нужная выборка будет накоплена нажмите **Остаовить запись в CSV**
-   - Нажмите **Выбрать файл CSV** для выбора пути для сохранения файла и нажмите **Сохранить данные в CSV** чтобы сохранить
-   - Генерируется совместимый с LogView `.csv` файл
-
-   Все параметры выбираются из выпадающих списков, которые можно настроить, чтобы отображались только нужные опции.
-
----
-
-## Возможности
-Режим "Watch":
-- Быстрое и удобное чтение одной или нескольких переменных по их индексу.
-- Автоматическое получение имен, типов и параметров масштабирования (IQ) переменных.
-- Запуск постоянного опроса для отслеживания изменений значений в реальном времени.
-- Наглядное представление данных в таблице с отображением как сырых, так и масштабированных значений.
-Режим "LowLevel":
-- Прямое чтение данных из памяти по заданным адресам.
-- Возможность указания типов указателей, IQ-масштабирования и форматов возвращаемых данных.
-- Аналогично режиму "Watch", поддерживается постоянный опрос выбранных низкоуровневых переменных.
-- Умное автодополнение имён переменных и полей структур.
-Логирование в CSV
-- Записывайте все полученные значения в файл формата CSV для последующего анализа.
-- Легкое управление записью: запуск, остановка и сохранение данных в любой момент.
-
----
-
-
-
 ---
 
 # Для разработчиков
@@ -226,25 +122,19 @@ cmd /c del /Q "${CWD}\Src\DebugTools\debug_tools.obj"
 ```bash
 Src
 ├── build/
-│   └── build_and_clean.py	  # Билдинг проекта в .exe (через nuitka или pyinstaller)
+│   └── build_and_clean.py	# Билдинг проекта в .exe (через nuitka или pyinstaller)
-├── DebugVarEdit_GUI.py       # Главное окно
+├── DebugVarEdit_GUI.py     # Главное окно
-├── tms_debugvar_term.py      # Терминал DebugVarTerminal
+├── var_table.py        	# Таблица выбранных переменных
-├── tms_debugvar_lowlevel.py  # Виджет для выбора переменных для LowLevel Watch
+├── var_selector_window.py 	# Окно выбора переменных
-├── var_table.py        	    # Таблица выбранных переменных
+├── var_selector_table.py  	# Таблица переменных в окне выбора переменных
-├── var_selector_window.py 	  # Окно выбора переменных
+├── scan_progress_gui.py   	# Отображение процесса сканирования переменных 
-├── var_selector_table.py  	  # Таблица переменных в окне выбора переменных
+├── scan_vars.py           	# Сканирование переменных среди .c/.h файлов
-├── scan_progress_gui.py   	  # Отображение процесса сканирования переменных 
+├── generate_debug_vars.py 	# Генерация debug_vars.c
-├── scan_vars.py           	  # Сканирование переменных среди .c/.h файлов
+├── myXML.py                # Утилиты для XML
-├── generate_debug_vars.py 	  # Генерация debug_vars.c
+├── makefile_parser.py     	# Парсинг makefile на .c/.h файлы
-├── allvars_xml_parser.py     # Парсинг XML со всеми переменными и структурами
+├── var_setup.py            # Подготовка переменных для окна выбора переменных
-├── csv_logger.py             # Логирование переменных в CSV
+├── libclang.dll            # Бибилиотека clang
-├── myXML.py                  # Утилиты для XML
+├── icon.ico                # Иконка
-├── makefile_parser.py     	  # Парсинг makefile на .c/.h файлы
-├── var_setup.py              # Подготовка переменных для окна выбора переменных
-├── path_hints.py             # Подсказки для автодополнения путей переменных
-├── libclang.dll              # Бибилиотека clang
-├── icon.ico                  # Иконка
-
 ```
 
 ### Зависимости
@@ -271,7 +161,7 @@ Src
 - Очищает временные папки после сборки:
   - `build_temp`
   - `__pycache__`
-  - `<MAIN_SCRIPT_NAME>.*`
+  - `DebugVarEdit_GUI.*`
 
 > Все пути, имена файлов, временные папки и выбор между Nuitka и PyInstaller можно настроить в начале файла `build_and_clean.py`.
 

Src/DebugVarEdit_GUI.py

@@ -7,7 +7,6 @@ import subprocess
 import lxml.etree as ET
 from generate_debug_vars import type_map, choose_type_map
 from enum import IntEnum
-from tms_debugvar_term import _DemoWindow
 import threading
 from generate_debug_vars import run_generate
 import var_setup
@@ -18,7 +17,6 @@ import scan_vars
 import myXML
 import time
 
-
 from PySide2.QtWidgets import (
     QApplication, QWidget, QTableWidget, QTableWidgetItem,
     QCheckBox, QComboBox, QLineEdit, QVBoxLayout, QHBoxLayout, QPushButton,
@@ -150,18 +148,7 @@ class VarEditor(QWidget):
         self.target_menu.addAction(self.action_tms)
         self.target_menu.addAction(self.action_stm)
 
-        self.terminal_menu = QMenu("Открыть Терминал", menubar)
-        
-        self.action_terminal_tms = QAction("TMS DemoTerminal", self)
-        self.action_terminal_modbus = QAction("Modbus DemoTerminal", self)
-        self.action_terminal_tms.triggered.connect(lambda: self.open_terminal("TMS"))
-        self.action_terminal_modbus.triggered.connect(lambda: self.open_terminal("MODBUS"))
-
-        self.terminal_menu.addAction(self.action_terminal_tms)
-        #self.terminal_menu.addAction(self.action_terminal_modbus)
-
         menubar.addMenu(self.target_menu)
-        menubar.addMenu(self.terminal_menu)
 
         # Кнопка сохранения
         btn_save = QPushButton(build_title)
@@ -192,40 +179,6 @@ class VarEditor(QWidget):
         self.setLayout(layout)
 
 
-    def open_terminal(self, target):
-        target = target.lower()
-        
-        if target == "tms":
-            exe_name = "DebugVarTerminal.exe"
-            # Путь к exe в текущей директории запуска программы
-            exe_path = os.path.join(os.getcwd(), exe_name)
-            
-            if not os.path.isfile(exe_path):
-                # Файл не найден — попросим пользователя выбрать путь к exe
-                msg = QMessageBox()
-                msg.setIcon(QMessageBox.Warning)
-                msg.setWindowTitle("Файл не найден")
-                msg.setText(f"Файл {exe_name} не найден в текущей папке.\nВыберите путь к {exe_name}.")
-                msg.exec_()
-                
-                # Открываем диалог выбора файла
-                selected_path, _ = QFileDialog.getOpenFileName(
-                    None, "Выберите файл " + exe_name, os.getcwd(), "Executable Files (*.exe)"
-                )
-                
-                if not selected_path:
-                    # Пользователь отменил выбор — ничего не делаем
-                    return
-                
-                exe_path = selected_path
-            
-            # Запускаем exe (отдельное окно терминала)
-            subprocess.Popen([exe_path], creationflags=subprocess.CREATE_NEW_CONSOLE)
-            
-        elif target == "modbus":
-            a = 1
-
-        
     def on_target_selected(self, target):
         self.target_menu.setTitle(f'МК: {target}')
         self.settings.setValue("mcu_choosen", target)

Src/README_DEVELOP.md

@@ -1,4 +1,3 @@
-
 # Для разработчиков
 
 ### Структура проекта:
@@ -6,39 +5,33 @@
 ```bash
 Src
 ├── build/
-│   └── build_and_clean.py	  # Билдинг проекта в .exe (через nuitka или pyinstaller)
+│   └── build_and_clean.py	# Билдинг проекта в .exe (через nuitka или pyinstaller)
-├── DebugVarEdit_GUI.py       # Главное окно
+├── DebugVarEdit_GUI.py     # Главное окно
-├── tms_debugvar_term.py      # Терминал DebugVarTerminal
+├── var_table.py        	# Таблица выбранных переменных
-├── tms_debugvar_lowlevel.py  # Виджет для выбора переменных для LowLevel Watch
+├── var_selector_window.py 	# Окно выбора переменных
-├── var_table.py        	    # Таблица выбранных переменных
+├── var_selector_table.py  	# Таблица переменных в окне выбора переменных
-├── var_selector_window.py 	  # Окно выбора переменных
+├── scan_progress_gui.py   	# Отображение процесса сканирования переменных 
-├── var_selector_table.py  	  # Таблица переменных в окне выбора переменных
+├── scan_vars.py           	# Сканирование переменных среди .c/.h файлов
-├── scan_progress_gui.py   	  # Отображение процесса сканирования переменных 
+├── generate_debug_vars.py 	# Генерация debug_vars.c
-├── scan_vars.py           	  # Сканирование переменных среди .c/.h файлов
+├── myXML.py                # Утилиты для XML
-├── generate_debug_vars.py 	  # Генерация debug_vars.c
+├── makefile_parser.py     	# Парсинг makefile на .c/.h файлы
-├── allvars_xml_parser.py     # Парсинг XML со всеми переменными и структурами
+├── var_setup.py            # Подготовка переменных для окна выбора переменных
-├── csv_logger.py             # Логирование переменных в CSV
+├── libclang.dll            # Бибилиотека clang
-├── myXML.py                  # Утилиты для XML
+├── icon.ico                # Иконка
-├── makefile_parser.py     	  # Парсинг makefile на .c/.h файлы
-├── var_setup.py              # Подготовка переменных для окна выбора переменных
-├── path_hints.py             # Подсказки для автодополнения путей переменных
-├── libclang.dll              # Бибилиотека clang
-├── icon.ico                  # Иконка
-
 ```
 
 ### Зависимости
 
 Для запуска приложения:
 - **Python 3.7+**
-- **clang** — используется для парсинга C-кода (требуется `libclang.dll`, лежит в папке Src)
+- **clang** — используется для парсинга C-кода (требуется `libclang.dll`)
 - **PySide2** — GUI-фреймворк
 - **lxml** — работа с XML
 > Python 3.7 и PySide2 рекомендуется для совместимости с Windows 7
 
 Для сборки `.exe`:
 - **Nuitka** — создает полностью автономный `.exe` без внешних зависимостей
-- **PyInstaller** — создает `.exe` с зависимостью от `pythonXX.dll` (Python должен быть установлен для запуска `.exe`)
+- **PyInstaller** — создает `.exe` с зависимостью от `pythonXX.dll` (Python должен быть установлен)
 
 
 ### Сборка:
@@ -51,12 +44,12 @@ Src
 - Очищает временные папки после сборки:
   - `build_temp`
   - `__pycache__`
-  - `<MAIN_SCRIPT_NAME>.*`
+  - `DebugVarEdit_GUI.*`
 
 > Все пути, имена файлов, временные папки и выбор между Nuitka и PyInstaller можно настроить в начале файла `build_and_clean.py`.
 
 ### Установка зависимостей
 
 ```bash
-pip install clang PySide2 lxml nuitka pyinstaller
+pip install PySide2 lxml nuitka pyinstaller
 ```

Src/allvars_xml_parser.py

@@ -1,500 +0,0 @@
-"""
-VariablesXML + get_all_vars_data
----------------------------------
-Поддержка вложенных структур, указателей на структуры ("->"),
-и многомерных массивов (индексация [i][j]...).
-
-Требования пользователя:
-- size  (без индекса) = общий размер массива в байтах (НЕ измерение!).
-- size1..sizeN        = размеры измерений массива.
-- В результирующем плоском списке (flattened) должны присутствовать ВСЕ промежуточные
-  пути: var, var[0], var[0][0], var[0][0].field, var[0][0].field->subfield, ...
-- Аналогично для членов структур.
-
-Пример желаемого формата:
-    project
-    project.adc
-    project.adc[0]
-    project.adc[0][0]
-    project.adc[0][0].bus
-    project.adc[0][0].bus->status
-
-Данный модуль реализует:
-- Разбор XML (parse) с извлечением размеров размерностей в поле `dims`.
-- Генерацию плоского списка словарей `flattened()`.
-- Построение иерархии словарей `get_all_vars_data()`.
-
-"""
-
-from __future__ import annotations
-
-import re
-import xml.etree.ElementTree as ET
-from dataclasses import dataclass, field
-from typing import List, Dict, Optional, Tuple, Any
-
-import var_setup  # ожидается split_path(...)
-from generate_debug_vars import choose_type_map, type_map  # используется для выбора карт типов
-
-# --------------------------- константы ----------------------------
-
-DATE_FIELD_SET = {"year", "month", "day", "hour", "minute"}
-
-# --------------------------- dataclasses --------------------------
-
-@dataclass
-class MemberNode:
-    name: str
-    offset: int = 0
-    type_str: str = ""
-    size: Optional[int] = None                # общий размер (байты), если известен
-    children: List["MemberNode"] = field(default_factory=list)
-    # --- доп.поля ---
-    kind: Optional[str] = None                # 'array', 'union', ...
-    dims: Optional[List[int]] = None
-
-    def is_date_struct(self) -> bool:
-        if not self.children:
-            return False
-        child_names = {c.name for c in self.children}
-        return DATE_FIELD_SET.issubset(child_names)
-
-
-@dataclass
-class VariableNode:
-    name: str
-    address: int
-    type_str: str
-    size: Optional[int]
-    members: List[MemberNode] = field(default_factory=list)
-    # --- доп.поля ---
-    kind: Optional[str] = None                # 'array'
-    dims: Optional[List[int]] = None          # полный список размеров [size1, size2, ...]
-
-    def base_address_hex(self) -> str:
-        return f"0x{self.address:06X}"
-
-
-# --------------------------- класс парсера -----------------------
-
-class VariablesXML:
-    """
-    Читает XML и предоставляет методы:
-      - flattened(): плоский список всех путей.
-      - date_struct_candidates(): как раньше.
-
-    Правила формирования путей:
-      * Структурные поля: '.'
-      * Поля через указатель на структуру: '->'
-      * Массивы: [index] (каждое измерение).
-    """
-
-    # предполагаемые размеры примитивов (MCU: int=2)
-    _PRIM_SIZE = {
-        'char': 1, 'signed char': 1, 'unsigned char': 1,
-        'uint8_t': 1, 'int8_t': 1,
-        'short': 2, 'short int': 2, 'signed short': 2, 'unsigned short': 2,
-        'uint16_t': 2, 'int16_t': 2,
-        'int': 2, 'signed int': 2, 'unsigned int': 2,
-        'long': 4, 'unsigned long': 4, 'int32_t': 4, 'uint32_t': 4,
-        'float': 4,
-        'long long': 8, 'unsigned long long': 8, 'int64_t': 8, 'uint64_t': 8, 'double': 8,
-    }
-
-    def __init__(self, path: str):
-        self.path = path
-        self.timestamp: str = ""
-        self.variables: List[VariableNode] = []
-        choose_type_map(0)  # инициализация карт типов (если требуется)
-        self._parse()
-
-    # ------------------ утилиты ------------------
-
-    @staticmethod
-    def _parse_int_guess(txt: Optional[str]) -> Optional[int]:
-        if not txt:
-            return None
-        txt = txt.strip()
-        if txt.startswith(('0x', '0X')):
-            return int(txt, 16)
-        # если в строке есть A-F, попробуем hex
-        if any(c in 'abcdefABCDEF' for c in txt):
-            try:
-                return int(txt, 16)
-            except ValueError:
-                pass
-        try:
-            return int(txt, 10)
-        except ValueError:
-            return None
-
-    @staticmethod
-    def _is_pointer_to_struct(t: str) -> bool:
-        if not t:
-            return False
-        low = t.replace('\t', ' ').replace('\n', ' ')
-        return 'struct ' in low and '*' in low
-
-    @staticmethod
-    def _is_struct_or_union(t: str) -> bool:
-        if not t:
-            return False
-        low = t.strip()
-        return low.startswith('struct ') or low.startswith('union ')
-
-    @staticmethod
-    def _is_union(t: str) -> bool:
-        if not t:
-            return False
-        low = t.strip()
-        return low.startswith('union ')
-    
-    @staticmethod
-    def _strip_array_suffix(t: str) -> str:
-        t = t.strip()
-        while t.endswith('[]'):
-            t = t[:-2].strip()
-        return t
-
-    def _guess_primitive_size(self, type_str: str) -> Optional[int]:
-        if not type_str:
-            return None
-        base = type_str
-        for tok in ('volatile', 'const'):
-            base = base.replace(tok, '')
-        base = base.replace('*', ' ')
-        base = base.replace('[', ' ').replace(']', ' ')
-        base = ' '.join(base.split()).strip()
-        return self._PRIM_SIZE.get(base)
-
-    # ------------------ XML read ------------------
-
-    def _parse(self) -> None:
-        try:
-            tree = ET.parse(self.path)
-            root = tree.getroot()
-
-            ts = root.find('timestamp')
-            self.timestamp = ts.text.strip() if ts is not None and ts.text else ''
-
-            def parse_member(elem: ET.Element, base_offset=0) -> MemberNode: 
-                name = elem.get('name', '')
-                offset = int(elem.get('offset', '0'), 16) if elem.get('offset') else 0
-                t = elem.get('type', '') or ''
-                size_attr = elem.get('size')
-                size = int(size_attr, 16) if size_attr else None
-                kind = elem.get('kind')
-
-                abs_offset = base_offset + offset
-
-
-                # Собираем размеры, если есть
-                dims: List[int] = []
-                i = 1
-                while True:
-                    size_key = f"size{i}"
-                    size_val = elem.get(size_key)
-                    if size_val is None:
-                        break
-                    parsed = self._parse_int_guess(size_val)  # предполагается твоя функция парсинга int
-                    if parsed is not None:
-                        dims.append(parsed)
-                    i += 1
-
-                node = MemberNode(
-                    name=name,
-                    offset=abs_offset,
-                    type_str=t,
-                    size=size,
-                    kind=kind,
-                    dims=dims if dims else None,
-                )
-
-                # Для детей
-                for ch in elem.findall('member'):
-                    if kind == 'union':
-                        # Для union детей НЕ добавляем их offset, просто передаём abs_offset
-                        child = parse_member(ch, base_offset=abs_offset)
-                        child.offset = abs_offset  # выравниваем offset, игнорируем offset детей
-                    else:
-                        # Для struct/array суммируем offset нормально
-                        child = parse_member(ch, base_offset=abs_offset)
-                    node.children.append(child)
-
-                # Аналогично для pointee
-                pointee_elem = elem.find('pointee')
-                if pointee_elem is not None:
-                    for ch in pointee_elem.findall('member'):
-                        if kind == 'union':
-                            child = parse_member(ch, base_offset=abs_offset)
-                            child.offset = abs_offset
-                        else:
-                            child = parse_member(ch, base_offset=abs_offset)
-                        node.children.append(child)
-                    size_p = pointee_elem.get('size')
-                    if size_p:
-                        node.size = int(size_p, 16)
-
-                return node
-
-
-
-            for var in root.findall('variable'):
-                addr = int(var.get('address', '0'), 16)
-                name = var.get('name', '')
-                t = var.get('type', '') or ''
-                size_attr = var.get('size')  # общий размер байт
-                size = int(size_attr, 16) if size_attr else None
-                kind = var.get('kind')
-
-                dims: List[int] = []
-                i = 1
-                while True:
-                    key = f'size{i}'
-                    val = var.get(key)
-                    if val is None:
-                        break
-                    parsed = self._parse_int_guess(val)
-                    if parsed is not None:
-                        dims.append(parsed)
-                    i += 1
-
-                members = [parse_member(m) for m in var.findall('member')]
-
-                v = VariableNode(
-                    name=name,
-                    address=addr,
-                    type_str=t,
-                    size=size,
-                    members=members,
-                    kind=kind,
-                    dims=dims if dims else None,
-                )
-                self.variables.append(v)
-        except FileNotFoundError:
-            self.variables = []
-        except ET.ParseError:
-            self.variables = []
-
-    # ------------------ helpers для flattened ---------------------
-
-    def _elem_size_bytes(self, total_size: Optional[int], dims: List[int], base_type: str, members: List[MemberNode]) -> int:
-        """Оценка размера одного *листового* элемента (последнего измерения).
-        Если total_size и dims все известны — берём size / prod(dims).
-        Иначе — пробуем примитивный размер; иначе 1.
-        (Не учитываем выравнивание структур; при необходимости можно расширить.)
-        """
-        if total_size is not None and dims:
-            prod = 1
-            for d in dims:
-                if d is None or d == 0:
-                    prod = None
-                    break
-                prod *= d
-            if prod and prod > 0:
-                return max(1, total_size // prod)
-        prim = self._guess_primitive_size(base_type)
-        if prim:
-            return prim
-        # Если структура и у неё есть size по детям? Пока fallback=1.
-        return 1
-
-    # ------------------ flattened ------------------
-
-    def flattened(self, max_array_elems: Optional[int] = None) -> List[Dict[str, Any]]:
-        """Возвращает плоский список всех путей (каждый путь = dict).
-        Включает промежуточные узлы массивов (var[0], var[0][0], ...).
-        """
-        out: List[Dict[str, Any]] = []
-
-        def mk(name: str, addr: Optional[int], type_str: str, size: Optional[int], kind: Optional[str], dims_for_node: Optional[List[int]]):
-            if 'Bender' in name:
-                a=1
-            out.append({
-                'name': name,
-                'address': addr,
-                'type': type_str,
-                'size': size,
-                'kind': kind,
-                'dims': dims_for_node[:] if dims_for_node else None,
-            })
-            
-        def expand_members(prefix: str, base_addr: int, members: List[MemberNode], parent_is_ptr_struct: bool, parent_is_union: bool) -> None:
-            # Выбираем разделитель пути: '.' если обычный член, '->' если указатель на структуру
-            join = '->' if parent_is_ptr_struct else '.'
-
-            for m in members:
-                path_m = f"{prefix}{join}{m.name}" if prefix else m.name
-                is_union = m.kind == 'union' or parent_is_union
-                if is_union:
-                    # Все поля union начинаются с одного адреса
-                    addr_m = base_addr
-                else:
-                    addr_m = base_addr + m.offset
-
-                dims = m.dims or []
-
-                mk(path_m, addr_m, m.type_str, m.size, m.kind, dims)
-
-                if m.kind == 'array' and dims:
-                    base_t = self._strip_array_suffix(m.type_str)
-                    elem_sz = m.size
-
-                    # Для массива внутри структуры: первый уровень — '.' для доступа,
-                    # внутри массива раскрываем по обычной логике с parent_is_ptr_struct=False
-                    expand_dims(path_m, addr_m, dims, base_t, m.children, elem_sz, parent_is_ptr_struct=False)
-                else:
-                    if m.children:
-                        # Проверяем, является ли поле указателем на структуру
-                        is_ptr = self._is_pointer_to_struct(m.type_str)
-                        # Рекурсивно раскрываем дочерние поля, выбирая правильный разделитель
-                        expand_members(path_m, addr_m, m.children, is_ptr, is_union)
-
-
-        def expand_dims(name: str, base_addr: int, dims: List[int], base_type: str, children: List[MemberNode], elem_size: int, parent_is_ptr_struct: bool) -> None:
-            prods: List[int] = []
-            acc = 1
-            for d in reversed(dims[1:]):
-                acc *= (d if d else 1)
-                prods.append(acc)
-            prods.reverse()
-
-            def rec(k: int, cur_name: str, cur_addr: int) -> None:
-                if k == len(dims):
-                    # Листовой элемент массива
-                    mk(cur_name, cur_addr, base_type, elem_size, None, None)
-                    # Если элемент — структура или указатель на структуру, раскрываем вложения
-                    if children and self._is_struct_or_union(base_type):
-                        expand_members(cur_name, cur_addr, children, parent_is_ptr_struct=False, parent_is_union=self._is_union(base_type))
-                    elif self._is_pointer_to_struct(base_type):
-                        expand_members(cur_name, cur_addr, children, parent_is_ptr_struct=True, parent_is_union=self._is_union(base_type))
-                    return
-
-                dim_sz = dims[k] or 0
-                if max_array_elems is not None:
-                    dim_sz = min(dim_sz, max_array_elems)
-
-                stride = elem_size * prods[k] if k < len(prods) else elem_size
-                if len(dims) > 2:
-                    a=1
-                for i in range(dim_sz):
-                    child_name = f"{cur_name}[{i}]"
-                    child_addr = (cur_addr + i * stride) if cur_addr is not None else None
-                    remaining = dims[k+1:]
-                    mk(child_name, child_addr, base_type + '[]' * len(remaining), stride if remaining else elem_size, 'array' if remaining else None, remaining)
-                    rec(k + 1, child_name, child_addr)
-
-            rec(0, name, base_addr)
-
-
-        # --- цикл по топ‑левел переменным ---
-        for v in self.variables:
-            dims = v.dims or []
-            mk(v.name, v.address, v.type_str, v.size, v.kind, dims)
-            if (v.kind == 'array' or v.type_str.endswith('[]')) and dims:
-                base_t = self._strip_array_suffix(v.type_str)
-                elem_sz = v.size
-                expand_dims(v.name, v.address, dims, base_t, v.members, elem_sz, parent_is_ptr_struct=False)
-            else:
-                if v.members:
-                    is_ptr = self._is_pointer_to_struct(v.type_str)
-                    is_union = self._is_union(v.type_str)
-                    expand_members(v.name, v.address, v.members, is_ptr, is_union)
-
-        return out
-
-    # -------------------- date candidates (как раньше) -------------
-
-    def date_struct_candidates(self) -> List[Tuple[str, int]]:
-        cands = []
-        for v in self.variables:
-            # top level (if all date fields are present)
-            direct_names = {mm.name for mm in v.members}
-            if DATE_FIELD_SET.issubset(direct_names):
-                cands.append((v.name, v.address))
-            # check first-level members
-            for m in v.members:
-                if m.is_date_struct():
-                    cands.append((f"{v.name}.{m.name}", v.address + m.offset))
-        return cands
-
-
-    # ------------------------------------------------------------------
-    # Построение иерархического дерева из flattened()
-    # ------------------------------------------------------------------
-    def get_all_vars_data(self) -> List[Dict[str, Any]]:
-        """
-        Строит иерархию словарей из плоского списка переменных.
-
-        Каждый узел = {
-            'name': <полный путь>,
-            'address': <адрес или None>,
-            'type': <тип>,
-            'size': <байты>,
-            'kind': <'array' | ...>,
-            'dims': [size1, size2, ...] или None,
-            'children': [...список дочерних узлов]
-        }
-
-        Возвращает список корневых узлов (top-level переменных).
-        """
-        flat_data = self.flattened(max_array_elems=None)
-
-        # Быстрое отображение имя -> узел (словарь с детьми)
-        all_nodes: Dict[str, Dict[str, Any]] = {}
-        for item in flat_data:
-            node = dict(item)
-            node['children'] = []
-            all_nodes[item['name']] = node
-
-        def _parent_struct_split(path: str) -> Optional[str]:
-            # Ищем последний '.' или '->' для определения родителя
-            dot_idx = path.rfind('.')
-            arrow_idx = path.rfind('->')
-            cut_idx = max(dot_idx, arrow_idx)
-            if cut_idx == -1:
-                return None
-            # '->' занимает 2 символа, нужно взять срез до начала '->'
-            if arrow_idx > dot_idx:
-                return path[:arrow_idx]
-            else:
-                return path[:dot_idx]
-
-        def find_parent(path: str) -> Optional[str]:
-            """
-            Возвращает полный путь родителя, учитывая '.', '->' и индексы [] в конце.
-
-            Если путь заканчивается индексом [k], удаляет последний индекс и проверяет наличие родителя.
-            Иначе пытается найти последний сепаратор '.' или '->'.
-            """
-            # Если есть trailing индекс в конце, убираем его
-            m = re.search(r'\[[0-9]+\]$', path)
-            if m:
-                base = path[:m.start()]  # убираем последний [k]
-                # Если базовый путь есть в узлах, считаем его родителем
-                if base in all_nodes:
-                    return base
-                # Иначе пытаемся найти родителя от базового пути
-                return _parent_struct_split(base)
-            else:
-                # Если нет индекса, просто ищем последний разделитель
-                return _parent_struct_split(path)
-
-        # Строим иерархию: parent -> children
-        roots: List[Dict[str, Any]] = []
-        for full_name, node in all_nodes.items():
-            parent_name = find_parent(full_name)
-            if parent_name and parent_name in all_nodes:
-                all_nodes[parent_name]['children'].append(node)
-            else:
-                roots.append(node)
-
-        # Рекурсивно сортируем детей по имени для порядка
-        def sort_nodes(nodes: List[Dict[str, Any]]):
-            nodes.sort(key=lambda n: n['name'])
-            for n in nodes:
-                if n['children']:
-                    sort_nodes(n['children'])
-
-        sort_nodes(roots)
-        return roots

Src/build/build_and_clean.py

@@ -12,12 +12,10 @@ from PyInstaller.utils.hooks import collect_data_files
 
 # === Конфигурация ===
 USE_NUITKA = True  # True — сборка через Nuitka, False — через PyInstaller
-MAIN_SCRIPT_NAME = "tms_debugvar_term"
-OUTPUT_NAME = "DebugVarTerminal"
-
 
 SRC_PATH = Path("./Src/")
-SCRIPT_PATH = SRC_PATH / (MAIN_SCRIPT_NAME + ".py")
+SCRIPT_PATH = SRC_PATH / "DebugVarEdit_GUI.py"
+OUTPUT_NAME = "DebugVarEdit"
 
 DIST_PATH = Path("./").resolve()
 WORK_PATH = Path("./build_temp").resolve()
@@ -28,9 +26,9 @@ ICON_ICO_PATH = SRC_PATH / "icon.ico"
 TEMP_FOLDERS = [
     "build_temp",
     "__pycache__",
-    MAIN_SCRIPT_NAME + ".build",
+    "DebugVarEdit_GUI.build",
-    MAIN_SCRIPT_NAME + ".onefile-build",
+    "DebugVarEdit_GUI.onefile-build",
-    MAIN_SCRIPT_NAME + ".dist"
+    "DebugVarEdit_GUI.dist"
 ]
 # === Пути к DLL и прочим зависимостям ===
 LIBS = {

Src/csv_logger.py

@@ -1,224 +0,0 @@
-import csv
-import numbers
-import time
-from datetime import datetime
-from PySide2 import QtWidgets
-
-
-class CsvLogger:
-    """
-    Логгер, совместимый по формату с C-реализацией CSV_AddTitlesLine / CSV_AddLogLine.
-
-    Публичный API сохранён:
-        set_titles(varnames)
-        set_value(timestamp, varname, varvalue)
-        select_file(parent=None) -> bool
-        write_to_csv()
-
-    Использование:
-        1) set_titles([...])
-        2) многократно set_value(ts, name, value)
-        3) select_file() (по желанию)
-        4) write_to_csv()
-    """
-    def __init__(self, filename="log.csv", delimiter=';'):
-        self._filename = filename
-        self._delimiter = delimiter
-
-        # Пользовательские заголовки
-        self.variable_names_ordered = []
-        # Полные заголовки CSV (Ticks(X), Ticks(Y), Time(Y), ...)
-        self.headers = ['t']  # до вызова set_titles placeholder
-
-        # Данные: {timestamp_key: {varname: value, ...}}
-        # timestamp_key = то, что передано в set_value (float/int/etc)
-        self.data_rows = {}
-
-        # Внутренние структуры для генерации CSV-формата С
-        self._row_wall_dt = {}      # {timestamp_key: datetime при первой записи}
-        self._base_ts = None        # timestamp_key первой строки (число)
-        self._base_ts_val = 0.0     # float значение первой строки (для delta)
-        self._tick_x_start = 0      # начальный тик (можно менять вручную при необходимости)
-
-    # ---- Свойства ----
-    @property
-    def filename(self):
-        return self._filename
-
-    # ---- Публичные методы ----
-    def set_titles(self, varnames):
-        """
-        Устанавливает имена переменных.
-        Формирует полные заголовки CSV в формате С-лога.
-        """
-        if not isinstance(varnames, list):
-            raise TypeError("Varnames must be a list of strings.")
-        if not all(isinstance(name, str) for name in varnames):
-            raise ValueError("All variable names must be strings.")
-
-        self.variable_names_ordered = varnames
-        self.headers = ["Ticks(X)", "Ticks(Y)", "Time(Y)"] + self.variable_names_ordered
-
-        # Сброс данных (структура изменилась)
-        self.data_rows.clear()
-        self._row_wall_dt.clear()
-        self._base_ts = None
-        self._base_ts_val = 0.0
-
-
-    def set_value(self, timestamp, varname, varvalue):
-        """
-        Установить ОДНО значение в ОДНУ колонку для заданного timestamp’а.
-        timestamp — float секунд с эпохи (time.time()).
-        """
-        if varname not in self.variable_names_ordered:
-            return  # игнор, как у тебя было
-
-        # Новая строка?
-        if timestamp not in self.data_rows:
-            # Инициализируем поля переменных значением None
-            self.data_rows[timestamp] = {vn: None for vn in self.variable_names_ordered}
-
-            # Дата/время строки из ПЕРЕДАННОГО timestamp (а не datetime.now()!)
-            try:
-                ts_float = float(timestamp)
-            except Exception:
-                # если какая-то дичь прилетела, пусть будет 0 (эпоха) чтобы не упасть
-                ts_float = 0.0
-            self._row_wall_dt[timestamp] = datetime.fromtimestamp(ts_float)
-
-            # База для расчёта Ticks(Y) — первая строка
-            if self._base_ts is None:
-                self._base_ts = timestamp
-                self._base_ts_val = ts_float
-
-        # Записываем значение
-        self.data_rows[timestamp][varname] = varvalue
-
-    def select_file(self, parent=None) -> bool:
-        """
-        Диалог выбора файла.
-        """
-        options = QtWidgets.QFileDialog.Options()
-        filename, _ = QtWidgets.QFileDialog.getSaveFileName(
-            parent,
-            "Сохранить данные CSV",
-            self._filename,
-            "CSV Files (*.csv);;All Files (*)",
-            options=options
-        )
-        if filename:
-            if not filename.lower().endswith('.csv'):
-                filename += '.csv'
-            self._filename = filename
-            return True
-        else:
-            return False
-
-    def write_to_csv(self):
-        """
-        Формирует CSV в формате C:
-            Ticks(X);Ticks(Y);Time(Y);Var1;Var2;...
-            0;0,000000;22/07/2025 13:45:12:0123;...;...
-
-        Правила значений:
-            - Тик X: автоинкремент от 0 (или self._tick_x_start) по порядку сортировки timestamp.
-            - Ticks(Y): дельта (секунды,микросекунды) между текущим timestamp и первым timestamp.
-            - Time(Y): wallclock строки (datetime.now() при первом появлении timestamp).
-            - Значение < 0 -> пустая ячейка (как if(raw_data[i] >= 0) else ;)
-            - None -> пустая ячейка.
-        """
-        if len(self.headers) <= 3:  # только служебные поля без переменных
-            print("Ошибка: Заголовки не установлены или не содержат переменных. Вызовите set_titles() перед записью.")
-            return
-        if not self._filename:
-            print("Ошибка: Имя файла не определено. select_file() или задайте при инициализации.")
-            return
-        if not self.data_rows:
-            print("Предупреждение: Нет данных для записи.")
-            # всё равно создадим файл с одними заголовками
-        try:
-            with open(self._filename, 'w', newline='', encoding='utf-8') as csvfile:
-                # QUOTE_NONE + escapechar для чистого формата без кавычек (как в С-строке)
-                writer = csv.writer(
-                    csvfile,
-                    delimiter=self._delimiter,
-                    quoting=csv.QUOTE_NONE,
-                    escapechar='\\',
-                    lineterminator='\r\n'
-                )
-
-                # Пишем заголовки
-                writer.writerow(self.headers)
-
-                if self.data_rows:
-                    sorted_ts = sorted(self.data_rows.keys(), key=self._ts_sort_key)
-                    # убедимся, что база была зафиксирована
-                    if self._base_ts is None:
-                        self._base_ts = sorted_ts[0]
-                        self._base_ts_val = self._coerce_ts_to_float(self._base_ts)
-
-                    tick_x = self._tick_x_start
-                    for ts in sorted_ts:
-                        row_dict = self.data_rows[ts]
-                        # delta по timestamp
-                        cur_ts_val = self._coerce_ts_to_float(ts)
-                        delta_us = int(round((cur_ts_val - self._base_ts_val) * 1_000_000))
-                        if delta_us < 0:
-                            delta_us = 0  # защита
-
-                        seconds = delta_us // 1_000_000
-                        micros = delta_us % 1_000_000
-
-                        # wallclock строки
-                        dt = self._row_wall_dt.get(ts, datetime.now())
-                        # Формат DD/MM/YYYY HH:MM:SS:мммм (4 цифры ms, как в C: us/1000)
-                        time_str = dt.strftime("%d/%m/%Y %H:%M:%S") + f":{dt.microsecond // 1000:04d}"
-
-                        # Значения
-                        row_vals = []
-                        for vn in self.variable_names_ordered:
-                            v = row_dict.get(vn)
-                            if v is None:
-                                row_vals.append("")  # нет данных
-                            else:
-                                # если числовое и <0 -> пусто (как в C: если raw_data[i] >= 0 else ;)
-                                if isinstance(v, numbers.Number) and v < 0:
-                                    row_vals.append("")
-                                else:
-                                    row_vals.append(v)
-
-                        csv_row = [tick_x, f"{seconds},{micros:06d}", time_str] + row_vals
-                        writer.writerow(csv_row)
-                        tick_x += 1
-
-            print(f"Данные успешно записаны в '{self._filename}'")
-        except Exception as e:
-            print(f"Ошибка при записи в файл '{self._filename}': {e}")
-
-    # ---- Вспомогательные ----
-    def _coerce_ts_to_float(self, ts):
-        """
-        Пробуем привести переданный timestamp к float.
-        Разрешаем int/float/str, остальное -> индекс по порядку (0).
-        """
-        if isinstance(ts, numbers.Number):
-            return float(ts)
-        try:
-            return float(ts)
-        except Exception:
-            # fallback: нечисловой ключ -> используем порядковый индекс
-            # (таких почти не должно быть, но на всякий)
-            return 0.0
-
-    def _ts_sort_key(self, ts):
-        """
-        Ключ сортировки timestamp’ов — сначала попытка float, потом str.
-        """
-        if isinstance(ts, numbers.Number):
-            return (0, float(ts))
-        try:
-            return (0, float(ts))
-        except Exception:
-            return (1, str(ts))
-

Src/path_hints.py

@@ -1,319 +0,0 @@
-# path_hints.py
-from __future__ import annotations
-from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Tuple
-
-import re
-
-
-# ---------------------- tokenization helpers ----------------------
-
-def split_path_tokens(path: str) -> List[str]:
-    """
-    Разбивает строку пути на логические части:
-      'foo[2].bar[1]->baz' -> ['foo', '[2]', 'bar', '[1]', 'baz']
-    Аналог твоей split_path(), но оставлена как чистая функция.
-    """
-    tokens: List[str] = []
-    token = ''
-    i = 0
-    L = len(path)
-    while i < L:
-        c = path[i]
-        # '->'
-        if c == '-' and i + 1 < L and path[i:i+2] == '->':
-            if token:
-                tokens.append(token)
-                token = ''
-            i += 2
-            continue
-        # одиночный '-' в конце
-        if c == '-' and i == L - 1:
-            i += 1
-            continue
-        # '.'
-        if c == '.':
-            if token:
-                tokens.append(token)
-                token = ''
-            i += 1
-            continue
-        # '[' ... ']'
-        if c == '[':
-            if token:
-                tokens.append(token)
-                token = ''
-            idx = ''
-            while i < L and path[i] != ']':
-                idx += path[i]
-                i += 1
-            if i < L and path[i] == ']':
-                idx += ']'
-                i += 1
-            tokens.append(idx)
-            continue
-        # обычный символ
-        token += c
-        i += 1
-    if token:
-        tokens.append(token)
-    return tokens
-
-def split_path_tokens_with_spans(path: str) -> List[Tuple[str, int, int]]:
-    """
-    Возвращает список кортежей (токен, start_pos, end_pos)
-    Токены — так же, как в split_path_tokens, но с позициями в исходной строке.
-    """
-    tokens = []
-    i = 0
-    L = len(path)
-    while i < L:
-        c = path[i]
-        start = i
-        # '->'
-        if c == '-' and i + 1 < L and path[i:i+2] == '->':
-            tokens.append(('->', start, start + 2))
-            i += 2
-            continue
-        if c == '.':
-            tokens.append(('.', start, start + 1))
-            i += 1
-            continue
-        if c == '[':
-            # захватим весь индекс с ']'
-            j = i
-            while j < L and path[j] != ']':
-                j += 1
-            if j < L and path[j] == ']':
-                j += 1
-            tokens.append((path[i:j], i, j))
-            i = j
-            continue
-        # иначе - обычное имя (до точки, стрелки или скобок)
-        j = i
-        while j < L and path[j] not in ['.', '-', '[']:
-            if path[j] == '-' and j + 1 < L and path[j:j+2] == '->':
-                break
-            j += 1
-        tokens.append((path[i:j], i, j))
-        i = j
-    # фильтруем из списка токены-разделители '.' и '->' чтобы оставить только логические части
-    filtered = [t for t in tokens if t[0] not in ['.', '->']]
-    return filtered
-
-def canonical_key(path: str) -> str:
-    """
-    Преобразует путь к канонической форме для индекса / поиска:
-      - '->' -> '.'
-      - '[' -> '.['
-      - lower()
-    """
-    p = path.replace('->', '.')
-    p = p.replace('[', '.[')
-    return p.lower()
-
-
-# ---------------------- индекс узлов ----------------------
-
-@dataclass
-class PathNode:
-    """
-    Узел в логическом дереве путей.
-    Храним:
-      - собственное имя (локальное, напр. 'controller' или '[3]')
-      - полный путь (оригинальный, как его должен видеть пользователь)
-      - тип (опционально; widget может хранить отдельно)
-      - дети
-    """
-    name: str
-    full_path: str
-    type_str: str = ''
-    children: Dict[str, "PathNode"] = field(default_factory=dict)
-
-    def add_child(self, child: "PathNode") -> None:
-        self.children[child.name] = child
-
-    def get_children(self) -> List["PathNode"]:
-        """
-        Вернуть список дочерних узлов, отсортированных по имени.
-        """
-        return sorted(self.children.values(), key=lambda n: n.name)
-
-class PathHints:
-    """
-    Движок автоподсказок / completion.
-    Работает с плоским списком ПОЛНЫХ имён (как показываются пользователю).
-    Сам восстанавливает иерархию и выдаёт подсказки по текущему вводу.
-    Qt-независим.
-    """
-
-    def __init__(self) -> None:
-        self._paths: List[str] = []
-        self._types: Dict[str, str] = {}          # full_path -> type_str (опционально)
-        self._index: Dict[str, PathNode] = {}     # canonical full path -> node
-        self._root_children: Dict[str, PathNode] = {}  # top-level по первому токену
-
-    # ------------ Подаём данные ------------
-    def set_paths(self,
-                  paths: List[Tuple[str, Optional[str]]]
-                  ) -> None:
-        """
-        paths: список кортежей (full_path, type_str|None).
-        Пример: ('project.controller.read.errors.bit.status_er0', 'unsigned int')
-        Поля могут содержать '->' и индексы, т.е. строки в пользовательском формате.
-
-        NOTE: порядок не важен; дерево строится автоматически.
-        """
-        self._paths = []
-        self._types.clear()
-        self._index.clear()
-        self._root_children.clear()
-
-        for p, t in paths:
-            if t is None:
-                t = ''
-            self._add_path(p, t)
-
-    def _add_path(self, full_path: str, type_str: str) -> None:
-        self._paths.append(full_path)
-        self._types[full_path] = type_str
-
-        tokens_spans = split_path_tokens_with_spans(full_path)
-        if not tokens_spans:
-            return
-
-        cur_dict = self._root_children
-        cur_full = ''
-        parent_node: Optional[PathNode] = None
-
-        for i, (tok, start, end) in enumerate(tokens_spans):
-            cur_full = full_path[:end]  # подстрока с начала до конца токена включительно
-            
-            node = cur_dict.get(tok)
-            if node is None:
-                node = PathNode(name=tok, full_path=cur_full)
-                cur_dict[tok] = node
-
-            # Регистрируем все узлы, включая промежуточные
-            self._index[canonical_key(cur_full)] = node
-
-            parent_node = node
-            cur_dict = node.children
-
-        # В последний узел добавляем тип
-        if parent_node:
-            parent_node.type_str = type_str
-
-
-    # ------------ Поиск узла ------------
-
-    def find_node(self, path: str) -> Optional[PathNode]:
-        return self._index.get(canonical_key(path))
-
-    def get_children(self, full_path: str) -> List[PathNode]:
-        """
-        Вернуть список дочерних узлов PathNode для заданного полного пути.
-        Если узел не найден — вернуть пустой список.
-        """
-        node = self.find_node(full_path)
-        if node is None:
-            return []
-        return node.get_children()
-    # ------------ Подсказки ------------
-
-    def suggest(self,
-                text: str,
-                *,
-                include_partial: bool = True
-                ) -> List[str]:
-        """
-        Вернёт список *полных имён узлов*, подходящих под ввод.
-        Правила (упрощённо, повторяя твою update_completions()):
-          - Если текст пуст → top-level.
-          - Если заканчивается на '.' или '->' или '[' → вернуть детей текущего узла.
-          - Иначе → фильтр по последнему фрагменту (prefix substring match).
-        """
-        text = text or ''
-        stripped = text.strip()
-
-        # пусто: top-level
-        if stripped == '':
-            return sorted(self._root_full_names())
-
-        # Завершение по разделителю?
-        if stripped.endswith('.') or stripped.endswith('->') or stripped.endswith('['):
-            base = stripped[:-1] if stripped.endswith('[') else stripped.rstrip('.').rstrip('>').rstrip('-')
-            node = self.find_node(base)
-            if node:
-                return self._children_full_names(node)
-            # не нашли базу — ничего
-            return []
-
-        # иначе: обычный поиск по последней части
-        toks = split_path_tokens(stripped)
-        prefix_last = toks[-1].lower() if toks else ''
-        parent_toks = toks[:-1]
-
-        if not parent_toks:
-            # фильтр top-level
-            res = []
-            for name, node in self._root_children.items():
-                if prefix_last == '' or prefix_last in name.lower():
-                    res.append(node.full_path)
-            return sorted(res)
-
-        # есть родитель
-        parent_path = self._join_tokens(parent_toks)
-        parent_node = self.find_node(parent_path)
-        if not parent_node:
-            return []
-        res = []
-        for child in parent_node.children.values():
-            if prefix_last == '' or prefix_last in child.name.lower():
-                res.append(child.full_path)
-        return sorted(res)
-    
-    def add_separator(self, full_path: str) -> str:
-        """
-        Возвращает full_path с добавленным разделителем ('.' или '['),
-        если у узла есть дети и пользователь ещё не поставил разделитель.
-        Если первый ребёнок — массивный токен ('[0]') → добавляем '['.
-        Позже можно допилить '->' для указателей.
-        """
-        node = self.find_node(full_path)
-        text = full_path
-
-        if node and node.children and not (
-            text.endswith('.') or text.endswith('->') or text.endswith('[')
-        ):
-            first_child = next(iter(node.children.values()))
-            if first_child.name.startswith('['):
-                text += '['   # сразу начинаем индекс
-            else:
-                text += '.'   # обычный переход
-        return text
-
-
-    # ------------ внутренние вспомогательные ------------
-
-    def _root_full_names(self) -> List[str]:
-        return [node.full_path for node in self._root_children.values()]
-
-    def _children_full_names(self, node: PathNode) -> List[str]:
-        return [ch.full_path for ch in node.children.values()]
-
-    @staticmethod
-    def _join_tokens(tokens: List[str]) -> str:
-        """
-        Собираем путь обратно. Для внутренних нужд (поиск), формат не критичен —
-        всё равно canonical_key() нормализует.
-        """
-        if not tokens:
-            return ''
-        out = tokens[0]
-        for t in tokens[1:]:
-            if t.startswith('['):
-                out += t
-            else:
-                out += '.' + t
-        return out

Src/tms_debugvar_lowlevel.py

@@ -1,504 +0,0 @@
-"""
-LowLevelSelectorWidget (refactored)
------------------------------------
-Версия, использующая VariableTableWidget вместо самодельной таблицы selected_vars_table.
-
-Ключевые изменения:
-  * Вместо QTableWidget с 6 колонками теперь встраивается VariableTableWidget (8 колонок: №, En, Name, Origin Type, Base Type, IQ Type, Return Type, Short Name).
-  * Логика sync <-> self._all_available_vars перенесена в _on_var_table_changed() и _pull_from_var_table().
-  * Поддержка политики хранения типов:  
-        - ptr_type: строковое имя (без префикса `pt_`).  
-        - ptr_type_enum: числовой индекс (см. PT_ENUM_ORDER).  
-        - Для совместимости с VariableTableWidget: поле `pt_type` = 'pt_<name>'.  
-        - IQ / Return: аналогично (`iq_type` / `iq_type_enum`, `return_type` / `return_type_enum`).
-  * Функции получения выбранных переменных теперь читают данные из VariableTableWidget.
-  * Убраны неиспользуемые методы, связанные с прежней таблицей (комбо‑боксы и т.п.).
-
-Как интегрировать:
- 1. Поместите этот файл рядом с module VariableTableWidget (см. импорт ниже). Если класс VariableTableWidget находится в том же файле — удалите строку импорта и используйте напрямую.
- 2. Убедитесь, что VariablesXML предоставляет методы get_all_vars_data() (list[dict]) и, при наличии, get_struct_map() -> dict[type_name -> dict[field_name -> field_type]]. Если такого метода нет, передаём пустой {} и автодополнение по структурам будет недоступно.
- 3. Отметьте переменные в VariableSelectorDialog (как и раньше) — он обновит self._all_available_vars. После закрытия диалога вызывается self._populate_var_table().
- 4. Для чтения выбранных переменных используйте get_selected_variables_and_addresses(); она вернёт список словарей в унифицированном формате.
-
-Примечание о совместимости: VariableTableWidget работает с ключами `pt_type`, `iq_type`, `return_type` (строки с префиксами). Мы поддерживаем дублирование этих полей с «новыми» полями без префикса и enum‑значениями.
-
-"""
-from __future__ import annotations
-
-import sys
-import re
-import datetime
-from dataclasses import dataclass, field
-from typing import List, Dict, Optional, Tuple, Any
-
-from PySide2 import QtCore, QtGui
-from PySide2.QtWidgets import (
-    QWidget, QVBoxLayout, QPushButton, QLabel, QHBoxLayout, QFileDialog, QMessageBox,
-    QMainWindow, QApplication, QSizePolicy, QSpinBox, QGroupBox, QSplitter, QFormLayout
-)
-
-# Локальные импорты
-from path_hints import PathHints
-from generate_debug_vars import choose_type_map, type_map
-from var_selector_window import VariableSelectorDialog
-from allvars_xml_parser import VariablesXML
-
-# Импортируем готовую таблицу
-# ЗАМЕТКА: замените на реальное имя файла/модуля, если отличается.
-from var_table import VariableTableWidget, rows as VT_ROWS  # noqa: F401
-
-# ------------------------------------------------------------ Enumerations --
-# Порядок фиксируем на основании предыдущей версии. При необходимости расширьте.
-PT_ENUM_ORDER = [
-    'unknown','int8','int16','int32','int64',
-    'uint8','uint16','uint32','uint64','float',
-    'struct','union'
-]
-
-IQ_ENUM_ORDER = [
-    'iq_none','iq','iq1','iq2','iq3','iq4','iq5','iq6',
-    'iq7','iq8','iq9','iq10','iq11','iq12','iq13','iq14',
-    'iq15','iq16','iq17','iq18','iq19','iq20','iq21','iq22',
-    'iq23','iq24','iq25','iq26','iq27','iq28','iq29','iq30'
-]
-
-PT_ENUM_VALUE: Dict[str, int] = {name: idx for idx, name in enumerate(PT_ENUM_ORDER)}
-IQ_ENUM_VALUE: Dict[str, int] = {name: idx for idx, name in enumerate(IQ_ENUM_ORDER)}
-PT_ENUM_NAME_FROM_VAL: Dict[int, str] = {v: k for k, v in PT_ENUM_VALUE.items()}
-IQ_ENUM_NAME_FROM_VAL: Dict[int, str] = {v: k for k, v in IQ_ENUM_VALUE.items()}
-
-
-# ------------------------------------------- Address / validation helpers --
-HEX_ADDR_MASK = QtCore.QRegExp(r"0x[0-9A-Fa-f]{0,6}")
-class HexAddrValidator(QtGui.QRegExpValidator):
-    def __init__(self, parent=None):
-        super().__init__(HEX_ADDR_MASK, parent)
-
-    @staticmethod
-    def normalize(text: str) -> str:
-        if not text:
-            return '0x000000'
-        try:
-            val = int(text,16)
-        except ValueError:
-            return '0x000000'
-        return f"0x{val & 0xFFFFFF:06X}"
-
-
-class LowLevelSelectorWidget(QWidget):
-    variablePrepared = QtCore.Signal(dict)
-    xmlLoaded = QtCore.Signal(str)
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle('LowLevel Variable Selector')
-        self._xml: Optional[VariablesXML] = None
-        self._paths: List[str] = []
-        self._path_info: Dict[str, Tuple[int, str]] = {}
-        self._addr_index: Dict[int, Optional[str]] = {}
-        self._hints = PathHints()
-        self._all_available_vars: List[Dict[str, Any]] = []
-        self.dt = None
-        self.flat_vars = None
-
-        # --- NEW --- 
-        self.btn_read_once = QPushButton("Read Once")
-        self.btn_start_polling = QPushButton("Start Polling")
-        self.spin_interval = QSpinBox()
-        self.spin_interval.setRange(50, 10000)
-        self.spin_interval.setValue(500)
-        self.spin_interval.setSuffix(" ms")
-
-        self._build_ui()
-        self._connect()
-
-    def _build_ui(self):
-        tab = QWidget()
-        main_layout = QVBoxLayout(tab)
-
-        # --- Variable Selector ---
-        g_selector = QGroupBox("Variable Selector")
-        selector_layout = QVBoxLayout(g_selector)
-
-        form_selector = QFormLayout()
-
-        # --- XML File chooser ---
-        file_layout = QHBoxLayout()
-        self.btn_load = QPushButton('Load XML...')
-        self.lbl_file = QLabel('<no file>')
-        self.lbl_file.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse)
-        file_layout.addWidget(self.btn_load)
-        file_layout.addWidget(self.lbl_file, 1)
-        form_selector.addRow("XML File:", file_layout)
-
-        # --- Interval SpinBox ---
-        self.spin_interval = QSpinBox()
-        self.spin_interval.setRange(50, 10000)
-        self.spin_interval.setValue(500)
-        self.spin_interval.setSuffix(" ms")
-        form_selector.addRow("Interval:", self.spin_interval)
-
-        selector_layout.addLayout(form_selector)
-
-        # --- Buttons ---
-        self.btn_read_once = QPushButton("Read Once")
-        self.btn_start_polling = QPushButton("Start Polling")
-        btn_layout = QHBoxLayout()
-        btn_layout.addWidget(self.btn_read_once)
-        btn_layout.addWidget(self.btn_start_polling)
-        selector_layout.addLayout(btn_layout)
-
-        # --- Table ---
-        g_table = QGroupBox("Table")
-        table_layout = QVBoxLayout(g_table)
-        self.btn_open_var_selector = QPushButton("Выбрать переменные...")
-        table_layout.addWidget(self.btn_open_var_selector)
-        self.var_table = VariableTableWidget(self, show_value_instead_of_shortname=1)
-        self.var_table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        table_layout.addWidget(self.var_table)
-
-        # --- Timestamp (moved here) ---
-        self.lbl_timestamp = QLabel('Timestamp: -')
-        table_layout.addWidget(self.lbl_timestamp)
-
-        # --- Splitter (Selector + Table) ---
-        v_split = QSplitter(QtCore.Qt.Vertical)
-        v_split.addWidget(g_selector)
-        v_split.addWidget(g_table)
-        v_split.setStretchFactor(0, 1)
-        v_split.setStretchFactor(1, 3)
-
-        main_layout.addWidget(v_split)
-        self.setLayout(main_layout)
-
-
-
-    def _connect(self):
-        self.btn_load.clicked.connect(self._on_load_xml)
-        self.btn_open_var_selector.clicked.connect(self._on_open_variable_selector)
-
-    # ------------------------------------------------------ XML loading ----
-    def _on_load_xml(self):
-        path, _ = QFileDialog.getOpenFileName(
-            self, 'Select variables XML', '', 'XML Files (*.xml);;All Files (*)')
-        if not path:
-            return
-        try:
-            self._xml = VariablesXML(path)
-            self.flat_vars = {v['name']: v for v in self._xml.flattened()}
-            # Получаем сырые данные по переменным
-            self._all_available_vars = self._xml.get_all_vars_data()
-        except Exception as e:
-            QMessageBox.critical(self, 'Parse error', f'Ошибка парсинга:\n{e}')
-            return
-
-        self.lbl_file.setText(path)
-        self.lbl_timestamp.setText(f'Timestamp: {self._xml.timestamp or "-"}')
-
-        self._populate_internal_maps_from_all_vars()
-        self._apply_timestamp_to_date()
-        self.xmlLoaded.emit(path)
-        self._log(f'Loaded {path}, variables={len(self._all_available_vars)})')
-
-
-    def _apply_timestamp_to_date(self):
-        if not (self._xml and self._xml.timestamp):
-            return
-        try:
-            # Пример: "Sat Jul 19 15:27:59 2025"
-            self.dt = datetime.datetime.strptime(self._xml.timestamp, "%a %b %d %H:%M:%S %Y")
-        except Exception as e:
-            print(f"Ошибка разбора timestamp '{self._xml.timestamp}': {e}")
-
-    # ------------------------------------------ Variable selector dialog ----
-    def _on_open_variable_selector(self):
-        if not self._xml:
-            QMessageBox.warning(self, 'No XML', 'Сначала загрузите XML файл.')
-            return
-
-        dialog = VariableSelectorDialog(
-            table=None,            # не используем встроенную таблицу
-            all_vars=self._all_available_vars,
-            structs=None,          # при необходимости подайте реальные структуры из XML
-            typedefs=None,         # ...
-            xml_path=None,         # по запросу пользователя xml_path = None
-            parent=self
-        )
-        if dialog.exec_() == dialog.Accepted:
-            # Диалог обновил self._all_available_vars напрямую
-            self._populate_internal_maps_from_all_vars()
-            self._populate_var_table()
-            self._log("Variable selection updated.")
-
-    # ----------------------------------------------------- Populate table ----
-    def _populate_var_table(self):
-        """Отобразить переменные (show_var == 'true') в VariableTableWidget."""
-        if not self._all_available_vars:
-            self.var_table.setRowCount(0)
-            return
-
-        # Нормализуем все записи перед передачей таблице.
-        for var in self._all_available_vars:
-            self._normalize_var_record(var)
-
-        # Карта структур для автодополнения (если VariablesXML предоставляет)
-        try:
-            structs_map = self._xml.get_struct_map() if self._xml else {}
-        except AttributeError:
-            structs_map = {}
-
-        # populate() принимает: (vars_list, structs, on_change_callback)
-        self.var_table.populate(self._all_available_vars, structs_map, self._on_var_table_changed)
-
-    # -------------------------------------------------- Table change slot ----
-    def _on_var_table_changed(self, *args, **kwargs):  # noqa: D401 (неиспользуемые)
-        """Вызывается при любом изменении в VariableTableWidget.
-
-        Читаем данные из таблицы, мержим в self._all_available_vars (по имени),
-        пересобираем служебные индексы.
-        """
-        updated = self.var_table.read_data()  # list[dict]
-
-        # создаём индекс по имени из master списка
-        idx_by_name = {v.get('name'): v for v in self._all_available_vars if v.get('name')}
-
-        for rec in updated:
-            nm = rec.get('name')
-            if not nm:
-                continue
-            dst = idx_by_name.get(nm)
-            if not dst:
-                # Новая запись; добавляем базовые поля
-                dst = {
-                    'name': nm,
-                    'address': 0,
-                    'file': '', 'extern': 'false', 'static': 'false',
-                }
-                self._all_available_vars.append(dst)
-                idx_by_name[nm] = dst
-
-            # перенести видимые поля
-            dst['show_var'] = str(bool(rec.get('show_var'))).lower()
-            dst['enable']   = str(bool(rec.get('enable'))).lower()
-            dst['shortname']= rec.get('shortname', nm)
-            dst['type']     = rec.get('type', dst.get('type',''))
-
-            # типы (строковые, с префиксами) -> нормализуем
-            pt_pref = rec.get('pt_type','pt_unknown')   # 'pt_int16'
-            iq_pref = rec.get('iq_type','t_iq_none')    # 't_iq10' etc.
-            rt_pref = rec.get('return_type', iq_pref)
-
-            self._assign_types_from_prefixed(dst, pt_pref, iq_pref, rt_pref)
-
-        # Пересобрать карты путей/адресов
-        self._populate_internal_maps_from_all_vars()
-
-    # --------------------------------- Normalize var record (public-ish) ----
-    def _normalize_var_record(self, var: Dict[str, Any]):
-        """Унифицирует записи переменной.
-
-        Требуемые поля после нормализации:
-            var['ptr_type']        -> str (напр. 'int16')
-            var['ptr_type_enum']   -> int
-            var['iq_type']         -> str ('iq10')
-            var['iq_type_enum']    -> int
-            var['return_type']     -> str ('iq10')
-            var['return_type_enum']-> int
-            var['pt_type']         -> 'pt_<ptr_type>' (для совместимости с VariableTableWidget)
-            var['return_type_pref']-> 't_<return_type>' (см. ниже)  # не обяз.
-
-        Дополнительно корректируем show_var/enable и адрес.
-        """
-        # --- show_var / enable
-        var['show_var'] = str(var.get('show_var', 'false')).lower()
-        var['enable'] = str(var.get('enable', 'true')).lower()
-
-        # --- address
-        if not var.get('address'):  
-            var_name = var.get('name')
-            # Ищем в self.flat_vars
-            if hasattr(self, 'flat_vars') and isinstance(self.flat_vars, dict):
-                flat_entry = self.flat_vars.get(var_name)
-                if flat_entry and 'address' in flat_entry:
-                    var['address'] = flat_entry['address']
-                else:
-                    var['address'] = 0
-            else:
-                var['address'] = 0
-        else:
-            # Нормализация адреса (если строка типа '0x1234')
-            try:
-                if isinstance(var['address'], str):
-                    var['address'] = int(var['address'], 16)
-            except ValueError:
-                var['address'] = 0
-
-
-        # --- ptr_type (строка)
-        name = None
-        if isinstance(var.get('ptr_type'), str):
-            name = var['ptr_type']
-        elif isinstance(var.get('ptr_type_name'), str):
-            name = var['ptr_type_name']
-        elif isinstance(var.get('pt_type'), str) and 'pt_' in var.get('pt_type'):
-            name = var['pt_type'].replace('pt_','')
-        elif isinstance(var.get('ptr_type'), int):
-            name = PT_ENUM_NAME_FROM_VAL.get(var['ptr_type'], 'unknown')
-        else:
-            name = self._map_type_to_ptr_enum(var.get('type'))
-        val = PT_ENUM_VALUE.get(name, 0)
-        var['ptr_type'] = name
-        var['ptr_type_enum'] = val
-        var['pt_type'] = f'pt_{name}'
-
-    # ---------------------------------------------- prefixed assign helper ----
-    def _assign_types_from_prefixed(self, dst: Dict[str, Any], pt_pref: str, iq_pref: str, rt_pref: str):
-        """Парсит строки вида 'pt_int16', 't_iq10' и записывает нормализованные поля."""
-        pt_name = pt_pref.replace('pt_','') if pt_pref else 'unknown'
-        iq_name = iq_pref
-        if iq_name.startswith('t_'):
-            iq_name = iq_name[2:]
-        rt_name = rt_pref
-        if rt_name.startswith('t_'):
-            rt_name = rt_name[2:]
-
-        dst['ptr_type'] = pt_name
-        dst['ptr_type_enum'] = PT_ENUM_VALUE.get(pt_name, 0)
-        dst['pt_type'] = f'pt_{pt_name}'
-
-        dst['iq_type'] = iq_name
-        dst['iq_type_enum'] = IQ_ENUM_VALUE.get(iq_name, 0)
-
-        dst['return_type'] = rt_name
-        dst['return_type_enum'] = IQ_ENUM_VALUE.get(rt_name, dst['iq_type_enum'])
-        dst['return_type_pref'] = f't_{rt_name}'
-
-    # ------------------------------------------ Populate internal maps ----
-    def _populate_internal_maps_from_all_vars(self):
-        self._path_info.clear()
-        self._addr_index.clear()
-        self._paths.clear()
-
-        for var in self._all_available_vars:
-            nm = var.get('name')
-            tp = var.get('type')
-            addr = var.get('address')
-            if nm is None:
-                continue
-            if addr is None:
-                addr = 0
-                var['address'] = 0
-            self._paths.append(nm)
-            self._path_info[nm] = (addr, tp)
-            if addr in self._addr_index:
-                self._addr_index[addr] = None
-            else:
-                self._addr_index[addr] = nm
-
-        # Обновим подсказки
-        self._hints.set_paths([(p, self._path_info[p][1]) for p in self._paths])
-
-    # -------------------------------------------------- Public helpers ----
-    def get_selected_variables_and_addresses(self) -> List[Dict[str, Any]]:
-        """Возвращает список выбранных переменных (show_var == true) с адресами и типами.
-
-        Чтение из VariableTableWidget + подстановка адресов/прочих служебных полей
-        из master списка.
-        """
-        tbl_data = self.var_table.read_data()  # список dict'ов в формате VariableTableWidget
-        idx_by_name = {v.get('name'): v for v in self._all_available_vars if v.get('name')}
-
-        out: List[Dict[str, Any]] = []
-        for rec in tbl_data:
-            nm = rec.get('name')
-            if not nm:
-                continue
-            src = idx_by_name.get(nm, {})
-            addr = src.get('address')
-            if addr is None or addr == '' or addr == 0:
-                src['address'] = self.flat_vars.get(nm, {}).get('address', 0)
-            else:
-                # если это строка "0x..." — конвертируем в int
-                if isinstance(addr, str) and addr.startswith('0x'):
-                    try:
-                        src['address'] = int(addr, 16)
-                    except ValueError:
-                        src['address'] = self.flat_vars.get(nm, {}).get('address', 0)
-            type_str = src.get('type', rec.get('type','N/A'))
-
-            # нормализация типов
-            tmp = dict(src)  # copy src to preserve extra fields (file, extern, ...)
-            self._assign_types_from_prefixed(tmp,
-                                             rec.get('pt_type','pt_unknown'),
-                                             rec.get('iq_type','t_iq_none'),
-                                             rec.get('return_type', rec.get('iq_type','t_iq_none')))
-            tmp['show_var'] = str(bool(rec.get('show_var'))).lower()
-            tmp['enable']   = str(bool(rec.get('enable'))).lower()
-            tmp['name']     = nm
-            tmp['address']  = addr
-            tmp['type']     = type_str
-            out.append(tmp)
-        return out
-
-    def get_datetime(self):
-        return self.dt
-    
-    def set_variable_value(self, var_name: str, value: Any):
-        # 1. Обновляем master-список переменных
-        found = None
-        for var in self._all_available_vars:
-            if var.get('name') == var_name:
-                var['value'] = value
-                found = var
-                break
-
-        if not found:
-            # Если переменной нет в списке, можно либо проигнорировать, либо добавить.
-            return False
-
-        # 2. Обновляем отображение в таблице
-        #self.var_table.populate(self._all_available_vars, {}, self._on_var_table_changed)
-        return True
-
-    # --------------- Address mapping / type mapping helpers ---------------
-
-    
-    def _map_type_to_ptr_enum(self, type_str: Optional[str]) -> str:
-        if not type_str:
-            return 'unknown'
-        low = type_str.lower()
-        token = low.replace('*',' ').replace('[',' ')
-        return type_map.get(token, 'unknown').replace('pt_','')
-
-    # ----------------------------------------------------------- Logging --
-    def _log(self, msg: str):
-        print(f"[LowLevelSelectorWidget Log] {msg}")
-
-
-# ---------------------------------------------------------------------------
-# Тест‑прогоночка (ручной) --------------------------------------------------
-# Запускать только вручную: python LowLevelSelectorWidget_refactored.py <xml>
-# ---------------------------------------------------------------------------
-
-# ----------------------------------------------------------- Demo window --
-class _DemoWindow(QMainWindow):
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle('LowLevel Selector Demo')
-        self.selector = LowLevelSelectorWidget(self)
-        self.setCentralWidget(self.selector)
-        self.selector.variablePrepared.connect(self.on_var)
-
-    def on_var(self, data: dict):
-        print('Variable prepared ->', data)
-
-    def closeEvent(self, ev):
-        self.setCentralWidget(None)
-        super().closeEvent(ev)
-
-# ----------------------------------------------------------------- main ---
-if __name__ == '__main__':
-    app = QApplication(sys.argv)
-    w = _DemoWindow()
-    w.resize(640, 520)
-    w.show()
-    sys.exit(app.exec_())

Src/var_selector_table.py

@@ -1,64 +1,86 @@
-# variable_select_widget.py
+import re
-import pickle
-import hashlib
-from typing import List, Dict, Any, Optional
-
 from PySide2.QtWidgets import (
-    QWidget, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QLineEdit,
+    QWidget, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QLineEdit, 
     QHeaderView, QCompleter
 )
 from PySide2.QtGui import QKeyEvent
 from PySide2.QtCore import Qt, QStringListModel
+import pickle
+import time
+import hashlib
 
-from path_hints import PathHints, canonical_key, split_path_tokens
-
-
-# ------------------------------------------------------------------
-# utils
-# ------------------------------------------------------------------
 def compute_vars_hash(vars_list):
     return hashlib.sha1(pickle.dumps(vars_list)).hexdigest()
 
+# Вспомогательные функции, которые теперь будут использоваться виджетом
+def split_path(path):
+    """
+    Разбивает путь на компоненты:
+    - 'foo[2].bar[1]->baz' → ['foo', '[2]', 'bar', '[1]', 'baz']
+    Если видит '-' в конце строки (без '>' после) — обрезает этот '-'
+    """
+    tokens = []
+    token = ''
+    i = 0
+    length = len(path)
+    while i < length:
+        c = path[i]
+        # Разделители: '->' и '.'
+        if c == '-' and i + 1 < length and path[i:i+2] == '->':
+            if token:
+                tokens.append(token)
+                token = ''
+            i += 2
+            continue
+        elif c == '-' and i == length - 1:
+            # '-' на конце строки без '>' после — просто пропускаем его
+            i += 1
+            continue
+        elif c == '.':
+            if token:
+                tokens.append(token)
+                token = ''
+            i += 1
+            continue
+        elif c == '[':
+            if token:
+                tokens.append(token)
+                token = ''
+            idx = ''
+            while i < length and path[i] != ']':
+                idx += path[i]
+                i += 1
+            if i < length and path[i] == ']':
+                idx += ']'
+                i += 1
+            tokens.append(idx)
+            continue
+        else:
+            token += c
+            i += 1
+    if token:
+        tokens.append(token)
+    return tokens
 
-def is_lazy_item(item: QTreeWidgetItem) -> bool:
+
+def is_lazy_item(item):
     return item.childCount() == 1 and item.child(0).text(0) == 'lazy_marker'
 
 
-# ------------------------------------------------------------------
-# VariableSelectWidget
-# ------------------------------------------------------------------
 class VariableSelectWidget(QWidget):
-    """
-    Виджет выбора переменных с деревом + строкой поиска + автодополнением.
-    Подсказки полностью через PathHints.
-    ВАЖНО: ожидается, что в данных (vars_list) каждое var['name'] — ПОЛНЫЙ ПУТЬ
-           (например: 'project.adc.status'), даже внутри children.
-    """
-
-    ROLE_NAME      = Qt.UserRole            # локальный хвост (display)
-    ROLE_VAR_DICT  = Qt.UserRole + 100      # исходный dict
-    ROLE_FULLPATH  = Qt.UserRole + 200      # полный путь
-
     def __init__(self, parent=None):
         super().__init__(parent)
-
+        self.expanded_vars = []
-        # данные
+        self.node_index = {}
-        self.expanded_vars: List[Dict[str, Any]] = []
+        self.is_autocomplete_on = True  # <--- ДОБАВИТЬ ЭТУ СТРОКУ
-        self.is_autocomplete_on = True
-        self.manual_completion_active = False
         self._bckspc_pressed = False
-        self._vars_hash: Optional[str] = None
+        self.manual_completion_active = False
+        self._vars_hash = None
 
-        # индекс: canonical_full_path -> item
+        # --- UI Элементы ---
-        self._item_by_canon: Dict[str, QTreeWidgetItem] = {}
-
-        # подсказки
-        self.hints = PathHints()
-
-        # --- UI ---
         self.search_input = QLineEdit(self)
         self.search_input.setPlaceholderText("Поиск...")
-
+        
         self.tree = QTreeWidget(self)
         self.tree.setHeaderLabels(["Имя переменной", "Тип"])
         self.tree.setSelectionMode(QTreeWidget.ExtendedSelection)
@@ -75,58 +97,32 @@ class VariableSelectWidget(QWidget):
         self.completer.setCaseSensitivity(Qt.CaseInsensitive)
         self.completer.setFilterMode(Qt.MatchContains)
         self.completer.setWidget(self.search_input)
-        self.completer.activated[str].connect(self.insert_completion)
 
-        # layout
+        # --- Layout ---
-        lay = QVBoxLayout(self)
+        layout = QVBoxLayout(self)
-        lay.setContentsMargins(0, 0, 0, 0)
+        layout.setContentsMargins(0, 0, 0, 0)
-        lay.addWidget(self.search_input)
+        layout.addWidget(self.search_input)
-        lay.addWidget(self.tree)
+        layout.addWidget(self.tree)
-
+        
-        # signals
+        # --- Соединения ---
-        self.search_input.textChanged.connect(self.on_search_text_changed)
+        #self.search_input.textChanged.connect(self.on_search_text_changed)
+        self.search_input.textChanged.connect(lambda text: self.on_search_text_changed(text))
         self.search_input.installEventFilter(self)
+        self.completer.activated[str].connect(lambda text: self.insert_completion(text))
 
-    # ------------------------------------------------------------------
+    # --- Публичные методы для управления виджетом снаружи ---
-    # public api
+    
-    # ------------------------------------------------------------------
     def set_autocomplete(self, enabled: bool):
+        """Включает или выключает режим автодополнения."""
         self.is_autocomplete_on = enabled
 
-    def set_data(self, vars_list: List[Dict[str, Any]]):
+    def set_data(self, vars_list):
-        """
+        """Основной метод для загрузки данных в виджет."""
-        Загружаем список переменных (формат: см. класс docstring).
-        """
-        # deepcopy
         self.expanded_vars = pickle.loads(pickle.dumps(vars_list, protocol=pickle.HIGHEST_PROTOCOL))
+        # self.build_completion_list() # Если нужна полная перестройка списка
+        self.populate_tree()
 
-        # rebuild hints из полного списка узлов (каждый узел уже с full_path)
-        self._rebuild_hints_from_vars(self.expanded_vars)
 
-        # rebuild tree
-        self.populate_tree(self.expanded_vars)
-
-    # ------------------------------------------------------------------
-    # hints builder: дети уже содержат ПОЛНЫЙ ПУТЬ
-    # ------------------------------------------------------------------
-    def _rebuild_hints_from_vars(self, vars_list: List[Dict[str, Any]]):
-        paths: List[tuple] = []
-
-        def walk(node: Dict[str, Any]):
-            full = node.get('name', '')
-            if full:
-                paths.append((full, node.get('type')))
-            for ch in node.get('children', []) or []:
-                walk(ch)
-
-        for v in vars_list:
-            walk(v)
-
-        self.hints.set_paths(paths)
-
-    # ------------------------------------------------------------------
-    # tree building
-    # ------------------------------------------------------------------
     def populate_tree(self, vars_list=None):
         if vars_list is None:
             vars_list = self.expanded_vars
@@ -134,295 +130,477 @@ class VariableSelectWidget(QWidget):
         new_hash = compute_vars_hash(vars_list)
         if self._vars_hash == new_hash:
             return
-        self._vars_hash = new_hash
 
+        self._vars_hash = new_hash
         self.tree.setUpdatesEnabled(False)
         self.tree.blockSignals(True)
         self.tree.clear()
-        self._item_by_canon.clear()
+        self.node_index.clear()
 
-        # построим top-level из входного списка: определяем по глубине токенов
+        for var in vars_list:
-        # (vars_list может содержать и глубокие узлы; выберем корни = те, чей full_path не имеет родителя в списке)
+            self.add_tree_item_lazy(None, var)
-        full_to_node = {v['name']: v for v in vars_list}
-        # но safer: просто добавляем все как top-level, если ты уже передаёшь только корни.
-        # Если в твоих данных vars_list == корни, просто сделаем:
-        for v in vars_list:
-            self._add_tree_item_lazy(None, v)
 
         self.tree.setUpdatesEnabled(True)
         self.tree.blockSignals(False)
-
         header = self.tree.header()
         header.setSectionResizeMode(QHeaderView.Interactive)
         header.setSectionResizeMode(1, QHeaderView.Stretch)
         self.tree.setColumnWidth(0, 400)
-
+        
-    def on_item_expanded(self, item: QTreeWidgetItem):
+    def on_item_expanded(self, item):
         if is_lazy_item(item):
             item.removeChild(item.child(0))
-            var = item.data(0, self.ROLE_VAR_DICT)
+            var = item.data(0, Qt.UserRole + 100)
             if var:
-                for ch in var.get('children', []) or []:
+                for child_var in var.get('children', []):
-                    self._add_tree_item_lazy(item, ch)
+                    self.add_tree_item_lazy(item, child_var)
 
-    # ------------------------------------------------------------------
+
-    # item creation (var['name'] — ПОЛНЫЙ ПУТЬ)
+    def get_full_item_name(self, item):
-    # ------------------------------------------------------------------
+        fullname = item.text(0)
-    def _add_tree_item_lazy(self, parent: Optional[QTreeWidgetItem], var: Dict[str, Any]):
+        # Заменяем '->' на '.'
-        full_path = var.get('name', '')
+        fullname = fullname.replace('->', '.')
+        fullname = fullname.replace('[', '.[')
+        return fullname
+
+    def add_tree_item_lazy(self, parent, var):
+        name = var['name']
         type_str = var.get('type', '')
-
+        item = QTreeWidgetItem([name, type_str])
-        # здесь оставляем полный путь для отображения
+        item.setData(0, Qt.UserRole, name)
-        item = QTreeWidgetItem([full_path, type_str])
+        full_name = self.get_full_item_name(item)
-        item.setData(0, self.ROLE_NAME, full_path)  # теперь ROLE_NAME = полный путь
+        self.node_index[full_name.lower()] = item
-        item.setData(0, self.ROLE_VAR_DICT, var)
-        item.setData(0, self.ROLE_FULLPATH, full_path)
 
         if "(bitfield:" in type_str:
             item.setDisabled(True)
-            self._set_tool(item, "Битовые поля недоступны для выбора")
+            self.set_tool(item, "Битовые поля недоступны для выбора")
 
-        # метаданные
         for i, attr in enumerate(['file', 'extern', 'static']):
             item.setData(0, Qt.UserRole + 1 + i, var.get(attr))
 
-        # в дерево
         if parent is None:
             self.tree.addTopLevelItem(item)
         else:
             parent.addChild(item)
 
-        # lazy children
+        # Если есть дети — добавляем заглушку (чтобы можно было раскрыть)
         if var.get('children'):
             dummy = QTreeWidgetItem(["lazy_marker"])
             item.addChild(dummy)
 
-        # индекс
+        # Кэшируем детей для подгрузки по событию
-        self._item_by_canon[canonical_key(full_path)] = item
+        item.setData(0, Qt.UserRole + 100, var)  # Сохраняем var целиком
 
-    @staticmethod
+    
-    def _tail_token(full_path: str) -> str:
+    def show_matching_path(self, item, path_parts, level=0):
-        toks = split_path_tokens(full_path)
+        node_name = item.text(0).lower()
-        return toks[-1] if toks else full_path
+        node_parts = split_path(node_name)
 
-    # ------------------------------------------------------------------
+        if 'project' in node_name:
-    # filtering
+            a = 1
-    # ------------------------------------------------------------------
-    def filter_tree(self):
-        """
-        Быстрый фильтр:
-        - без разделителей → substring по ЛОКАЛЬНОМУ имени top-level
-        - с разделителями → структурный (по токенам full_path)
-        """
-        text = (self.search_input.text() or '').strip()
-        low = text.lower()
-        parts = split_path_tokens(low) if low else []
-
-        # простой режим (нет ., ->, [):
-        if low and all(x not in low for x in ('.', '->', '[')):
-            for i in range(self.tree.topLevelItemCount()):
-                it = self.tree.topLevelItem(i)
-                full = (it.data(0, self.ROLE_FULLPATH) or '').lower()
-                it.setHidden(low not in full)
-            return
-
-        # структурный
-        for i in range(self.tree.topLevelItemCount()):
-            it = self.tree.topLevelItem(i)
-            self._show_matching_path(it, parts, 0)
-
-    def _show_matching_path(self, item: QTreeWidgetItem, path_parts: List[str], level: int = 0):
-        """
-        Сравниваем введённый путь (разбитый на токены) с ПОЛНЫМ ПУТЁМ узла.
-        Алгоритм: берём полный путь узла, разбиваем в токены, берём уровень level,
-        и сравниваем с соответствующим токеном path_parts[level].
-        """
-        full = (item.data(0, self.ROLE_FULLPATH) or '').lower()
-        node_parts = split_path_tokens(full)
 
         if level >= len(path_parts):
+            # Путь полностью пройден — показываем только этот узел (без раскрытия всех детей)
             item.setHidden(False)
             item.setExpanded(False)
             return True
 
         if level >= len(node_parts):
-            item.setHidden(True)
+            # Уровень поиска больше длины пути узла — скрываем
-            return False
+            item.setHidden(False)
 
         search_part = path_parts[level]
         node_part = node_parts[level]
 
         if search_part == node_part:
+            # Точное совпадение — показываем узел, идём вглубь только по совпадениям
             item.setHidden(False)
             matched_any = False
             self.on_item_expanded(item)
             for i in range(item.childCount()):
-                ch = item.child(i)
+                child = item.child(i)
-                if self._show_matching_path(ch, path_parts, level + 1):
+                if self.show_matching_path(child, path_parts, level + 1):
                     matched_any = True
             item.setExpanded(matched_any)
             return matched_any or item.childCount() == 0
 
         elif node_part.startswith(search_part):
+            # Неполное совпадение — показываем только этот узел, детей скрываем, не раскрываем
             item.setHidden(False)
             item.setExpanded(False)
             return True
-
+        
-        elif search_part in node_part and (level == len(path_parts) - 1):
+        elif search_part in node_part and (level == len(path_parts)-1):
+            # Неполное совпадение — показываем только этот узел, детей скрываем, не раскрываем
             item.setHidden(False)
             item.setExpanded(False)
             return True
 
         else:
+            # Несовпадение — скрываем
             item.setHidden(True)
             return False
 
-    # ------------------------------------------------------------------
-    # completions (ONLY PathHints)
-    # ------------------------------------------------------------------
-    def update_completions(self, text: Optional[str] = None) -> List[str]:
-        if text is None:
-            text = self.search_input.text()
-        suggestions = self.hints.suggest(text)
-        self.completer.setModel(QStringListModel(suggestions))
-        if suggestions:
-            self.completer.complete()
-        else:
-            self.completer.popup().hide()
-        return suggestions
 
-    def insert_completion(self, full_path: str):
+    def filter_tree(self):
-        text = self.hints.add_separator(full_path)
+        text = self.search_input.text().strip().lower()
-        if not self._bckspc_pressed:
+        path_parts = split_path(text) if text else []
+
+        if '.' not in text and '->' not in text and '[' not in text and text != '':
+            for i in range(self.tree.topLevelItemCount()):
+                item = self.tree.topLevelItem(i)
+                name = item.text(0).lower()
+                if text in name:
+                    item.setHidden(False)
+                    # Не сбрасываем expanded, чтобы можно было раскрывать вручную
+                else:
+                    item.setHidden(True)
+        else:
+            for i in range(self.tree.topLevelItemCount()):
+                item = self.tree.topLevelItem(i)
+                self.show_matching_path(item, path_parts, 0)
+
+
+
+    def find_node_by_path(self, root_vars, path_list):
+        current_level = root_vars
+        node = None
+        for part in path_list:
+            node = None
+            for var in current_level:
+                if var['name'] == part:
+                    node = var
+                    break
+            if node is None:
+                return None
+            current_level = node.get('children', [])
+        return node
+    
+
+    def update_completions(self, text=None):
+        if text is None:
+            text = self.search_input.text().strip()
+        else:
+            text = text.strip()
+
+        normalized_text = text.replace('->', '.')
+        parts = split_path(text)
+        path_parts = parts[:-1] if parts else []
+        prefix = parts[-1].lower() if parts else ''
+        ends_with_sep = text.endswith('.') or text.endswith('->') or text.endswith('[')
+        is_index_suggestion = text.endswith('[')
+
+        completions = []
+
+        def find_exact_node(parts):
+            if not parts:
+                return None
+            fullname = parts[0]
+            for p in parts[1:]:
+                fullname += '.' + p
+            return self.node_index.get(fullname.lower())
+
+        if is_index_suggestion:
+            base_text = text[:-1]  # убираем '['
+            parent_node = self.find_node_by_fullname(base_text)
+            if not parent_node:
+                base_text_clean = re.sub(r'\[\d+\]$', '', base_text)
+                parent_node = self.find_node_by_fullname(base_text_clean)
+            if parent_node:
+                seen = set()
+                for i in range(parent_node.childCount()):
+                    child = parent_node.child(i)
+                    if child.isHidden():
+                        continue
+                    cname = child.text(0)
+                    m = re.match(rf'^{re.escape(base_text)}\[(\d+)\]$', cname)
+                    if m and cname not in seen:
+                        completions.append(cname)
+                        seen.add(cname)
+            self.completer.setModel(QStringListModel(completions))
+            return completions
+
+        if ends_with_sep:
+            node = self.find_node_by_fullname(text[:-1])
+            if node:
+                for i in range(node.childCount()):
+                    child = node.child(i)
+                    if child.isHidden():
+                        continue
+                    completions.append(child.text(0))
+        elif not path_parts:
+            # Первый уровень — только если имя начинается с prefix
+            for i in range(self.tree.topLevelItemCount()):
+                item = self.tree.topLevelItem(i)
+                if item.isHidden():
+                    continue
+                name = item.text(0)
+                if name.lower().startswith(prefix):
+                    completions.append(name)
+        else:
+            node = find_exact_node(path_parts)
+            if node:
+                for i in range(node.childCount()):
+                    child = node.child(i)
+                    if child.isHidden():
+                        continue
+                    name = child.text(0)
+                    name_parts = child.data(0, Qt.UserRole + 10)
+                    if name_parts is None:
+                        name_parts = split_path(name)
+                        child.setData(0, Qt.UserRole + 10, name_parts)
+                    if not name_parts:
+                        continue
+                    last_part = name_parts[-1].lower()
+                    if prefix == '' or prefix in last_part:  # ← строго startswith
+                        completions.append(name)
+
+        self.completer.setModel(QStringListModel(completions))
+        self.completer.complete()
+        return completions
+
+
+    # Функция для поиска узла с полным именем
+    def find_node_by_fullname(self, name):
+        if name is None:
+            return None
+        normalized_name = name.replace('->', '.').lower()
+        normalized_name = normalized_name.replace('[', '.[').lower()
+        return self.node_index.get(normalized_name)
+        
+    def insert_completion(self, text):
+        node = self.find_node_by_fullname(text)
+        if node and node.childCount() > 0 and not (text.endswith('.') or text.endswith('->') or text.endswith('[')):
+            # Определяем разделитель по имени первого ребёнка
+            child_name = node.child(0).text(0)
+            if child_name.startswith(text + '->'):
+                text += '->'
+            elif child_name.startswith(text + '.'):
+                text += '.'
+            elif '[' in child_name:
+                text += '['  # для массивов
+            else:
+                text += '.'  # fallback
+                
+            if not self._bckspc_pressed:
+                self.search_input.setText(text)
+                self.search_input.setCursorPosition(len(text))
+
+            self.run_completions(text)
+        else:
             self.search_input.setText(text)
             self.search_input.setCursorPosition(len(text))
-        self.run_completions(text)
 
-    # ------------------------------------------------------------------
-    # events
-    # ------------------------------------------------------------------
     def eventFilter(self, obj, event):
         if obj == self.search_input and isinstance(event, QKeyEvent):
             if event.key() == Qt.Key_Space and event.modifiers() & Qt.ControlModifier:
                 self.manual_completion_active = True
-                self.run_completions(self.search_input.text())
+                text = self.search_input.text().strip()
+                self.run_completions(text)
             elif event.key() == Qt.Key_Escape:
+                # Esc — выключаем ручной режим и скрываем подсказки, если autocomplete выключен
                 if not self.is_autocomplete_on:
                     self.manual_completion_active = False
                     self.completer.popup().hide()
                     return True
+
             if event.key() == Qt.Key_Backspace:
-                self._bckspc_pressed = True
+                self._bckspc_pressed = True 
             else:
                 self._bckspc_pressed = False
+
         return super().eventFilter(obj, event)
+    
+    def run_completions(self, text):  
+        completions = self.update_completions(text)
 
-    def run_completions(self, text: str):
+        if not self.is_autocomplete_on and self._bckspc_pressed:
-        if not self.is_autocomplete_on and not self.manual_completion_active:
+            text = text[:-1]
-            self.completer.popup().hide()
+            
-            return
+        if len(completions) == 1 and completions[0].lower() == text.lower():
-        self.update_completions(text)
+            # Найдем узел с таким именем
+            def find_exact_item(name):
+                stack = [self.tree.topLevelItem(i) for i in range(self.tree.topLevelItemCount())]
+                while stack:
+                    node = stack.pop()
+                    if node.text(0).lower() == name.lower():
+                        return node
+                    for i in range(node.childCount()):
+                        stack.append(node.child(i))
+                return None
 
-    def on_search_text_changed(self, text: str):
+            node = find_exact_item(completions[0])
-        self.completer.setWidget(self.search_input)
+            if node and node.childCount() > 0:
+                # Используем первую подсказку, чтобы определить нужный разделитель                        
+                completions = self.update_completions(text + '.')    
+                if not completions:
+                    return
+                suggestion = completions[0]
+
+                # Ищем, какой символ идёт после текущего текста
+                separator = '.'
+                if suggestion.startswith(text):
+                    rest = suggestion[len(text):]
+                    if rest.startswith(text + '->'):
+                        separator += '->'
+                    elif rest.startswith(text + '.'):
+                        separator += '.'
+                    elif '[' in rest:
+                        separator += '['  # для массивов
+                    else:
+                        separator += '.'  # fallback
+                
+                if not self._bckspc_pressed:
+                    self.search_input.setText(text + separator)
+                completions = self.update_completions(text)
+                self.completer.setModel(QStringListModel(completions))
+                self.completer.complete()
+                return True
+
+        # Иначе просто показываем подсказки
+        self.completer.setModel(QStringListModel(completions))
+        if completions:
+            self.completer.complete()
+        return True
+
+    def on_search_text_changed(self, text):    
+        sender_widget = self.sender()
+        sender_name = sender_widget.objectName() if sender_widget else "Unknown Sender"
+
+        self.completer.setWidget(self.search_input) 
         self.filter_tree()
-        if text is None:
+        if text == None:
-            text = self.search_input.text()
+            text = self.search_input.text().strip()
         if self.is_autocomplete_on:
             self.run_completions(text)
         else:
+            # Если выключено, показываем подсказки только если флаг ручного вызова True
             if self.manual_completion_active:
                 self.run_completions(text)
             else:
                 self.completer.popup().hide()
-
+    
     def focusInEvent(self, event):
         if self.completer.widget() != self.search_input:
             self.completer.setWidget(self.search_input)
         super().focusInEvent(event)
 
-    def closeEvent(self, event):
+    def _custom_focus_in_event(self, event):
-        self.completer.setWidget(None)
+        # Принудительно установить виджет для completer при получении фокуса
-        self.completer.deleteLater()
+        if self.completer.widget() != self.search_input:
-        super().closeEvent(event)
+            self.completer.setWidget(self.search_input)
+        super(QLineEdit, self.search_input).focusInEvent(event) # Вызвать оригинальный обработчик
 
-    # ------------------------------------------------------------------
-    # lookup by full path
-    # ------------------------------------------------------------------
-    def find_item_by_fullpath(self, path: str) -> Optional[QTreeWidgetItem]:
-        return self._item_by_canon.get(canonical_key(path))
 
-    # ------------------------------------------------------------------
+    def build_completion_list(self):
-    # tooltips
+        completions = []
-    # ------------------------------------------------------------------
+
-    def _set_tool(self, item: QTreeWidgetItem, text: str):
+        def recurse(var, prefix=''):
+            fullname = f"{prefix}.{var['name']}" if prefix else var['name']
+            completions.append(fullname)
+            for child in var.get('children', []):
+                recurse(child, fullname)
+
+        for v in self.expanded_vars:
+            recurse(v)
+        self.all_completions = completions
+
+    def set_tool(self, item, text):
         item.setToolTip(0, text)
         item.setToolTip(1, text)
 
-    # ------------------------------------------------------------------
-    # selection helpers
-    # ------------------------------------------------------------------
     def get_all_items(self):
-        """Все leaf-узлы (подгружаем lazy)."""
+        """Возвращает все конечные (leaf) элементы, исключая битовые поля и элементы с детьми (реальными)."""
-        def collect_leaf(parent):
+        def collect_leaf_items(parent):
-            leaves = []
+            leaf_items = []
             for i in range(parent.childCount()):
-                ch = parent.child(i)
+                child = parent.child(i)
-                if ch.isHidden():
+                if child.isHidden():
                     continue
-                self.on_item_expanded(ch)
-                if ch.childCount() == 0:
-                    t = ch.text(1)
-                    if t and 'bitfield' in t.lower():
-                        continue
-                    leaves.append(ch)
-                else:
-                    leaves.extend(collect_leaf(ch))
-            return leaves
 
-        out = []
+                # Если есть заглушка — раскрываем                
+                self.on_item_expanded(child)
+
+                if child.childCount() == 0:
+                    item_type = child.text(1)
+                    if item_type and 'bitfield' in str(item_type).lower():
+                        continue
+                    leaf_items.append(child)
+                else:
+                    leaf_items.extend(collect_leaf_items(child))
+            return leaf_items
+
+        all_leaf_items = []
         for i in range(self.tree.topLevelItemCount()):
             top = self.tree.topLevelItem(i)
+
+            # Раскрываем lazy, если надо
             self.on_item_expanded(top)
+
             if top.childCount() == 0:
-                t = top.text(1)
+                item_type = top.text(1)
-                if t and 'bitfield' in t.lower():
+                if item_type and 'bitfield' in str(item_type).lower():
                     continue
-                out.append(top)
+                all_leaf_items.append(top)
             else:
-                out.extend(collect_leaf(top))
+                all_leaf_items.extend(collect_leaf_items(top))
-        return out
+        return all_leaf_items
+
+
 
     def _get_internal_selected_items(self):
+        """Возвращает выделенные элементы и всех их потомков, включая lazy."""
         selected = self.tree.selectedItems()
         all_items = []
-        def collect(item):
+
+        def collect_children(item):
+            # Раскрываем при необходимости
+            # Раскрываем lazy, если надо
             self.on_item_expanded(item)
-            res = [item]
+
+            items = [item]
             for i in range(item.childCount()):
-                res.extend(collect(item.child(i)))
+                child = item.child(i)
-            return res
+                items.extend(collect_children(child))
-        for it in selected:
+            return items
-            all_items.extend(collect(it))
+
+        for item in selected:
+            all_items.extend(collect_children(item))
+
         return all_items
 
     def get_selected_items(self):
+        """Возвращает только конечные (leaf) выделенные элементы, исключая bitfield."""
         selected = self.tree.selectedItems()
-        leaves = []
+        leaf_items = []
-        for it in selected:
+        for item in selected:
-            self.on_item_expanded(it)
+            # Раскрываем lazy, если надо
-            if all(it.child(i).isHidden() or not it.child(i).isSelected() for i in range(it.childCount())):
+            self.on_item_expanded(item)
-                t = it.data(0, self.ROLE_NAME)
+
-                if t and isinstance(t, str) and 'bitfield' in t.lower():
+            # Если у узла нет видимых/выделенных детей — он лист
+            if all(item.child(i).isHidden() or not item.child(i).isSelected() for i in range(item.childCount())):
+                item_type = item.data(0, Qt.UserRole)
+                if item_type and 'bitfield' in str(item_type).lower():
                     continue
-                leaves.append(it)
+                leaf_items.append(item)
-        return leaves
+        return leaf_items
+
 
     def get_all_var_names(self):
-        return [it.data(0, self.ROLE_FULLPATH) for it in self.get_all_items() if it.data(0, self.ROLE_FULLPATH)]
+        """Возвращает имена всех конечных (leaf) переменных, исключая битовые поля и группы."""
+        return [item.text(0) for item in self.get_all_items() if item.text(0)]
+
 
     def _get_internal_selected_var_names(self):
-        return [it.data(0, self.ROLE_FULLPATH) for it in self._get_internal_selected_items() if it.data(0, self.ROLE_FULLPATH)]
+        """Возвращает имена выделенных переменных."""
+        return [item.text(0) for item in self._get_internal_selected_items() if item.text(0)]
+
 
     def get_selected_var_names(self):
-        return [it.data(0, self.ROLE_FULLPATH) for it in self.get_selected_items() if it.data(0, self.ROLE_FULLPATH)]
+        """Возвращает имена только конечных (leaf) переменных из выделенных."""
+        return [item.text(0) for item in self.get_selected_items() if item.text(0)]
+
+    def closeEvent(self, event):
+        self.completer.setWidget(None)
+        self.completer.deleteLater()
+        super().closeEvent(event)

Src/var_selector_window.py

@@ -206,7 +206,7 @@ class VariableSelectorDialog(QDialog):
                     'enable': 'true', 
                     'shortname': name, 
                     'pt_type': '', 
-                    'iq_type': 't_iq_none',
+                    'iq_type': '',
                     'return_type': 't_iq_none', 
                     'file': file_val,
                     'extern': str(extern_val).lower() if extern_val else 'false',
@@ -304,7 +304,7 @@ class VariableSelectorDialog(QDialog):
         # Проверка пути к XML
         if not hasattr(self, 'xml_path') or not self.xml_path:
             from PySide2.QtWidgets import QMessageBox
-            #QMessageBox.warning(self, "Ошибка", "Путь к XML не задан, невозможно обновить переменные.")
+            QMessageBox.warning(self, "Ошибка", "Путь к XML не задан, невозможно обновить переменные.")
             return
 
         root, tree = myXML.safe_parse_xml(self.xml_path)

Src/var_table.py

@@ -64,8 +64,7 @@ class SetSizeDialog(QDialog):
     """
     Диалоговое окно для выбора числового значения (размера).
     """
-    def __init__(self, parent=None, initial_value=10, min_value=1, max_value=50, title="Укажите размер короткого имени",
+    def __init__(self, parent=None, initial_value=10, min_value=1, max_value=50, title="Укажите размер короткого имени"):
-                 label_text="Количество символов:"):
         super().__init__(parent)
         self.setWindowTitle(title)
         self.setFixedSize(320, 120)  # Задаем фиксированный размер для аккуратного вида
@@ -75,7 +74,7 @@ class SetSizeDialog(QDialog):
 
         # Макет для ввода значения
         input_layout = QHBoxLayout()
-        label = QLabel(label_text, self)
+        label = QLabel("Количество символов:", self)
         
         self.spin_box = QSpinBox(self)
         self.spin_box.setRange(min_value, max_value)  # Устанавливаем диапазон допустимых значений
@@ -120,92 +119,84 @@ class CtrlScrollComboBox(QComboBox):
             event.ignore()
             
 class VariableTableWidget(QTableWidget):
-    def __init__(self, parent=None, show_value_instead_of_shortname=0):
+    def __init__(self, parent=None):
+        super().__init__(0, 8, parent)
         # Таблица переменных
-        if show_value_instead_of_shortname:
+        self.setHorizontalHeaderLabels([
-            super().__init__(0, 8, parent)
+            '№',             # новый столбец
-            self.setHorizontalHeaderLabels([
+            'En',
-                '№',
+            'Name',
-                'En',
+            'Origin Type',
-                'Name',
+            'Base Type',
-                'Origin Type',
+            'IQ Type',
-                'Base Type',
+            'Return Type',
-                'IQ Type',
+            'Short Name'
-                'Return Type',
+        ])
-                'Value'
-            ])
-            self._show_value = True
-        else:
-            super().__init__(0, 8, parent)
-            self.setHorizontalHeaderLabels([
-                '№',
-                'En',
-                'Name',
-                'Origin Type',
-                'Base Type',
-                'IQ Type',
-                'Return Type',
-                'Short Name'
-            ])
-            self._show_value = False
         self.setEditTriggers(QAbstractItemView.AllEditTriggers)
         self.var_list = []
-
+        # Инициализируем QSettings с именем организации и приложения
-        # QSettings
         self.settings = QSettings("SET", "DebugVarEdit_VarTable")
+        # Восстанавливаем сохранённое состояние, если есть
         shortsize = self.settings.value("shortname_size", True, type=int)
         self._shortname_size = shortsize
-
+        
-        if(self._show_value):
-            self._shortname_size = 3
-
         self.type_options = list(dict.fromkeys(type_map.values()))
         self.pt_types_all = [t.replace('pt_', '') for t in self.type_options]
         self.iq_types_all = ['iq_none', 'iq'] + [f'iq{i}' for i in range(1, 31)]
+        # Задаём базовые iq-типы (без префикса 'iq_')
         self.iq_types = ['iq_none', 'iq', 'iq10', 'iq15', 'iq19', 'iq24']
-        type_options = [t for t in dict.fromkeys(type_map.values()) if 'arr' not in t and 'ptr' not in t
+        # Фильтруем типы из type_map.values() исключая те, что содержат 'arr' или 'ptr'
-                        and 'struct' not in t and 'union' not in t and '64' not in t]
+        type_options = [t for t in dict.fromkeys(type_map.values()) if 'arr' not in t and 'ptr' not in t and
+                        'struct' not in t and 'union' not in t and '64' not in t]
+        # Формируем display_type_options без префикса 'pt_'
         self.pt_types = [t.replace('pt_', '') for t in type_options]
 
-        self._iq_type_filter = list(self.iq_types)
+        self._iq_type_filter = list(self.iq_types)  # Текущий фильтр iq типов (по умолчанию все)
         self._pt_type_filter = list(self.pt_types)
         self._ret_type_filter = list(self.iq_types)
-
         header = self.horizontalHeader()
+        # Для остальных колонок — растяжение (Stretch), чтобы они заняли всю оставшуюся ширину
+
         for col in range(self.columnCount()):
             if col == self.columnCount() - 1:
                 header.setSectionResizeMode(col, QHeaderView.Stretch)
             else:
                 header.setSectionResizeMode(col, QHeaderView.Interactive)
 
+        parent_widget = self.parentWidget()
+        # Сделаем колонки с номерами фиксированной ширины
         self.setColumnWidth(rows.No, 30)
         self.setColumnWidth(rows.include, 30)
         self.setColumnWidth(rows.pt_type, 85)
         self.setColumnWidth(rows.iq_type, 85)
         self.setColumnWidth(rows.ret_type, 85)
+
         self.setColumnWidth(rows.name, 300)
         self.setColumnWidth(rows.type, 100)
-
         self._resizing = False
         self.horizontalHeader().sectionResized.connect(self.on_section_resized)
         self.horizontalHeader().sectionClicked.connect(self.on_header_clicked)
 
+
     def populate(self, vars_list, structs, on_change_callback):
         self.var_list = vars_list
-        self.setUpdatesEnabled(False)
-        self.blockSignals(True)
 
+        # --- ДО: удаляем отображение структур и union-переменных
         for var in vars_list:
             pt_type = var.get('pt_type', '')
             if 'struct' in pt_type or 'union' in pt_type:
                 var['show_var'] = 'false'
                 var['enable'] = 'false'
 
+
         filtered_vars = [v for v in vars_list if v.get('show_var', 'false') == 'true']
         self.setRowCount(len(filtered_vars))
         self.verticalHeader().setVisible(False)
         style_with_padding = "padding-left: 5px; padding-right: 5px; font-size: 14pt; font-family: 'Segoe UI';"
 
+
+
+
         for row, var in enumerate(filtered_vars):
             # №
             no_item = QTableWidgetItem(str(row))
@@ -221,21 +212,25 @@ class VariableTableWidget(QTableWidget):
 
             # Name
             name_edit = QLineEdit(var['name'])
+            if var['type'] in structs:
+                completer = QCompleter(structs[var['type']].keys())
+                completer.setCaseSensitivity(Qt.CaseInsensitive)
+                name_edit.setCompleter(completer)
             name_edit.textChanged.connect(on_change_callback)
             name_edit.setStyleSheet(style_with_padding)
             self.setCellWidget(row, rows.name, name_edit)
 
-            # Origin Type
+            # Origin Type (readonly)
             origin_item = QTableWidgetItem(var.get('type', ''))
             origin_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
-            origin_item.setToolTip(var.get('type', ''))
+            origin_item.setToolTip(var.get('type', ''))  # Всплывающая подсказка
             origin_item.setForeground(QBrush(Qt.black))
             self.setItem(row, rows.type, origin_item)
 
             # pt_type
             pt_combo = CtrlScrollComboBox()
             pt_combo.addItems(self.pt_types)
-            value = var.get('pt_type', 'unknown').replace('pt_', '')
+            value = var['pt_type'].replace('pt_', '')
             if value not in self.pt_types:
                 pt_combo.addItem(value)
             pt_combo.setCurrentText(value)
@@ -246,7 +241,7 @@ class VariableTableWidget(QTableWidget):
             # iq_type
             iq_combo = CtrlScrollComboBox()
             iq_combo.addItems(self.iq_types)
-            value = var.get('iq_type', 'iq_none').replace('t_', '')
+            value = var['iq_type'].replace('t_', '')
             if value not in self.iq_types:
                 iq_combo.addItem(value)
             iq_combo.setCurrentText(value)
@@ -257,46 +252,19 @@ class VariableTableWidget(QTableWidget):
             # return_type
             ret_combo = CtrlScrollComboBox()
             ret_combo.addItems(self.iq_types)
-            value = var.get('return_type', 'iq_none').replace('t_', '')
+            value = var['return_type'].replace('t_', '')
-            if value not in self.iq_types:
-                ret_combo.addItem(value)
             ret_combo.setCurrentText(value)
             ret_combo.currentTextChanged.connect(on_change_callback)
             ret_combo.setStyleSheet(style_with_padding)
             self.setCellWidget(row, rows.ret_type, ret_combo)
 
-            # Последний столбец
+            # short_name
-            if self._show_value:
+            short_name_val = var.get('shortname', var['name'])
-                if self._show_value:
+            short_name_edit = QLineEdit(short_name_val)
-                    val = var.get('value', '')
+            short_name_edit.textChanged.connect(on_change_callback)
-                    if val is None:
+            short_name_edit.setStyleSheet(style_with_padding)
-                        val = ''
+            self.setCellWidget(row, rows.short_name, short_name_edit)
-                    else:
+        
-                        try:
-                            f_val = float(val)
-                            # Форматируем число с учетом self._shortname_size
-                            if f_val.is_integer():
-                                val = str(int(f_val))
-                            else:
-                                precision = getattr(self, "_shortname_size", 3)  # по умолчанию 3
-                                val = f"{f_val:.{precision}f}"
-                        except ValueError:
-                            # Если значение не число (строка и т.п.), оставляем как есть
-                            val = str(val)
-
-                    val_edit = QLineEdit(val)
-                    val_edit.textChanged.connect(on_change_callback)
-                    val_edit.setStyleSheet(style_with_padding)
-                    self.setCellWidget(row, rows.short_name, val_edit)
-            else:
-                short_name_val = var.get('shortname', var['name'])
-                short_name_edit = QLineEdit(short_name_val)
-                short_name_edit.textChanged.connect(on_change_callback)
-                short_name_edit.setStyleSheet(style_with_padding)
-                self.setCellWidget(row, rows.short_name, short_name_edit)
-
-        self.blockSignals(False)
-        self.setUpdatesEnabled(True)
         self.check()
 
     def check(self):
@@ -327,10 +295,9 @@ class VariableTableWidget(QTableWidget):
             if not found:
                 color = error_color
                 tooltip = tooltip_missing
-            elif long_shortname:                
+            elif long_shortname:
-                if not self._show_value:
+                color = warning_color
-                    color = warning_color
+                tooltip = tooltip_shortname
-                    tooltip = tooltip_shortname
 
             self.highlight_row(row, color, tooltip)
             t4 = time.time()
@@ -384,15 +351,10 @@ class VariableTableWidget(QTableWidget):
                 self.update_comboboxes({rows.ret_type: self._ret_type_filter})
                 
         elif logicalIndex == rows.short_name:
-            if self._show_value:
+            dlg = SetSizeDialog(self)
-                dlg = SetSizeDialog(self, title="Укажите точность", label_text="Кол-во знаков после запятой", initial_value=3)
-            else:
-                dlg = SetSizeDialog(self)
-
             if dlg.exec_():
                 self._shortname_size = dlg.get_selected_size()   
-                if not self._show_value:
+                self.settings.setValue("shortname_size", self._shortname_size)             
-                    self.settings.setValue("shortname_size", self._shortname_size)             
                 self.check()
 
 
@@ -413,9 +375,10 @@ class VariableTableWidget(QTableWidget):
                     combo.clear()
                     
                     combo.addItems(allowed_items)
-                    if current not in allowed_items:
+                    if current in allowed_items:
-                        combo.addItem(current)
+                        combo.setCurrentText(current)
-                    combo.setCurrentText(current)
+                    else:
+                        combo.setCurrentIndex(0)
                     combo.blockSignals(False)
 
 

debug_tools.c

@@ -9,21 +9,6 @@ DebugLowLevel_t debug_ll = DEBUG_LOWLEVEL_INIT; ///<
 
 static int getDebugVar(DebugVar_t *var, int32_t *int_var, float *float_var);
 static int convertDebugVarToIQx(DebugVar_t *var, int32_t *ret_var);
-static int iqTypeToQ(DebugVarIQType_t t);
-static int is_addr_in_allowed_ranges(uint32_t addr_val, const AddrRange_t *ranges, int count);
-
-/**
- * @brief Ìàññèâ äîïóñòèìûõ äèàïàçîíîâ àäðåñîâ äëÿ îòëàäî÷íîãî ÷òåíèÿ
- *
- * Âêëþ÷àåò â ñåáÿ íàáîð äèàïàçîíîâ ïàìÿòè, ðàçðåø¸ííûõ äëÿ äîñòóïà
- * ôóíêöèåé Debug_LowLevel_ReadVar.
- */
-static const AddrRange_t debug_allowed_ranges[] = ALLOWED_ADDRESS_RANGES;
-/**
- * @brief Êîëè÷åñòâî ýëåìåíòîâ â ìàññèâå debug_allowed_ranges
- */
-static const int debug_allowed_ranges_count = sizeof(debug_allowed_ranges) / sizeof(debug_allowed_ranges[0]);
-
 
 ///////////////////////////----EXAPLE-----//////////////////////////////
 int var_numb = 1;           ///< Ïðèìåð ïåðåìåííîé äëÿ îòëàäêè
@@ -39,9 +24,8 @@ DateTime_t ext_date = {2025, 11, 07, 16, 50}; ///<
   */
 void Debug_Test_Example(void)
 {
-    return;
     result = Debug_ReadVar(var_numb, &return_var);
-    result = Debug_ReadVarName(var_numb, var_name, 0);
+    result = Debug_ReadVarName(var_numb, var_name);
 
 
     if(Debug_LowLevel_Initialize(&ext_date) == 0)
@@ -59,79 +43,19 @@ void Debug_Test_Example(void)
   */
 int Debug_ReadVar(int var_ind, int32_t *return_32b)
 {
+    if(return_32b == NULL)
+        return 1;
     int32_t tmp_var;
 
-    if(return_32b == NULL)
-        return DEBUG_ERR_INTERNAL;
     if (var_ind >= DebugVar_Qnt)
-        return DEBUG_ERR_VAR_NUMB;
+        return 1;
     if((dbg_vars[var_ind].ptr_type == pt_struct) || (dbg_vars[var_ind].ptr_type == pt_union) ||
             (dbg_vars[var_ind].ptr_type == pt_unknown))
-        return DEBUG_ERR_INVALID_VAR;
+        return 1;
 
     return convertDebugVarToIQx(&dbg_vars[var_ind], return_32b);
 }
 
-/**
-  * @brief    ×èòàåò âîçâðàùàåìûé òèï (IQ) ïåðåìåííîé ïî èíäåêñó.
-  * @param    var_ind      – èíäåêñ ïåðåìåííîé.
-  * @param    vartype       – óêàçàòåëü äëÿ âîçâðàòà òèïà.
-  * @return   int          – 0: óñïåõ, 1: îøèáêà.
-  * @details  Èñïîëüçóåòñÿ äëÿ ÷òåíèÿ âîçâðàùàåìîãî òèïà (IQ) ïåðåìåííûõ ïî èõ èíäåêñó.
-  */
-int Debug_ReadVarReturnType(int var_ind, int *vartype)
-{
-    int rettype;
-    if(vartype == NULL)
-        return DEBUG_ERR_INTERNAL;
-    if (var_ind >= DebugVar_Qnt)
-        return DEBUG_ERR_VAR_NUMB;
-    if((dbg_vars[var_ind].ptr_type == pt_struct) || (dbg_vars[var_ind].ptr_type == pt_union) ||
-            (dbg_vars[var_ind].ptr_type == pt_unknown))
-        return DEBUG_ERR_INVALID_VAR;
-
-    *vartype = iqTypeToQ(dbg_vars[var_ind].return_type);
-
-    return 0;
-}
-
-/**
-  * @brief    ×èòàåò òèï ïåðåìåííîé ïî èíäåêñó.
-  * @param    var_ind      – èíäåêñ ïåðåìåííîé.
-  * @param    vartype      – óêàçàòåëü äëÿ âîçâðàòà òèïà.
-  * @return   int          – 0: óñïåõ, 1: îøèáêà.
-  * @details  Èñïîëüçóåòñÿ äëÿ ÷òåíèÿ òèïà ïåðåìåííûõ ïî èõ èíäåêñó.
-  */
-int Debug_ReadVarType(int var_ind, int *vartype)
-{
-    int rettype;
-    if(vartype == NULL)
-        return DEBUG_ERR_INTERNAL;
-    if (var_ind >= DebugVar_Qnt)
-        return DEBUG_ERR_VAR_NUMB;
-    if((dbg_vars[var_ind].ptr_type == pt_struct) || (dbg_vars[var_ind].ptr_type == pt_union) ||
-            (dbg_vars[var_ind].ptr_type == pt_unknown))
-        return DEBUG_ERR_INVALID_VAR;
-
-    *vartype = dbg_vars[var_ind].ptr_type;
-
-    switch(dbg_vars[var_ind].ptr_type)
-    {
-        case pt_int8:
-        case pt_int16:
-        case pt_int32:
-        case pt_float:
-            *vartype = dbg_vars[var_ind].ptr_type | DEBUG_SIGNED_VAR;
-            break;
-
-        default:
-            *vartype = dbg_vars[var_ind].ptr_type;
-            break;
-    }
-
-    return 0;
-}
-
 /**
   * @brief    ×èòàåò èìÿ ïåðåìåííîé ïî èíäåêñó.
   * @param    var_ind    – èíäåêñ ïåðåìåííîé.
@@ -139,26 +63,21 @@ int Debug_ReadVarType(int var_ind, int *vartype)
   * @return   int        – 0: óñïåõ, 1: îøèáêà.
   * @details  Êîïèðóåò èìÿ ïåðåìåííîé â ïðåäîñòàâëåííûé áóôåð.
   */
-int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr, int *length)
+int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr)
 {
-    int i;
-
     if(name_ptr == NULL)
-        return DEBUG_ERR_INTERNAL;
+        return 1;
 
     if (var_ind >= DebugVar_Qnt)
-        return DEBUG_ERR_VAR_NUMB;
+        return 1;
 
+    int i;
     // Êîïèðîâàíèå ñ çàùèòîé îò ïåðåïîëíåíèÿ è ÿâíîé îñòàíîâêîé ïî '\0'
     for (i = 0; i < sizeof(dbg_vars[var_ind].name); i++)
     {
         name_ptr[i] = dbg_vars[var_ind].name[i];
         if (dbg_vars[var_ind].name[i] == '\0')
-        {
-            if(length != NULL)
-                *length = i;
             break;
-        }
     }
     // Ãàðàíòèðîâàííîå çàâåðøåíèå ñòðîêè (íà ñëó÷àé, åñëè â var->name íå áûëî '\0')
     name_ptr[sizeof(dbg_vars[var_ind].name) - 1] = '\0';
@@ -166,6 +85,7 @@ int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr, int *length)
     return 0;
 }
 
+
 /**
   * @brief    ×èòàåò çíà÷åíèå ïåðåìåííîé îòëàäêè ñ íèæíåãî óðîâíÿ.
   * @param    return_32b  – óêàçàòåëü íà ïåðåìåííóþ, êóäà çàïèñûâàåòñÿ ðåçóëüòàò.
@@ -174,17 +94,26 @@ int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr, int *length)
   */
 int Debug_LowLevel_ReadVar(int32_t *return_32b)
 {
+    if (return_32b == NULL)
+        return 1;
+    if (debug_ll.isVerified == 0)
+        return 1;
+
     uint8_t *addr = debug_ll.dbg_var.Ptr;
     uint32_t addr_val = (uint32_t)addr;
 
-    if (return_32b == NULL)
+    // Ðàçðåø¸ííûå äèàïàçîíû ïàìÿòè (èç .cmd ôàéëà)
-        return DEBUG_ERR_INTERNAL;
+    if (!(
-    if (debug_ll.isVerified == 0)
+        (addr_val <= 0x0007FF) ||  // RAMM0 + RAMM1
-        return DEBUG_ERR_DATATIME;
+        (addr_val >= 0x008120 && addr_val <= 0x009FFC) ||  // L0 + L1 SARAM
-
+        (addr_val >= 0x3F8000 && addr_val <= 0x3F9FFF) ||  // PRAMH0 + DRAMH0
-    if (is_addr_in_allowed_ranges(addr_val, debug_allowed_ranges, debug_allowed_ranges_count) != 0)
+        (addr_val >= 0x3FF000 && addr_val <= 0x3FFFFF) ||  // BOOTROM + RESET
-    {
+        (addr_val >= 0x080002 && addr_val <= 0x09FFFF) ||  // RAMEX1
-        return DEBUG_ERR_ADDR; // Çàïðåù¸ííûé àäðåñ — íåëüçÿ ÷èòàòü
+        (addr_val >= 0x0F0000 && addr_val <= 0x0FFEFF) ||  // RAMEX4
+        (addr_val >= 0x100002 && addr_val <= 0x103FFF) ||  // RAMEX0 + RAMEX2 + RAMEX01
+        (addr_val >= 0x102000 && addr_val <= 0x103FFF)     // RAMEX2
+    )) {
+        return 2; // Çàïðåù¸ííûé àäðåñ — íåëüçÿ ÷èòàòü
     }
 
     return convertDebugVarToIQx(&debug_ll.dbg_var, return_32b);
@@ -199,7 +128,7 @@ int Debug_LowLevel_ReadVar(int32_t *return_32b)
 int Debug_LowLevel_Initialize(DateTime_t* external_date)
 {
     if (external_date == NULL) {
-        return DEBUG_ERR_INTERNAL;
+        return -1;
     }
 
 
@@ -215,64 +144,10 @@ int Debug_LowLevel_Initialize(DateTime_t* external_date)
     }
     debug_ll.isVerified = 0;
 
-    return DEBUG_ERR_DATATIME;  // Íå ñîâïàëî
+    return 1;  // Íå ñîâïàëî
 }
 
 
-/**
-  * @brief    ×èòàåò âîçâðàùàåìûé òèï (IQ) íèçêîóðîâíåíî çàäàííîé ïåðåìåííîé.
-  * @param    var_ind      – èíäåêñ ïåðåìåííîé.
-  * @param    vartype       – óêàçàòåëü äëÿ âîçâðàòà òèïà.
-  * @return   int          – 0: óñïåõ, 1: îøèáêà.
-  * @details  Èñïîëüçóåòñÿ äëÿ ÷òåíèÿ âîçâðàùàåìîãî òèïà (IQ) ïåðåìåííûõ ïî èõ èíäåêñó.
-  */
-int Debug_LowLevel_ReadVarReturnType(int *vartype)
-{
-    int rettype;
-    if(vartype == NULL)
-        return DEBUG_ERR_INTERNAL;
-    if((debug_ll.dbg_var.ptr_type == pt_struct) || (debug_ll.dbg_var.ptr_type == pt_union) ||
-            (debug_ll.dbg_var.ptr_type == pt_unknown))
-        return DEBUG_ERR_INVALID_VAR;
-
-    *vartype = iqTypeToQ(debug_ll.dbg_var.return_type);
-
-    return 0;
-}
-
-/**
-  * @brief    ×èòàåò òèï íèçêîóðîâíåíî çàäàííîé ïåðåìåííîé.
-  * @param    var_ind      – èíäåêñ ïåðåìåííîé.
-  * @param    vartype      – óêàçàòåëü äëÿ âîçâðàòà òèïà.
-  * @return   int          – 0: óñïåõ, 1: îøèáêà.
-  */
-int Debug_LowLevel_ReadVarType(int *vartype)
-{
-    int rettype;
-    if(vartype == NULL)
-        return DEBUG_ERR_INTERNAL;
-    if((debug_ll.dbg_var.ptr_type == pt_struct) || (debug_ll.dbg_var.ptr_type == pt_union) ||
-            (debug_ll.dbg_var.ptr_type == pt_unknown))
-        return DEBUG_ERR_INVALID_VAR;
-
-    *vartype = debug_ll.dbg_var.ptr_type;
-
-    switch(debug_ll.dbg_var.ptr_type)
-    {
-        case pt_int8:
-        case pt_int16:
-        case pt_int32:
-        case pt_float:
-            *vartype = debug_ll.dbg_var.ptr_type | DEBUG_SIGNED_VAR;
-            break;
-
-        default:
-            *vartype = debug_ll.dbg_var.ptr_type;
-            break;
-    }
-
-    return 0;
-}
 
 
 
@@ -292,7 +167,7 @@ static int iqTypeToQ(DebugVarIQType_t t)
     else if (t >= t_iq1 && t <= t_iq30)
         return (int)t - (int)t_iq1 + 1; // íàïðèìåð t_iq1 -> 1, t_iq2 -> 2 è ò.ä.
     else
-        return 0;      // îøèáêà
+        return -1;      // îøèáêà
 }
 
 /**
@@ -305,25 +180,26 @@ static int iqTypeToQ(DebugVarIQType_t t)
 static int convertDebugVarToIQx(DebugVar_t *var, int32_t *ret_var)
 {
     int32_t iq_numb, iq_united, iq_final;
-    int64_t iq_united64 = 0;
-    int64_t iq_final64 = 0;
-    int status;
-
     float float_numb;
 
-    status = getDebugVar(var, &iq_numb, &float_numb);
+    if(getDebugVar(var, &iq_numb, &float_numb) != 0)
-    if(status != 0)
+        return 1;
-        return status;
 
     int src_q = iqTypeToQ(var->iq_type);
     int dst_q = iqTypeToQ(var->return_type);
 
+    if (src_q < 0 || dst_q < 0)
+        return 2; // íåïðàâèëüíûé ôîðìàò
+
+    int64_t iq_united64 = 0;
+    int64_t iq_final64 = 0;
+
     // Êîíâåðòàöèÿ ê GLOBAL_Q (64-áèò)
     if (var->iq_type == t_iq_none) {
         if (var->ptr_type == pt_float) {
             // float_numb óìíîæàåì íà 2^GLOBAL_Q
             // Ðåçóëüòàò ïðèâîäèì ê 64 áèòà
-            iq_united64 = (int64_t)(float_numb * ((uint32_t)1 << GLOBAL_Q));
+            iq_united64 = (int64_t)(float_numb * (1 << GLOBAL_Q));
         } else {
             iq_united64 = ((int64_t)iq_numb) << GLOBAL_Q;
         }
@@ -346,7 +222,11 @@ static int convertDebugVarToIQx(DebugVar_t *var, int32_t *ret_var)
         else
             iq_final64 = iq_united64 >> (-shift);
 
-        *ret_var = (int32_t)iq_final64;
+        // Ïðîâåðÿåì ïåðåïîëíåíèå int32_t
+        if (iq_final64 > 2147483647 || iq_final64 < -2147483648)
+            return 3; // ïåðåïîëíåíèå
+
+        *ret_var = (uint32_t)iq_final64;
     }
 
     return 0;
@@ -362,55 +242,52 @@ static int convertDebugVarToIQx(DebugVar_t *var, int32_t *ret_var)
   */
 static int getDebugVar(DebugVar_t *var, int32_t *int_var, float *float_var)
 {
+    if (!var || !int_var || !float_var || !var->Ptr)
+        return 1; // îøèáêà: null óêàçàòåëü
+
     uint8_t *addr = var->Ptr;
     uint32_t addr_val = (uint32_t)addr;
 
-    if (!var || !int_var || !float_var || !var->Ptr)
-        return DEBUG_ERR_INTERNAL; // îøèáêà: null óêàçàòåëü
-
     switch (var->ptr_type)
     {
         case pt_int8:      // 8 áèò
             if ((addr_val & ALIGN_8BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
-                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+                return 1;   // îøèáêà âûðàâíèâàíèÿ
             *int_var = *((volatile int8_t *)addr);
-            break;
         case pt_uint8:
             if ((addr_val & ALIGN_8BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
-                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+                return 1;   // îøèáêà âûðàâíèâàíèÿ
             *int_var = *((volatile uint8_t *)addr);
             break;
 
         case pt_int16:     // 16 áèò (int)
             if ((addr_val & ALIGN_16BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
-                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+                return 2;   // îøèáêà âûðàâíèâàíèÿ
             *int_var = *((volatile int16_t *)addr);
-            break;
         case pt_uint16:
             if ((addr_val & ALIGN_16BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
-                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+                return 2;   // îøèáêà âûðàâíèâàíèÿ
             *int_var = *((volatile uint16_t *)addr);
             break;
 
         case pt_int32:     // 32 áèò
             if ((addr_val & ALIGN_32BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
-                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+                return 3;   // îøèáêà âûðàâíèâàíèÿ
             *int_var = *((volatile int32_t *)addr);
-            break;
         case pt_uint32:
             if ((addr_val & ALIGN_32BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
-                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+                return 3;   // îøèáêà âûðàâíèâàíèÿ
             *int_var = *((volatile uint32_t *)addr);
             break;
 
         case pt_float:     // float (4 áàéòà)
             if ((addr_val & ALIGN_FLOAT) != 0)  // ïðîâåðêà âûðàâíèâàíèÿ
-                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+                return 4;   // îøèáêà âûðàâíèâàíèÿ
             *float_var = *((volatile float *)addr);
             break;
 
         default:
-            return DEBUG_ERR_INVALID_VAR; // íåïîääåðæèâàåìûé òèï
+            return 1; // íåïîääåðæèâàåìûé òèï
         // äëÿ óêàçàòåëåé è ìàññèâîâ íå ïîääåðæèâàåòñÿ ÷òåíèå
 //        case pt_ptr_int8:
 //        case pt_ptr_int16:
@@ -429,23 +306,3 @@ static int getDebugVar(DebugVar_t *var, int32_t *int_var, float *float_var)
     return 0; // óñïåõ
 }
 
-
-/**
- * @brief Ïðîâåðÿåò, âõîäèò ëè àäðåñ â îäèí èç äîïóñòèìûõ äèàïàçîíîâ
- *
- * @param addr_val  - Çíà÷åíèå àäðåñà äëÿ ïðîâåðêè
- * @param ranges    - Óêàçàòåëü íà ìàññèâ äèàïàçîíîâ AddrRange_t
- * @param count     - Êîëè÷åñòâî äèàïàçîíîâ â ìàññèâå
- * @return 0 åñëè àäðåñ íàõîäèòñÿ â îäíîì èç äèàïàçîíîâ, èíà÷å 1
- */
-static int is_addr_in_allowed_ranges(uint32_t addr_val, const AddrRange_t *ranges, int count)
-{
-    int i;
-
-    for (i = 0; i < count; i++) {
-        if (addr_val >= ranges[i].start && addr_val <= ranges[i].end) {
-            return 0;
-        }
-    }
-    return 1;
-}

debug_tools.h

@@ -5,18 +5,6 @@
 
 
 
-#define ALLOWED_ADDRESS_RANGES    { \
-    {0x000000, 0x0007FF},           \
-    {0x008120, 0x009FFC},           \
-    {0x3F8000, 0x3F9FFF},           \
-    {0x3FF000, 0x3FFFFF},           \
-    {0x080002, 0x09FFFF},           \
-    {0x0F0000, 0x0FFEFF},           \
-    {0x100002, 0x103FFF},           \
-    {0x102000, 0x103FFF}            \
-}
-
-
 #if UINT8_MAX // Если есть тип 8 бит - знчачит адресация по 8 бит
 
     #define ALIGN_8BIT   0x0     ///< Выравнивание без ограничений (любой адрес)
@@ -43,19 +31,6 @@
     #define NULL 0
 #endif
 
-#define DEBUG_SIGNED_VAR                (1<<7)
-
-#define DEBUG_OK                        (0)
-#define DEBUG_ERR                       (1<<7)
-#define DEBUG_ERR_VAR_NUMB              (1<<0) | DEBUG_ERR
-#define DEBUG_ERR_INVALID_VAR           (1<<1) | DEBUG_ERR
-#define DEBUG_ERR_ADDR                  (1<<2) | DEBUG_ERR
-#define DEBUG_ERR_ADDR_ALIGN            (1<<3) | DEBUG_ERR
-#define DEBUG_ERR_INTERNAL              (1<<4) | DEBUG_ERR
-#define DEBUG_ERR_DATATIME              (1<<5) | DEBUG_ERR
-#define DEBUG_ERR_RS                    (1<<6) | DEBUG_ERR
-
-
 
 /**
   * @brief Тип данных, на который указывает указатель переменной отладки.
@@ -154,13 +129,6 @@ typedef struct {
     uint8_t  minute;   ///< Минуты (0-59)
 } DateTime_t;
 
-/**
- * @brief Ñòðóêòóðà, îïèñûâàþùàÿ äèàïàçîí àäðåñîâ ïàìÿòè.
- */
-typedef struct {
-    uint32_t start;  ///< Íà÷àëüíûé àäðåñ äèàïàçîíà
-    uint32_t end;    ///< Êîíå÷íûé àäðåñ äèàïàçîíà (âêëþ÷èòåëüíî)
-} AddrRange_t;
 /**
   * @brief Структура нижнего уровня отладки.
   */
@@ -191,19 +159,10 @@ void Debug_Test_Example(void);
 /* Читает значение переменной по индексу */
 int Debug_ReadVar(int var_ind, int32_t *return_long);
 /* Читает имя переменной по индексу */
-int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr, int *length);
+int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr);
-/* ×èòàåò âîçâðàùàåìûé òèï (IQ) ïåðåìåííîé ïî èíäåêñó */
-int Debug_ReadVarReturnType(int var_ind, int *vartype);
-/* ×èòàåò òèï ïåðåìåííîé ïî èíäåêñó */
-int Debug_ReadVarType(int var_ind, int *vartype);
-
-
 /* Читает значение переменной с нижнего уровня */
 int Debug_LowLevel_ReadVar(int32_t *return_long);
 /* Инициализирует отладку нижнего уровня */
 int Debug_LowLevel_Initialize(DateTime_t *external_date);
-/* ×èòàåò âîçâðàùàåìûé òèï (IQ) íèçêîóðîâíåíî çàäàííîé ïåðåìåííîé */
+
-int Debug_LowLevel_ReadVarReturnType(int *vartype);
-/* ×èòàåò òèï íèçêîóðîâíåíî çàäàííîé ïåðåìåííîé.*/
-int Debug_LowLevel_ReadVarType(int *vartype);
 #endif //DEBUG_TOOLS

debug_vars_example.c

@@ -0,0 +1,23 @@
+#include "debug_tools.h"
+
+
+// Инклюды для доступа к переменным
+#include "bender.h"
+
+// Экстерны для доступа к переменным
+extern int ADC0finishAddr;
+
+
+// Определение массива с указателями на переменные для отладки
+int DebugVar_Qnt = 5;
+#pragma DATA_SECTION(dbg_vars,".dbgvar_info")
+//												pointer_type    iq_type			return_iq_type  short_name
+DebugVar_t dbg_vars[] = {\
+{(uint8_t *)&freqTerm,                         	pt_float,       t_iq_none,      t_iq10,         "freqT"              }, \
+{(uint8_t *)&ADC_sf[0][0],                      pt_int16,       t_iq_none,      t_iq_none,      "ADC_sf00"           }, \
+{(uint8_t *)&ADC_sf[0][1],                      pt_int16,       t_iq_none,      t_iq_none,      "ADC_sf01"           }, \
+{(uint8_t *)&ADC_sf[0][2],                      pt_int16,       t_iq_none,      t_iq_none,      "ADC_sf02"           }, \
+{(uint8_t *)&ADC_sf[0][3],                      pt_int16,       t_iq_none,      t_iq_none,      "ADC_sf03"           }, \
+{(uint8_t *)&Bender[0].KOhms,                   pt_uint16,      t_iq,      		t_iq10,      	"Bend0.KOhm"         }, \
+{(uint8_t *)&Bender[0].Times,                   pt_uint16,      t_iq_none,      t_iq_none,      "Bend0.Time"         }, \
+};

parse_xml/Src/parse_xml.py

@@ -1,417 +0,0 @@
-# pyinstaller --onefile --distpath ./parse_xml --workpath ./parse_xml/build --specpath ./build parse_xml/Src/parse_xml.py
-# python -m nuitka --standalone --onefile --output-dir=./parse_xml parse_xml/Src/parse_xml.py
-import xml.etree.ElementTree as ET
-import xml.dom.minidom
-import sys
-import os
-
-
-
-if len(sys.argv) < 3:
-    print("Usage: python parse_xml.exe <input.xml> <info.txt> [output.xml]")
-    sys.exit(1)
-
-input_path = sys.argv[1]
-info_path = sys.argv[2]
-
-base_type_sizes = {
-    "char": 2,
-    "short": 2,
-    "int": 2,
-    "long": 4,
-    "long long": 8,
-    "float": 4,
-    "double": 8,
-}
-
-if len(sys.argv) >= 4:
-    output_path = sys.argv[3]
-else:
-    input_dir = os.path.dirname(os.path.abspath(input_path))
-    output_path = os.path.join(input_dir, "simplified.xml")
-
-tree = ET.parse(input_path)
-root = tree.getroot()
-
-def extract_timestamp(info_path):
-    with open(info_path, "r", encoding="utf-8") as f:
-        for line in f:
-            if "Time Stamp:" in line:
-                parts = line.split("Time Stamp:")
-                if len(parts) > 1:
-                    timestamp = parts[1].strip()
-                    return timestamp
-
-
-
-die_by_id = {die.attrib.get("id"): die for die in root.iter("die") if "id" in die.attrib}
-
-def get_attr(die, attr_type):
-    for attr in die.findall("attribute"):
-        type_elem = attr.find("type")
-        if type_elem is not None and type_elem.text == attr_type:
-            return attr.find("value")
-    return None
-
-def get_die_size(die):
-    """Вернуть размер DIE в байтах из атрибута DW_AT_byte_size или по ключевым словам имени типа."""
-
-    # Сначала пытаемся получить размер из DW_AT_byte_size
-    for attr in die.findall("attribute"):
-        type_elem = attr.find("type")
-        if type_elem is not None and type_elem.text == "DW_AT_byte_size":
-            const_elem = attr.find("value/const")
-            if const_elem is not None:
-                return int(const_elem.text, 0)
-
-    # Если не нашли, пробуем определить размер по ключевым словам в имени типа
-    name_elem = die.find("attribute[@name='DW_AT_name']/value/const")
-    if name_elem is not None:
-        type_name = name_elem.text.lower()
-
-        for key, size in base_type_sizes.items():
-            if key in type_name:
-                return size
-
-    return None
-
-def resolve_type_die(type_id):
-    """Получить DIE типа, разрешая typedef, const и volatile."""
-    visited = set()
-    while type_id and type_id not in visited:
-        visited.add(type_id)
-        die = die_by_id.get(type_id)
-        if die is None:
-            return None
-        tag = die.findtext("tag")
-        if tag in ("DW_TAG_volatile_type", "DW_TAG_const_type", "DW_TAG_typedef", "DW_TAG_TI_far_type"):
-            ref = get_attr(die, "DW_AT_type")
-            if ref is not None and ref.find("ref") is not None:
-                type_id = ref.find("ref").attrib.get("idref")
-            else:
-                return None
-        else:
-            return die
-    return None
-
-# Словарь для простых базовых типов по тегам (пример)
-base_types_map = {
-    "DW_TAG_base_type": lambda die: die.find("attribute[@type='DW_AT_name']/value/string").text if die.find("attribute[@type='DW_AT_name']/value/string") is not None else "unknown",
-    "DW_TAG_structure_type": lambda die: "struct",
-    "DW_TAG_union_type": lambda die: "union",
-    "DW_TAG_pointer_type": lambda die: "pointer",
-    "DW_TAG_array_type": lambda die: "array",
-}
-
-def get_type_name(type_id):
-    die = resolve_type_die(type_id)
-    if die is None:
-        return "unknown"
-
-    tag = die.findtext("tag")
-
-    if tag == "DW_TAG_pointer_type":
-        ref = get_attr(die, "DW_AT_type")
-        if ref is not None and ref.find("ref") is not None:
-            pointee_id = ref.find("ref").attrib.get("idref")
-            name = get_type_name(pointee_id)
-            return name + "*" if name != "unknown" else name
-        else:
-            return "void*"
-
-    elif tag == "DW_TAG_base_type":
-        name_attr = get_attr(die, "DW_AT_name")
-        if name_attr is not None:
-            return name_attr.findtext("string")
-        else:
-            return "base_type_unknown"
-
-    elif tag == "DW_TAG_structure_type":
-        name_attr = get_attr(die, "DW_AT_name")
-        name = name_attr.findtext("string") if name_attr is not None else "anonymous_struct"
-        return f"struct {name}"
-
-    elif tag == "DW_TAG_union_type":
-        name_attr = get_attr(die, "DW_AT_name")
-        name = name_attr.findtext("string") if name_attr is not None else "anonymous_union"
-        return f"union {name}"
-
-    elif tag == "DW_TAG_array_type":
-        ref = get_attr(die, "DW_AT_type")
-        if ref is not None and ref.find("ref") is not None:
-            element_type_id = ref.find("ref").attrib.get("idref")
-            element_type_name = get_type_name(element_type_id)
-            return f"{element_type_name}[]"
-        else:
-            return "array[]"
-
-    # Добавляем поддержку enum
-    elif tag == "DW_TAG_enumeration_type":
-        name_attr = get_attr(die, "DW_AT_name")
-        name = name_attr.findtext("string") if name_attr is not None else "anonymous_enum"
-        return f"enum {name}"
-    
-    else:
-        return "unknown"
-
-def parse_offset(offset_text):
-    if offset_text and offset_text.startswith("DW_OP_plus_uconst "):
-        return int(offset_text.split()[-1], 0)
-    return 0
-
-
-
-def get_base_type_die(array_die):
-    """Спускаемся по цепочке DW_AT_type, пока не дойдем до не-массива (базового типа)."""
-    current_die = array_die
-    while True:
-        ref = get_attr(current_die, "DW_AT_type")
-        if ref is None or ref.find("ref") is None:
-            break
-        next_die = resolve_type_die(ref.find("ref").attrib.get("idref"))
-        if next_die is None:
-            break
-        if next_die.findtext("tag") == "DW_TAG_array_type":
-            current_die = next_die
-        else:
-            return next_die
-    return current_die
-
-def get_array_dimensions(array_die):
-    dims = []
-    # Итерируем по всем DIE с тегом DW_TAG_subrange_type, потомки текущего массива
-    for child in array_die.findall("die"):
-        if child.findtext("tag") != "DW_TAG_subrange_type":
-            continue
-
-        dim_size = None
-        ub_attr = get_attr(child, "DW_AT_upper_bound")
-        if ub_attr is not None:
-            # Попробуем разные варианты получить значение upper_bound
-            # 1) value/const
-            val_const = ub_attr.find("const")
-            if val_const is not None:
-                try:
-                    dim_size = int(val_const.text, 0) + 1
-                    #print(f"[DEBUG] Found DW_AT_upper_bound const: {val_const.text}, size={dim_size}")
-                except Exception as e:
-                    a=1#print(f"[WARN] Error parsing upper_bound const: {e}")
-            else:
-                # 2) value/block (DW_OP_constu / DW_OP_plus_uconst, etc.)
-                val_block = ub_attr.find("block")
-                if val_block is not None:
-                    block_text = val_block.text
-                    # Можно попытаться парсить DWARF expr (например DW_OP_plus_uconst 7)
-                    if block_text and "DW_OP_plus_uconst" in block_text:
-                        try:
-                            parts = block_text.split()
-                            val = int(parts[-1], 0)
-                            dim_size = val + 1
-                            #print(f"[DEBUG] Parsed upper_bound block: {val} + 1 = {dim_size}")
-                        except Exception as e:
-                            a=1#print(f"[WARN] Error parsing upper_bound block: {e}")
-                    else:
-                        a=1#print(f"[WARN] Unexpected DW_AT_upper_bound block content: {block_text}")
-                else:
-                    a=1#print(f"[WARN] DW_AT_upper_bound has no const or block value")
-        
-        if dim_size is None:
-            # fallback по DW_AT_count — редко встречается
-            ct_attr = get_attr(child, "DW_AT_count")
-            if ct_attr is not None:
-                val_const = ct_attr.find("value/const")
-                if val_const is not None:
-                    try:
-                        dim_size = int(val_const.text, 0)
-                        #print(f"[DEBUG] Found DW_AT_count: {dim_size}")
-                    except Exception as e:
-                        a=1#print(f"[WARN] Error parsing DW_AT_count const: {e}")
-
-        if dim_size is None:
-            print("[DEBUG] No dimension size found for this subrange, defaulting to 0")
-            dim_size = 0
-
-        dims.append(dim_size)
-
-    # Если не нашли измерений — пытаемся вычислить размер массива по общему размеру
-    if not dims:
-        arr_size = get_die_size(array_die)
-        elem_size = None
-        element_type_ref = get_attr(array_die, "DW_AT_type")
-        if element_type_ref is not None and element_type_ref.find("ref") is not None:
-            element_type_id = element_type_ref.find("ref").attrib.get("idref")
-            elem_die = resolve_type_die(element_type_id)
-            if elem_die is not None:
-                elem_size = get_die_size(elem_die)
-                #print(f"[DEBUG] Fallback: arr_size={arr_size}, elem_size={elem_size}")
-
-        if arr_size is not None and elem_size:
-            dim_calc = arr_size // elem_size
-            dims.append(dim_calc)
-            #print(f"[DEBUG] Calculated dimension size from total size: {dim_calc}")
-        else:
-            dims.append(0)
-            print("[DEBUG] Could not calculate dimension size, set 0")
-
-    # Рекурсивно обрабатываем вложенные массивы
-    element_type_ref = get_attr(array_die, "DW_AT_type")
-    if element_type_ref is not None and element_type_ref.find("ref") is not None:
-        element_type_id = element_type_ref.find("ref").attrib.get("idref")
-        element_type_die = resolve_type_die(element_type_id)
-        if element_type_die is not None and element_type_die.findtext("tag") == "DW_TAG_array_type":
-            dims.extend(get_array_dimensions(element_type_die))
-
-    #print(f"[DEBUG] Array dimensions: {dims}")
-    return dims
-
-
-
-def handle_array_type(member_elem, resolved_type, offset=0):
-    dims = get_array_dimensions(resolved_type)
-
-    base_die = get_base_type_die(resolved_type)
-    base_name = "unknown"
-    base_size = None
-    if base_die is not None:
-        base_id = base_die.attrib.get("id")
-        if base_id:
-            base_name = get_type_name(base_id)
-            base_size = get_die_size(base_die)
-        else:
-            base_name = get_type_name(base_die.attrib.get("id", ""))
-    #print(f"[DEBUG] Base type name: {base_name}, base size: {base_size}")
-
-    member_elem.set("type", base_name + "[]" * len(dims))
-
-    if base_size is None:
-        base_size = 0
-
-    total_elements = 1
-    for d in dims:
-        if d == 0:
-            total_elements = 0
-            print(f"[WARN] Dimension size is zero, setting total elements to 0")
-            break
-        total_elements *= d
-
-    total_size = total_elements * base_size if base_size is not None else 0
-    if total_size:
-        member_elem.set("size", str(base_size if base_size is not None else 1))
-    else:
-        arr_size = get_die_size(resolved_type)
-        if arr_size:
-            member_elem.set("size", str(arr_size))
-            #print(f"[DEBUG] Used fallback size from resolved_type: {arr_size}")
-        else:
-            print(f"[WARN] Could not determine total size for array")
-
-    for i, dim in enumerate(dims, 1):
-        member_elem.set(f"size{i}", str(dim))
-        #print(f"[DEBUG] Setting size{i} = {dim}")
-
-    member_elem.set("kind", "array")
-
-    if base_die is not None and base_die.findtext("tag") == "DW_TAG_structure_type":
-        add_members_recursive(member_elem, base_die, offset)
-
-
-
-
-
-def add_members_recursive(parent_elem, struct_die, base_offset=0):
-    is_union = struct_die.findtext("tag") == "DW_TAG_union_type"
-    size = get_die_size(struct_die)
-    if size is not None:
-        parent_elem.set("size", hex(size))
-
-    for member in struct_die.findall("die"):
-        if member.findtext("tag") != "DW_TAG_member":
-            continue
-
-        name_attr = get_attr(member, "DW_AT_name")
-        offset_attr = get_attr(member, "DW_AT_data_member_location")
-        type_attr = get_attr(member, "DW_AT_type")
-        if name_attr is None or offset_attr is None or type_attr is None:
-            continue
-
-        name = name_attr.findtext("string")
-        offset = parse_offset(offset_attr.findtext("block")) + base_offset
-        type_id = type_attr.find("ref").attrib.get("idref")
-        resolved_type = resolve_type_die(type_id)
-        type_name = get_type_name(type_id)
-        if type_name == "unknown":
-            continue
-
-        member_elem = ET.SubElement(parent_elem, "member", name=name, offset=hex(offset), type=type_name)
-        if is_union:
-            member_elem.set("kind", "union")
-
-        if resolved_type is not None:
-            tag = resolved_type.findtext("tag")
-            if tag == "DW_TAG_array_type":
-                handle_array_type(member_elem, resolved_type, offset)
-            elif tag in ("DW_TAG_structure_type", "DW_TAG_union_type"):
-                member_elem.set("type", type_name)
-                add_members_recursive(member_elem, resolved_type, offset)
-            elif tag == "DW_TAG_pointer_type":
-                # Проверяем тип, на который указывает указатель
-                pointee_ref = get_attr(resolved_type, "DW_AT_type")
-                if pointee_ref is not None and pointee_ref.find("ref") is not None:
-                    pointee_id = pointee_ref.find("ref").attrib.get("idref")
-                    pointee_die = resolve_type_die(pointee_id)
-                    if pointee_die is not None:
-                        pointee_tag = pointee_die.findtext("tag")
-                        if pointee_tag in ("DW_TAG_structure_type", "DW_TAG_union_type"):
-                            # Добавляем подэлементы для структуры, на которую указывает указатель
-                            pointer_elem = ET.SubElement(member_elem, "pointee", type=get_type_name(pointee_id))
-                            add_members_recursive(pointer_elem, pointee_die, 0)
-
-
-
-output_root = ET.Element("variables")
-for die in root.iter("die"):
-    if die.findtext("tag") != "DW_TAG_variable":
-        continue
-
-    name_attr = get_attr(die, "DW_AT_name")
-    addr_attr = get_attr(die, "DW_AT_location")
-    type_attr = get_attr(die, "DW_AT_type")
-    if name_attr is None or addr_attr is None or type_attr is None:
-        continue
-
-    name = name_attr.findtext("string")
-    if "$" in name:
-        continue
-
-    addr_text = addr_attr.findtext("block")
-    if not addr_text or not addr_text.startswith("DW_OP_addr "):
-        continue
-
-    addr = int(addr_text.split()[-1], 0)
-    type_id = type_attr.find("ref").attrib.get("idref")
-    resolved_type = resolve_type_die(type_id)
-    type_name = get_type_name(type_id)
-    if 0x800 <= addr < 0x8000 or type_name == "unknown":
-        continue
-
-    var_elem = ET.SubElement(output_root, "variable", name=name, address=hex(addr), type=type_name)
-    if resolved_type is not None:
-        tag = resolved_type.findtext("tag")
-        if tag == "DW_TAG_array_type":
-            handle_array_type(var_elem, resolved_type)
-        elif tag in ("DW_TAG_structure_type", "DW_TAG_union_type"):
-            add_members_recursive(var_elem, resolved_type)
-
-timestamp = extract_timestamp(info_path)
-timestamp_elem = ET.Element("timestamp")
-timestamp_elem.text = timestamp
-output_root.insert(0, timestamp_elem)
-
-rough_string = ET.tostring(output_root, encoding="utf-8")
-pretty_xml = xml.dom.minidom.parseString(rough_string).toprettyxml(indent="  ")
-with open(output_path, "w", encoding="utf-8") as f:
-    f.write(pretty_xml)
-
-os.remove(input_path)
-os.remove(info_path)
-print(f"Simplified and formatted XML saved to: {output_path}")