parser-ci-AP 0.1.0__py3-none-any.whl

parser_ci_AP/__init__.py

@@ -0,0 +1,55 @@
+from .project import Project
+from .project_file import AbstractProjectFile
+from .type_info import BaseTypeInfo
+from .function_info import FunctionInfo
+from .variable_info import VariableInfo
+from .define_info import DefineInfo
+from .errors_info import DiagnosticInfo
+
+__all__ = [
+    "Project",
+    "AbstractProjectFile",
+    "BaseTypeInfo",
+    "FunctionInfo",
+    "VariableInfo",
+    "DefineInfo",
+    "DiagnosticInfo"
+]
+
+
+
+# Что может парсер
+
+# На уровне проекта:
+# 1) Перечислить все пользовательские типы данных (структуры, перечисления, typedef и т.д.);
+# 2) Перечислить все файлы проекта;
+# 3) Подсчитать количество строк (всего / без комментариев / только функциональных);
+# 4) Перечислить все define-ы (макросы) проекта;
+# 5) Перечислить все глобальные переменные проекта;
+# 6) Перечислить все статические переменные проекта;
+# 7) Перечислить все extern-переменные проекта;
+# 8) Перечислить все функции проекта (глобальные и static отдельно);
+# 9) Разделить все define-ы на системные и пользовательские;
+
+# На уровне файла:
+# 1) Перечислить все функции в файле (включая static и обычные);
+# 2) Перечислить все зависимости (файлы, подключённые через #include);
+# 3) Перечислить все переменные в файле (глобальные, static, extern);
+# 4) Перечислить все define-ы в файле;
+# 5) Перечислить все пользовательские типы данных в файле;
+# 6) Подсчитать количество строк (всего / только функциональных);
+# 7) Диагностика кода клангом
+
+# На уровне функции:
+# 1) Перечислить аргументы функции;
+# 2) Перечислить локальные переменные;
+# 3) Имя функции;
+# 4) Получить шапку функции (прототип или полное объявление);
+# 5) Извлечь из проекта весь контекст функции, чтобы можно было запустить её изолированно;
+# 6) Перечислить глобальные переменные, используемые внутри функции;
+# 7) Найти вызовы других функций внутри тела;
+# 8) Определить тип возвращаемого значения;
+# 9) Получить выражение, возвращаемое из функции (например: return x + 1 → "x + 1");
+# 10) Число строк кода
+
+

parser_ci_AP/define_info.py

