Files
SPHLite/tools/testing/check_source_size.py
T
2026-07-02 19:50:44 +08:00

132 lines
4.3 KiB
Python

from __future__ import annotations
import argparse
import re
from pathlib import Path
FORTRAN_FILE_MAX_LINES = 700
C_FILE_MAX_LINES = 500
PYTHON_FILE_MAX_LINES = 500
FORTRAN_PROCEDURE_MAX_LINES = 140
def read_exceptions(path: Path) -> set[str]:
exceptions: set[str] = set()
if not path.exists():
raise SystemExit(f"exception file does not exist: {path}")
for raw in path.read_text(encoding="utf-8").splitlines():
line = raw.strip()
if not line or line.startswith("#"):
continue
exceptions.add(line.split()[0].replace("\\", "/"))
return exceptions
def source_files(root: Path) -> list[Path]:
skip_dirs = {".git", ".agents", ".codex"}
result: list[Path] = []
for path in root.rglob("*"):
if not path.is_file():
continue
rel_path = path.relative_to(root)
rel_parts = set(rel_path.parts)
if rel_parts & skip_dirs:
continue
if rel_path.parts and rel_path.parts[0].startswith("build"):
continue
if path.suffix.lower() in {".f90", ".c", ".cpp", ".h", ".hpp", ".py"}:
result.append(path)
return sorted(result)
def rel_key(root: Path, path: Path) -> str:
return path.relative_to(root).as_posix()
def check_file_lines(root: Path, path: Path, exceptions: set[str], errors: list[str]) -> None:
rel = rel_key(root, path)
lines = path.read_text(encoding="utf-8").splitlines()
suffix = path.suffix.lower()
if suffix in {".f90"}:
limit = FORTRAN_FILE_MAX_LINES
elif suffix in {".c", ".cpp", ".h", ".hpp"}:
limit = C_FILE_MAX_LINES
elif suffix == ".py":
limit = PYTHON_FILE_MAX_LINES
else:
return
if len(lines) > limit and rel not in exceptions:
errors.append(f"{rel}: {len(lines)} lines exceeds limit {limit}")
def check_fortran_procedures(root: Path, path: Path, exceptions: set[str], errors: list[str]) -> None:
rel = rel_key(root, path)
lines = path.read_text(encoding="utf-8").splitlines()
start_re = re.compile(r"^\s*(subroutine|function|program)\s+([a-zA-Z_][a-zA-Z0-9_]*)", re.I)
end_re = re.compile(r"^\s*end\s+(subroutine|function|program)\b", re.I)
active_name: str | None = None
active_start = 0
for index, line in enumerate(lines, start=1):
if active_name is None:
match = start_re.match(line)
if match:
active_name = match.group(2)
active_start = index
continue
if end_re.match(line):
size = index - active_start + 1
key = f"{rel}:{active_name}"
if size > FORTRAN_PROCEDURE_MAX_LINES and key not in exceptions:
errors.append(
f"{key}: {size} lines exceeds procedure limit "
f"{FORTRAN_PROCEDURE_MAX_LINES}"
)
active_name = None
def check_stale_exceptions(root: Path, exceptions: set[str], files: list[Path], errors: list[str]) -> None:
file_keys = {rel_key(root, path) for path in files}
possible_keys = set(file_keys)
for path in files:
if path.suffix.lower() == ".f90":
text = path.read_text(encoding="utf-8")
for match in re.finditer(
r"^\s*(subroutine|function|program)\s+([a-zA-Z_][a-zA-Z0-9_]*)",
text,
re.I | re.M,
):
possible_keys.add(f"{rel_key(root, path)}:{match.group(2)}")
for item in exceptions:
if item not in possible_keys:
errors.append(f"stale source size exception: {item}")
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--root", required=True)
parser.add_argument("--exceptions", required=True)
args = parser.parse_args()
root = Path(args.root).resolve()
exceptions = read_exceptions(Path(args.exceptions).resolve())
files = source_files(root)
errors: list[str] = []
for path in files:
check_file_lines(root, path, exceptions, errors)
if path.suffix.lower() == ".f90":
check_fortran_procedures(root, path, exceptions, errors)
check_stale_exceptions(root, exceptions, files, errors)
if errors:
for error in errors:
print(error)
return 1
return 0
if __name__ == "__main__":
raise SystemExit(main())