Compare commits
No commits in common. "master" and "v1.1" have entirely different histories.
4
.gitignore
vendored
4
.gitignore
vendored
@ -4,6 +4,4 @@
|
||||
/build_temp
|
||||
/DebugVarEdit_GUI.build
|
||||
/DebugVarEdit_GUI.dist
|
||||
/DebugVarEdit_GUI.onefile-build
|
||||
/parse_xml/build/
|
||||
/parse_xml/Src/__pycache__/
|
||||
/DebugVarEdit_GUI.onefile-build
|
||||
BIN
DebugVarEdit.exe
BIN
DebugVarEdit.exe
Binary file not shown.
Binary file not shown.
142
README.md
142
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 *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);
|
||||
int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr);
|
||||
```
|
||||
|
||||
|
||||
Переменные доступные для чтения определяются в **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)
|
||||
├── DebugVarEdit_GUI.py # Главное окно
|
||||
├── tms_debugvar_term.py # Терминал DebugVarTerminal
|
||||
├── tms_debugvar_lowlevel.py # Виджет для выбора переменных для LowLevel Watch
|
||||
├── var_table.py # Таблица выбранных переменных
|
||||
├── var_selector_window.py # Окно выбора переменных
|
||||
├── var_selector_table.py # Таблица переменных в окне выбора переменных
|
||||
├── scan_progress_gui.py # Отображение процесса сканирования переменных
|
||||
├── scan_vars.py # Сканирование переменных среди .c/.h файлов
|
||||
├── generate_debug_vars.py # Генерация debug_vars.c
|
||||
├── allvars_xml_parser.py # Парсинг XML со всеми переменными и структурами
|
||||
├── csv_logger.py # Логирование переменных в CSV
|
||||
├── myXML.py # Утилиты для XML
|
||||
├── makefile_parser.py # Парсинг makefile на .c/.h файлы
|
||||
├── var_setup.py # Подготовка переменных для окна выбора переменных
|
||||
├── path_hints.py # Подсказки для автодополнения путей переменных
|
||||
├── libclang.dll # Бибилиотека clang
|
||||
├── icon.ico # Иконка
|
||||
|
||||
│ └── build_and_clean.py # Билдинг проекта в .exe (через nuitka или pyinstaller)
|
||||
├── DebugVarEdit_GUI.py # Главное окно
|
||||
├── var_table.py # Таблица выбранных переменных
|
||||
├── var_selector_window.py # Окно выбора переменных
|
||||
├── var_selector_table.py # Таблица переменных в окне выбора переменных
|
||||
├── scan_progress_gui.py # Отображение процесса сканирования переменных
|
||||
├── scan_vars.py # Сканирование переменных среди .c/.h файлов
|
||||
├── generate_debug_vars.py # Генерация debug_vars.c
|
||||
├── myXML.py # Утилиты для XML
|
||||
├── makefile_parser.py # Парсинг makefile на .c/.h файлы
|
||||
├── var_setup.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`.
|
||||
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
# Для разработчиков
|
||||
|
||||
### Структура проекта:
|
||||
@ -6,39 +5,33 @@
|
||||
```bash
|
||||
Src
|
||||
├── build/
|
||||
│ └── build_and_clean.py # Билдинг проекта в .exe (через nuitka или pyinstaller)
|
||||
├── DebugVarEdit_GUI.py # Главное окно
|
||||
├── tms_debugvar_term.py # Терминал DebugVarTerminal
|
||||
├── tms_debugvar_lowlevel.py # Виджет для выбора переменных для LowLevel Watch
|
||||
├── var_table.py # Таблица выбранных переменных
|
||||
├── var_selector_window.py # Окно выбора переменных
|
||||
├── var_selector_table.py # Таблица переменных в окне выбора переменных
|
||||
├── scan_progress_gui.py # Отображение процесса сканирования переменных
|
||||
├── scan_vars.py # Сканирование переменных среди .c/.h файлов
|
||||
├── generate_debug_vars.py # Генерация debug_vars.c
|
||||
├── allvars_xml_parser.py # Парсинг XML со всеми переменными и структурами
|
||||
├── csv_logger.py # Логирование переменных в CSV
|
||||
├── myXML.py # Утилиты для XML
|
||||
├── makefile_parser.py # Парсинг makefile на .c/.h файлы
|
||||
├── var_setup.py # Подготовка переменных для окна выбора переменных
|
||||
├── path_hints.py # Подсказки для автодополнения путей переменных
|
||||
├── libclang.dll # Бибилиотека clang
|
||||
├── icon.ico # Иконка
|
||||
|
||||
│ └── build_and_clean.py # Билдинг проекта в .exe (через nuitka или pyinstaller)
|
||||
├── DebugVarEdit_GUI.py # Главное окно
|
||||
├── var_table.py # Таблица выбранных переменных
|
||||
├── var_selector_window.py # Окно выбора переменных
|
||||
├── var_selector_table.py # Таблица переменных в окне выбора переменных
|
||||
├── scan_progress_gui.py # Отображение процесса сканирования переменных
|
||||
├── scan_vars.py # Сканирование переменных среди .c/.h файлов
|
||||
├── generate_debug_vars.py # Генерация debug_vars.c
|
||||
├── myXML.py # Утилиты для XML
|
||||
├── makefile_parser.py # Парсинг makefile на .c/.h файлы
|
||||
├── var_setup.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
|
||||
```
|
||||
@ -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
|
||||
@ -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",
|
||||
MAIN_SCRIPT_NAME + ".onefile-build",
|
||||
MAIN_SCRIPT_NAME + ".dist"
|
||||
"DebugVarEdit_GUI.build",
|
||||
"DebugVarEdit_GUI.onefile-build",
|
||||
"DebugVarEdit_GUI.dist"
|
||||
]
|
||||
# === Пути к DLL и прочим зависимостям ===
|
||||
LIBS = {
|
||||
|
||||
@ -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))
|
||||
|
||||
@ -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
|
||||
@ -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_())
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,64 +1,86 @@
|
||||
# variable_select_widget.py
|
||||
import pickle
|
||||
import hashlib
|
||||
from typing import List, Dict, Any, Optional
|
||||
|
||||
import re
|
||||
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: List[Dict[str, Any]] = []
|
||||
self.is_autocomplete_on = True
|
||||
self.manual_completion_active = False
|
||||
self.expanded_vars = []
|
||||
self.node_index = {}
|
||||
self.is_autocomplete_on = True # <--- ДОБАВИТЬ ЭТУ СТРОКУ
|
||||
self._bckspc_pressed = False
|
||||
self._vars_hash: Optional[str] = None
|
||||
self.manual_completion_active = False
|
||||
self._vars_hash = None
|
||||
|
||||
# индекс: canonical_full_path -> item
|
||||
self._item_by_canon: Dict[str, QTreeWidgetItem] = {}
|
||||
|
||||
# подсказки
|
||||
self.hints = PathHints()
|
||||
|
||||
# --- UI ---
|
||||
# --- 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
|
||||
lay = QVBoxLayout(self)
|
||||
lay.setContentsMargins(0, 0, 0, 0)
|
||||
lay.addWidget(self.search_input)
|
||||
lay.addWidget(self.tree)
|
||||
|
||||
# signals
|
||||
self.search_input.textChanged.connect(self.on_search_text_changed)
|
||||
# --- Layout ---
|
||||
layout = QVBoxLayout(self)
|
||||
layout.setContentsMargins(0, 0, 0, 0)
|
||||
layout.addWidget(self.search_input)
|
||||
layout.addWidget(self.tree)
|
||||
|
||||
# --- Соединения ---
|
||||
#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]]):
|
||||
"""
|
||||
Загружаем список переменных (формат: см. класс docstring).
|
||||
"""
|
||||
# deepcopy
|
||||
def set_data(self, vars_list):
|
||||
"""Основной метод для загрузки данных в виджет."""
|
||||
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 из входного списка: определяем по глубине токенов
|
||||
# (vars_list может содержать и глубокие узлы; выберем корни = те, чей full_path не имеет родителя в списке)
|
||||
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)
|
||||
for var in vars_list:
|
||||
self.add_tree_item_lazy(None, var)
|
||||
|
||||
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 []:
|
||||
self._add_tree_item_lazy(item, ch)
|
||||
for child_var in var.get('children', []):
|
||||
self.add_tree_item_lazy(item, child_var)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# item creation (var['name'] — ПОЛНЫЙ ПУТЬ)
|
||||
# ------------------------------------------------------------------
|
||||
def _add_tree_item_lazy(self, parent: Optional[QTreeWidgetItem], var: Dict[str, Any]):
|
||||
full_path = var.get('name', '')
|
||||
|
||||
def get_full_item_name(self, item):
|
||||
fullname = item.text(0)
|
||||
# Заменяем '->' на '.'
|
||||
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([full_path, type_str])
|
||||
item.setData(0, self.ROLE_NAME, full_path) # теперь ROLE_NAME = полный путь
|
||||
item.setData(0, self.ROLE_VAR_DICT, var)
|
||||
item.setData(0, self.ROLE_FULLPATH, full_path)
|
||||
item = QTreeWidgetItem([name, type_str])
|
||||
item.setData(0, Qt.UserRole, name)
|
||||
full_name = self.get_full_item_name(item)
|
||||
self.node_index[full_name.lower()] = item
|
||||
|
||||
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:
|
||||
toks = split_path_tokens(full_path)
|
||||
return toks[-1] if toks else full_path
|
||||
|
||||
def show_matching_path(self, item, path_parts, level=0):
|
||||
node_name = item.text(0).lower()
|
||||
node_parts = split_path(node_name)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# filtering
|
||||
# ------------------------------------------------------------------
|
||||
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 'project' in node_name:
|
||||
a = 1
|
||||
|
||||
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)
|
||||
if self._show_matching_path(ch, path_parts, level + 1):
|
||||
child = item.child(i)
|
||||
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):
|
||||
text = self.hints.add_separator(full_path)
|
||||
if not self._bckspc_pressed:
|
||||
def filter_tree(self):
|
||||
text = self.search_input.text().strip().lower()
|
||||
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 not self.manual_completion_active:
|
||||
self.completer.popup().hide()
|
||||
return
|
||||
self.update_completions(text)
|
||||
if not self.is_autocomplete_on and self._bckspc_pressed:
|
||||
text = text[:-1]
|
||||
|
||||
if len(completions) == 1 and completions[0].lower() == text.lower():
|
||||
# Найдем узел с таким именем
|
||||
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):
|
||||
self.completer.setWidget(self.search_input)
|
||||
node = find_exact_item(completions[0])
|
||||
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:
|
||||
text = self.search_input.text()
|
||||
if text == None:
|
||||
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):
|
||||
self.completer.setWidget(None)
|
||||
self.completer.deleteLater()
|
||||
super().closeEvent(event)
|
||||
def _custom_focus_in_event(self, event):
|
||||
# Принудительно установить виджет для completer при получении фокуса
|
||||
if self.completer.widget() != self.search_input:
|
||||
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))
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# tooltips
|
||||
# ------------------------------------------------------------------
|
||||
def _set_tool(self, item: QTreeWidgetItem, text: str):
|
||||
def build_completion_list(self):
|
||||
completions = []
|
||||
|
||||
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)."""
|
||||
def collect_leaf(parent):
|
||||
leaves = []
|
||||
"""Возвращает все конечные (leaf) элементы, исключая битовые поля и элементы с детьми (реальными)."""
|
||||
def collect_leaf_items(parent):
|
||||
leaf_items = []
|
||||
for i in range(parent.childCount()):
|
||||
ch = parent.child(i)
|
||||
if ch.isHidden():
|
||||
child = parent.child(i)
|
||||
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)
|
||||
if t and 'bitfield' in t.lower():
|
||||
item_type = top.text(1)
|
||||
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))
|
||||
return out
|
||||
all_leaf_items.extend(collect_leaf_items(top))
|
||||
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)))
|
||||
return res
|
||||
for it in selected:
|
||||
all_items.extend(collect(it))
|
||||
child = item.child(i)
|
||||
items.extend(collect_children(child))
|
||||
return items
|
||||
|
||||
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 = []
|
||||
for it in selected:
|
||||
self.on_item_expanded(it)
|
||||
if all(it.child(i).isHidden() or not it.child(i).isSelected() for i in range(it.childCount())):
|
||||
t = it.data(0, self.ROLE_NAME)
|
||||
if t and isinstance(t, str) and 'bitfield' in t.lower():
|
||||
leaf_items = []
|
||||
for item in selected:
|
||||
# Раскрываем lazy, если надо
|
||||
self.on_item_expanded(item)
|
||||
|
||||
# Если у узла нет видимых/выделенных детей — он лист
|
||||
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)
|
||||
return leaves
|
||||
leaf_items.append(item)
|
||||
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)
|
||||
@ -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)
|
||||
|
||||
155
Src/var_table.py
155
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="Укажите размер короткого имени",
|
||||
label_text="Количество символов:"):
|
||||
def __init__(self, parent=None, initial_value=10, min_value=1, max_value=50, title="Укажите размер короткого имени"):
|
||||
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:
|
||||
super().__init__(0, 8, parent)
|
||||
self.setHorizontalHeaderLabels([
|
||||
'№',
|
||||
'En',
|
||||
'Name',
|
||||
'Origin Type',
|
||||
'Base Type',
|
||||
'IQ Type',
|
||||
'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.setHorizontalHeaderLabels([
|
||||
'№', # новый столбец
|
||||
'En',
|
||||
'Name',
|
||||
'Origin Type',
|
||||
'Base Type',
|
||||
'IQ Type',
|
||||
'Return Type',
|
||||
'Short Name'
|
||||
])
|
||||
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
|
||||
and 'struct' not in t and 'union' not in t and '64' not in t]
|
||||
# Фильтруем типы из type_map.values() исключая те, что содержат 'arr' или 'ptr'
|
||||
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_', '')
|
||||
if value not in self.iq_types:
|
||||
ret_combo.addItem(value)
|
||||
value = var['return_type'].replace('t_', '')
|
||||
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)
|
||||
|
||||
# Последний столбец
|
||||
if self._show_value:
|
||||
if self._show_value:
|
||||
val = var.get('value', '')
|
||||
if val is None:
|
||||
val = ''
|
||||
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)
|
||||
# short_name
|
||||
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.check()
|
||||
|
||||
def check(self):
|
||||
@ -327,10 +295,9 @@ class VariableTableWidget(QTableWidget):
|
||||
if not found:
|
||||
color = error_color
|
||||
tooltip = tooltip_missing
|
||||
elif long_shortname:
|
||||
if not self._show_value:
|
||||
color = warning_color
|
||||
tooltip = tooltip_shortname
|
||||
elif long_shortname:
|
||||
color = warning_color
|
||||
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, title="Укажите точность", label_text="Кол-во знаков после запятой", initial_value=3)
|
||||
else:
|
||||
dlg = SetSizeDialog(self)
|
||||
|
||||
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:
|
||||
combo.addItem(current)
|
||||
combo.setCurrentText(current)
|
||||
if current in allowed_items:
|
||||
combo.setCurrentText(current)
|
||||
else:
|
||||
combo.setCurrentIndex(0)
|
||||
combo.blockSignals(False)
|
||||
|
||||
|
||||
|
||||
253
debug_tools.c
253
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)
|
||||
return DEBUG_ERR_INTERNAL;
|
||||
if (debug_ll.isVerified == 0)
|
||||
return DEBUG_ERR_DATATIME;
|
||||
|
||||
if (is_addr_in_allowed_ranges(addr_val, debug_allowed_ranges, debug_allowed_ranges_count) != 0)
|
||||
{
|
||||
return DEBUG_ERR_ADDR; // Çàïðåù¸ííûé àäðåñ — íåëüçÿ ÷èòàòü
|
||||
// Ðàçðåø¸ííûå äèàïàçîíû ïàìÿòè (èç .cmd ôàéëà)
|
||||
if (!(
|
||||
(addr_val <= 0x0007FF) || // RAMM0 + RAMM1
|
||||
(addr_val >= 0x008120 && addr_val <= 0x009FFC) || // L0 + L1 SARAM
|
||||
(addr_val >= 0x3F8000 && addr_val <= 0x3F9FFF) || // PRAMH0 + DRAMH0
|
||||
(addr_val >= 0x3FF000 && addr_val <= 0x3FFFFF) || // BOOTROM + RESET
|
||||
(addr_val >= 0x080002 && addr_val <= 0x09FFFF) || // RAMEX1
|
||||
(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(status != 0)
|
||||
return status;
|
||||
if(getDebugVar(var, &iq_numb, &float_numb) != 0)
|
||||
return 1;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
@ -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);
|
||||
/* ×èòàåò âîçâðàùàåìûé òèï (IQ) ïåðåìåííîé ïî èíäåêñó */
|
||||
int Debug_ReadVarReturnType(int var_ind, int *vartype);
|
||||
/* ×èòàåò òèï ïåðåìåííîé ïî èíäåêñó */
|
||||
int Debug_ReadVarType(int var_ind, int *vartype);
|
||||
|
||||
|
||||
int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr);
|
||||
/* Читает значение переменной с нижнего уровня */
|
||||
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
|
||||
|
||||
23
debug_vars_example.c
Normal file
23
debug_vars_example.c
Normal file
@ -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" }, \
|
||||
};
|
||||
@ -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}")
|
||||
Binary file not shown.
Loading…
Reference in New Issue
Block a user