@@ -0,0 +1,116 @@
+from typing import Optional, List
+from pathlib import Path
+from clang.cindex import Cursor
+
+
+class DefineInfo:
+    def __init__(self, cursor: Cursor, encoding: str):
+        self._cursor = cursor
+        self.name: str = cursor.spelling
+        self.location: Path = (
+            Path(cursor.location.file.name).resolve()
+            if cursor.location.file
+            else Path()
+        )
+        try:
+            self._usr: str = cursor.get_usr()
+        except (AttributeError, TypeError, UnicodeDecodeError):
+            self._usr = f"{self.name}@{self.location}"
+        self.encoding = encoding
+
+        self._raw_line: str
+        self.params: Optional[List[str]]
+        self.value: str
+        self.comment: str
+        self.is_system: bool
+
+        self._raw_line = self._read_raw_line()
+        self.params = self._extract_params()
+        self.value = self._extract_value()
+        self.comment = self._extract_comment_after()
+        self.is_system = self._detect_system_define()  # Дефайны которые не используются кодом напрямую
+
+    def _detect_system_define(self) -> bool:
+        """
+        Определяет, является ли define системным:
+        - начинается с '_'
+        - или у него отсутствует значение (value)
+        """
+        return self.name.startswith("_") or not self.value
+
+    def _read_raw_line(self) -> str:
+        """
+        Считывает строку исходника, содержащую #define.
+        """
+        try:
+            line_num = self._cursor.location.line
+            with open(self.location, "r", encoding=self.encoding, errors="replace") as f:
+                lines = f.readlines()
+                return lines[line_num - 1].strip()
+        except Exception as e:
+            return f"[!] Ошибка чтения строки define {self.name}: {e}"
+
+    def _extract_params(self) -> Optional[List[str]]:
+        """
+        Пытается извлечь параметры, если define является макросом с параметрами.
+        Пример: #define MAX(a, b) ((a) > (b) ? (a) : (b))
+        """
+        try:
+            after_name = self._raw_line.split(self.name, 1)[1].lstrip()
+            if after_name.startswith("("):
+                end_idx = after_name.find(")")
+                if end_idx != -1:
+                    param_str = after_name[1:end_idx]
+                    params = [p.strip() for p in param_str.split(",") if p.strip()]
+                    return params
+        except Exception:
+            pass
+        return None
+
+    def _extract_value(self) -> str:
+        """
+        Извлекает значение define (до начала комментария, если он есть).
+        """
+        try:
+            parts = self._raw_line.split(None, 2)
+            if len(parts) < 3:
+                return ""
+
+            value_part = parts[2]
+            # обрезаем комментарий (если есть)
+            for comment_start in ["//", "/*"]:
+                if comment_start in value_part:
+                    value_part = value_part.split(comment_start, 1)[0].strip()
+            return value_part.strip()
+        except Exception:
+            return ""
+
+    def _extract_comment_after(self) -> str:
+        """
+        Извлекает комментарий после значения define (если он есть).
+        """
+        try:
+            for marker in ["//", "/*"]:
+                if marker in self._raw_line:
+                    return self._raw_line.split(marker, 1)[1].strip()
+            return ""
+        except Exception:
+            return ""
+
+    def describe(self) -> str:
+        loc_str = f"{self.location}:{self._cursor.location.line}"
+        system_flag = "[system] " if self.is_system else ""
+        if self.params:
+            return f"{system_flag}#define {self.name}({', '.join(self.params)}) {self.value}  // from {loc_str}"
+        return f"{system_flag}#define {self.name} {self.value}  // from {loc_str}"
+
+    def __str__(self) -> str:
+        return self.describe()
+
+    def __eq__(self, other):
+        if not isinstance(other, DefineInfo):
+            return False
+        return self._usr == other._usr
+
+    def __hash__(self):
+        return hash(self._usr)

parser_ci_AP/errors_info.py

@@ -0,0 +1,32 @@
+from clang.cindex import Diagnostic
+
+class DiagnosticInfo:
+    def __init__(self, diag: Diagnostic):
+        self.severity = diag.severity  # 1=warning, 2=error, 3=fatal, ...
+        self.spelling = diag.spelling
+        self.location = f"{diag.location.file}:{diag.location.line}"
+        self.category = diag.category_name
+        self.option = diag.option
+
+    def __eq__(self, other):
+        if not isinstance(other, DiagnosticInfo):
+            return False
+        return (
+            self.severity == other.severity and
+            self.spelling == other.spelling and
+            self.location == other.location and
+            self.category == other.category and
+            self.option == other.option
+        )
+
+    def __hash__(self):
+        return hash((
+            self.severity,
+            self.spelling,
+            self.location,
+            self.category,
+            self.option
+        ))
+
+    def __str__(self):
+        return f"[{self.severity}] {self.location}: {self.spelling}"

parser_ci_AP/function_info.py

@@ -0,0 +1,278 @@
+from clang.cindex import Cursor, CursorKind, StorageClass
+from pathlib import Path
+import re
+from typing import Set, Optional
+
+from .variable_info import VariableInfo
+
+class FunctionInfo:
+    def __init__(self, cursor: Cursor, encoding: str):
+        self._cursor = cursor
+        self.name = cursor.spelling
+        self.location = Path(cursor.location.file.name).resolve() if cursor.location.file else Path()
+        try:
+            self._usr = cursor.get_usr()  # Уникальный идентификатор функции
+        except Exception:
+            self._usr = f"{self.name}@{self.location}"
+        self.encoding = encoding
+
+        self.return_var: Optional[ReturnInfo] = None
+        self.args: list[VariableInfo] = []
+        self.source_text: str
+        self.is_static: bool = False
+        self.comment: str
+        self.lines_functional: int
+        self.local_variables: list[VariableInfo] = []
+        self.called_funcs: Set[str] = set()
+        self.lines_pure_code: int
+
+        self.source_text = self._extract_source_text()
+        self.comment = self._extract_comments()
+        self._count_functional_lines()
+        self._extract_args()
+        self.external_variables = set()
+        self._extract_external_variables()
+        self.return_var = self._extract_return_variable()
+        self._detect_static()
+        self._count_pure_code_lines()
+
+        self._extract_from_cursor()
+
+    def _count_pure_code_lines(self):
+        """
+        Подсчитывает количество строк, содержащих только чистый код:
+        - без комментариев (// и /* */)
+        - без пустых строк
+        """
+        code = self.source_text
+
+        # Удаляем многострочные комментарии
+        code = re.sub(r"/\*.*?\*/", "", code, flags=re.DOTALL)
+
+        # Удаляем однострочные комментарии
+        code = re.sub(r"//.*", "", code)
+
+        # Оставляем только строки с кодом
+        self.lines_pure_code = sum(1 for line in code.splitlines() if line.strip())
+
+    def _extract_return_variable(self) -> Optional["ReturnInfo"]:
+        """
+        Извлекает информацию о возвращаемом значении функции:
+        - тип возврата
+        - выражение после return (если есть)
+        """
+        return_type = self._cursor.result_type.spelling
+        return_expr = None
+
+        def visit(node: Cursor):
+            nonlocal return_expr
+            if node.kind.name == "RETURN_STMT":
+                tokens = [t.spelling for t in node.get_tokens()]
+                if len(tokens) > 1:
+                    return_expr = " ".join(tokens[1:])  # Пропускаем 'return'
+            for child in node.get_children():
+                visit(child)
+
+        visit(self._cursor)
+
+        if return_expr is None:
+            return None
+        return ReturnInfo(return_type, return_expr)
+
+    def _detect_static(self):
+        """
+        Определяет, является ли функция статической, используя только canonical-курсоры.
+        """
+        try:
+            canonical = self._cursor.canonical
+            if canonical and canonical.storage_class == StorageClass.STATIC:
+                self.is_static = True
+        except Exception:
+            pass
+
+        return False
+
+    def _extract_args(self):
+        """
+        Извлекает аргументы функции как объекты VariableInfo.
+        """
+        self.args = []
+        for arg in self._cursor.get_arguments():
+            if arg.kind == CursorKind.PARM_DECL and arg.spelling:
+                self.args.append(VariableInfo(arg, self.encoding))
+
+    def _extract_source_text(self):
+        extent = self._cursor.extent
+        start = extent.start
+        end = extent.end
+
+        def extract_lines(lines):
+            lines = lines[start.line - 1:end.line]
+            lines[0] = lines[0][start.column - 1:]
+            lines[-1] = lines[-1][:end.column - 1]
+            return "".join(lines).strip()
+
+        try:
+            with open(self.location, "r", encoding=self.encoding, errors="replace") as f:
+                return extract_lines(f.readlines())
+        except Exception as e:
+            return f"[!] Ошибка извлечения текста функции {self.name}: {e}"
+
+    def _extract_comments(self) -> str:
+        """
+        Пытается извлечь комментарии, расположенные перед началом функции.
+        Поддерживает:
+          - однострочные // и ///
+          - многострочные /* ... */
+        Останавливается при встрече пустой строки.
+        """
+        try:
+            with open(self.location, "r", encoding=self.encoding, errors="replace") as f:
+                lines = f.readlines()
+
+            start_line = self._cursor.extent.start.line
+            comments = []
+            inside_block = False
+
+            for i in range(start_line - 2, -1, -1):
+                line = lines[i].rstrip()
+
+                if not line.strip() and not inside_block:
+                    break  # пустая строка прерывает комментарий
+
+                # Обрабатываем многострочные комментарии (/* ... */)
+                if "*/" in line:
+                    inside_block = True
+                    comments.insert(0, line)
+                    continue
+
+                if inside_block:
+                    comments.insert(0, line)
+                    if "/*" in line:
+                        inside_block = False
+                    continue
+
+                # Однострочные комментарии
+                stripped = line.strip()
+                if stripped.startswith("//") or stripped.startswith("///"):
+                    comments.insert(0, line)
+                    continue
+
+                break  # не комментарий и не внутри блока — прерываем
+
+            return "\n".join(comments).strip()
+
+        except Exception as e:
+            return f"[!] Ошибка при извлечении комментариев функции {self.name}: {e}"
+
+    def _count_functional_lines(self):
+        """
+        Подсчитывает количество строк с функциональным кодом.
+        Убирает комментарии `//`, `/* */` и пустые строки.
+        """
+        code = self.source_text
+
+        # Удаляем многострочные комментарии (включая переносы строк)
+        code = re.sub(r'/\*.*?\*/', '', code, flags=re.DOTALL)
+
+        # Удаляем однострочные комментарии
+        code = re.sub(r'//.*', '', code)
+
+        # Разбиваем на строки и фильтруем только те, что содержат код
+        lines = code.splitlines()
+        functional_lines = [line for line in lines if line.strip()]  # только непустые
+
+        self.lines_functional = len(functional_lines)
+
+    def _extract_from_cursor(self):
+
+        def visit(node: Cursor):
+            if node.kind == CursorKind.VAR_DECL:
+                self.local_variables.append(VariableInfo(node, self.encoding))
+            elif node.kind == CursorKind.CALL_EXPR:
+                called_name = node.spelling or node.displayname or "<unnamed_call>"
+                self.called_funcs.add(called_name)
+
+            for child in node.get_children():
+                visit(child)
+
+        visit(self._cursor)
+
+    def _extract_external_variables(self):
+        """
+        Находит все переменные, которые используются в функции, но не являются:
+        - её аргументами
+        - локальными переменными
+
+        Это потенциально глобальные или внешние переменные.
+        """
+        local_and_args = {var.name for var in self.local_variables}
+        local_and_args.update(arg.name for arg in self.args)
+
+        external_vars = set()
+
+        def visit(node: Cursor):
+            if node.kind == CursorKind.DECL_REF_EXPR:
+                name = node.spelling
+                if name and name not in local_and_args:
+                    external_vars.add(name)
+
+            for child in node.get_children():
+                visit(child)
+
+        visit(self._cursor)
+
+        self.external_variables = external_vars
+
+    def describe(self):
+        out = [f"Function: {self.name} ({self.location})"]
+        out.append(f"  Return type: {self.return_var}")
+        out.append(f"  Static: {'yes' if self.is_static else 'no'}")
+        out.append(f"  Functional lines: {self.lines_functional}")
+
+
+        if self.local_variables:
+            out.append("  Local variables:")
+            for var in self.local_variables:
+                out.append(f"    - {var['type']} {var['name']}")
+
+        out.append("  Arguments:")
+        for arg in self.args:
+            out.append(f"    - {arg['type']} {arg['name']}")
+
+        if self.called_funcs:
+            out.append("  Called functions:")
+            for name in self.called_funcs:
+                out.append(f"    - {name}")
+
+        if self.external_variables:
+            out.append(f"  External variables:")
+            for name in self.external_variables:
+                out.append(f"    - {name}")
+
+        return "\n".join(out)
+
+    def __str__(self):
+        return self.describe()
+
+    def __eq__(self, other):
+        if not isinstance(other, FunctionInfo):
+            return False
+        return self._usr == other._usr
+
+    def __hash__(self):
+        return hash(self._usr)
+
+class ReturnInfo:
+    def __init__(self, return_type: str, expression: Optional[str] = None):
+        self.type = return_type
+        self.expression = expression
+
+    def describe(self) -> str:
+        desc = f"Return type: {self.type}"
+        if self.expression:
+            desc += f", returns: {self.expression}"
+        return desc
+
+    def __str__(self):
+        return self.describe()

parser_ci_AP/logger.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger("parser_ci_AP")