cifter-cli 0.1.0__py3-none-any.whl

cifter/__init__.py

@@ -0,0 +1,3 @@
+from cifter.cli import main
+
+__all__ = ["main"]

cifter/__main__.py

@@ -0,0 +1,4 @@
+from cifter.cli import main
+
+if __name__ == "__main__":
+    main()

cifter/cli.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from cifter.errors import CiftError
+from cifter.extract_flow import extract_flow
+from cifter.extract_function import extract_function
+from cifter.extract_path import extract_path
+from cifter.model import TrackPath
+from cifter.parser import parse_source
+from cifter.render import render_result
+
+app = typer.Typer(no_args_is_help=True, help="C/C++ の関数実装を抽出する CLI")
+
+
+def main() -> None:
+    app()
+
+
+SourceOption = Annotated[
+    Path,
+    typer.Option(
+        "--source",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+        resolve_path=True,
+        help="解析するソースファイル",
+    ),
+]
+
+
+@app.command("function")
+def function_command(
+    name: Annotated[str, typer.Option("--name", help="抽出する関数名")],
+    source: SourceOption,
+    defines: Annotated[
+        list[str] | None,
+        typer.Option("--define", "-D", help="条件分岐評価に使うマクロ定義"),
+    ] = None,
+) -> None:
+    _run(lambda: render_result(extract_function(parse_source(source, defines or []), name)))
+
+
+@app.command("flow")
+def flow_command(
+    function_name: Annotated[str, typer.Option("--function", help="対象関数名")],
+    source: SourceOption,
+    track: Annotated[list[str], typer.Option("--track", help="保持するアクセスパス")] | None = None,
+    defines: Annotated[
+        list[str] | None,
+        typer.Option("--define", "-D", help="条件分岐評価に使うマクロ定義"),
+    ] = None,
+) -> None:
+    def task() -> str:
+        parsed = parse_source(source, defines or [])
+        tracks = tuple(TrackPath.parse(value) for value in (track or []))
+        return render_result(extract_flow(parsed, function_name, tracks))
+
+    _run(task)
+
+
+@app.command("path")
+def path_command(
+    function_name: Annotated[str, typer.Option("--function", help="対象関数名")],
+    source: SourceOption,
+    route: Annotated[str, typer.Option("--route", help="抽出する経路 DSL")],
+    defines: Annotated[
+        list[str] | None,
+        typer.Option("--define", "-D", help="条件分岐評価に使うマクロ定義"),
+    ] = None,
+) -> None:
+    def task() -> str:
+        parsed = parse_source(source, defines or [])
+        return render_result(extract_path(parsed, function_name, route))
+
+    _run(task)
+
+
+def _run(task: Callable[[], str]) -> None:
+    try:
+        typer.echo(task())
+    except CiftError as error:
+        typer.echo(error.message, err=True)
+        raise typer.Exit(code=1) from error

cifter/errors.py

@@ -0,0 +1,4 @@
+class CiftError(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self.message = message

cifter/extract_flow.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from tree_sitter import Node
+
+from cifter.model import ExtractedLine, ExtractionResult, TrackPath
+from cifter.parser import ParsedSource, find_function, function_body, node_text
+
+CONTROL_TYPES = {
+    "if_statement",
+    "switch_statement",
+    "case_statement",
+    "for_statement",
+    "while_statement",
+    "do_statement",
+    "goto_statement",
+    "break_statement",
+    "continue_statement",
+    "return_statement",
+    "labeled_statement",
+}
+
+STATEMENT_TYPES = {
+    "expression_statement",
+    "declaration",
+    "goto_statement",
+    "break_statement",
+    "continue_statement",
+    "return_statement",
+}
+
+
+def extract_flow(parsed: ParsedSource, function_name: str, tracks: tuple[TrackPath, ...]) -> ExtractionResult:
+    function_node = find_function(parsed, function_name)
+    body = function_body(function_node)
+    keep: set[int] = set()
+    _keep_range(keep, function_node.start_point.row + 1, body.start_point.row + 1)
+    keep.add(body.end_point.row + 1)
+    _collect_from_container(parsed, body, keep, tracks)
+    line_numbers = sorted(keep)
+    lines = tuple(
+        ExtractedLine(line_no=line_no, text=parsed.source.line_text(line_no))
+        for line_no in line_numbers
+    )
+    return ExtractionResult(span=parsed.source.span_for_lines(line_numbers), lines=lines)
+
+
+def _collect_from_container(
+    parsed: ParsedSource,
+    container: Node,
+    keep: set[int],
+    tracks: tuple[TrackPath, ...],
+) -> None:
+    for statement in _container_statements(container):
+        _collect_statement(parsed, statement, keep, tracks)
+
+
+def _collect_statement(
+    parsed: ParsedSource,
+    statement: Node,
+    keep: set[int],
+    tracks: tuple[TrackPath, ...],
+) -> None:
+    if statement.type == "switch_statement":
+        body = statement.named_children[-1]
+        _keep_range(keep, statement.start_point.row + 1, body.start_point.row + 1)
+        keep.add(body.end_point.row + 1)
+        _collect_from_container(parsed, body, keep, tracks)
+        return
+    if statement.type == "case_statement":
+        keep.add(statement.start_point.row + 1)
+        _collect_from_container(parsed, statement, keep, tracks)
+        return
+    if statement.type == "if_statement":
+        _collect_if_chain(parsed, statement, keep, tracks)
+        return
+    if statement.type in {"for_statement", "while_statement"}:
+        body = statement.named_children[-1]
+        _keep_range(keep, statement.start_point.row + 1, body.start_point.row + 1)
+        if body.type == "compound_statement":
+            keep.add(body.end_point.row + 1)
+            _collect_from_container(parsed, body, keep, tracks)
+        else:
+            _collect_statement(parsed, body, keep, tracks)
+        return
+    if statement.type == "do_statement":
+        body = statement.named_children[0]
+        keep.add(statement.start_point.row + 1)
+        keep.add(statement.end_point.row + 1)
+        if body.type == "compound_statement":
+            keep.add(body.end_point.row + 1)
+            _collect_from_container(parsed, body, keep, tracks)
+        else:
+            _collect_statement(parsed, body, keep, tracks)
+        return
+    if statement.type == "labeled_statement":
+        keep.add(statement.start_point.row + 1)
+        nested = statement.named_children[-1]
+        _collect_statement(parsed, nested, keep, tracks)
+        return
+    if statement.type in CONTROL_TYPES:
+        _keep_range(keep, statement.start_point.row + 1, statement.end_point.row + 1)
+        return
+    if statement.type in STATEMENT_TYPES and _matches_track(parsed, statement, tracks):
+        _keep_range(keep, statement.start_point.row + 1, statement.end_point.row + 1)
+
+
+def _collect_if_chain(
+    parsed: ParsedSource,
+    if_node: Node,
+    keep: set[int],
+    tracks: tuple[TrackPath, ...],
+) -> None:
+    consequence = if_node.named_children[1]
+    _keep_range(keep, if_node.start_point.row + 1, consequence.start_point.row + 1)
+    if consequence.type == "compound_statement":
+        keep.add(consequence.end_point.row + 1)
+        _collect_from_container(parsed, consequence, keep, tracks)
+    else:
+        _collect_statement(parsed, consequence, keep, tracks)
+
+    else_clause = _else_clause(if_node)
+    if else_clause is None:
+        return
+    alternative = else_clause.named_children[-1]
+    _keep_range(keep, else_clause.start_point.row + 1, alternative.start_point.row + 1)
+    if alternative.type == "if_statement":
+        _collect_if_chain(parsed, alternative, keep, tracks)
+        return
+    if alternative.type == "compound_statement":
+        keep.add(alternative.end_point.row + 1)
+        _collect_from_container(parsed, alternative, keep, tracks)
+        return
+    _collect_statement(parsed, alternative, keep, tracks)
+
+
+def _matches_track(parsed: ParsedSource, statement: Node, tracks: tuple[TrackPath, ...]) -> bool:
+    if not tracks:
+        return False
+    candidates = _collect_track_candidates(parsed, statement)
+    return any(track.normalized in candidates for track in tracks)
+
+
+def _collect_track_candidates(parsed: ParsedSource, node: Node) -> set[str]:
+    candidates: set[str] = set()
+    stack = [node]
+    while stack:
+        current = stack.pop()
+        if current.type == "field_expression":
+            candidates.add(node_text(parsed.source, current).replace(" ", ""))
+        elif current.type == "identifier" and current.parent is not None and current.parent.type != "field_expression":
+            candidates.add(node_text(parsed.source, current))
+        stack.extend(reversed(current.named_children))
+    return candidates
+
+
+def _container_statements(container: Node) -> list[Node]:
+    if container.type == "compound_statement":
+        return list(container.named_children)
+    if container.type == "case_statement":
+        return [child for child in container.named_children if _is_body_statement(child)]
+    if container.type == "labeled_statement":
+        return [container.named_children[-1]]
+    return [container]
+
+
+def _is_body_statement(node: Node) -> bool:
+    return node.type.endswith("_statement") or node.type == "declaration"
+
+
+def _else_clause(if_node: Node) -> Node | None:
+    for child in if_node.named_children:
+        if child.type == "else_clause":
+            return child
+    return None
+
+
+def _keep_range(keep: set[int], start_line: int, end_line: int) -> None:
+    keep.update(range(start_line, end_line + 1))

cifter/extract_function.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from cifter.model import ExtractedLine, ExtractionResult
+from cifter.parser import ParsedSource, find_function
+
+
+def extract_function(parsed: ParsedSource, name: str) -> ExtractionResult:
+    function_node = find_function(parsed, name)
+    start_line = function_node.start_point.row + 1
+    end_line = function_node.end_point.row + 1
+    lines = tuple(
+        ExtractedLine(line_no=line_no, text=parsed.source.line_text(line_no))
+        for line_no in range(start_line, end_line + 1)
+    )
+    return ExtractionResult(span=parsed.source.span_for_lines(list(range(start_line, end_line + 1))), lines=lines)

cifter/extract_path.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from tree_sitter import Node
+
+from cifter.errors import CiftError
+from cifter.model import (
+    ExtractedLine,
+    ExtractionResult,
+    RouteSegment,
+    normalize_condition_text,
+    parse_route,
+)
+from cifter.parser import ParsedSource, condition_text, find_function, function_body, node_text
+
+
+@dataclass(frozen=True)
+class _RouteMatch:
+    owner: Node
+    owner_index: int
+    kind: str
+    branch: Node
+    header_start_line: int
+    header_end_line: int
+    trim_end_byte: int | None = None
+    selected_start_byte: int | None = None
+
+
+def extract_path(parsed: ParsedSource, function_name: str, route: str) -> ExtractionResult:
+    function_node = find_function(parsed, function_name)
+    segments = parse_route(route)
+    body = function_body(function_node)
+    rendered: dict[int, str] = {}
+    _keep_original_range(rendered, parsed, function_node.start_point.row + 1, body.start_point.row + 1)
+    rendered[body.end_point.row + 1] = parsed.source.line_text(body.end_point.row + 1)
+    _collect_path_from_container(parsed, body, segments, rendered)
+    line_numbers = sorted(rendered)
+    lines = tuple(ExtractedLine(line_no=line_no, text=rendered[line_no]) for line_no in line_numbers)
+    return ExtractionResult(span=parsed.source.span_for_lines(line_numbers), lines=lines)
+
+
+def _collect_path_from_container(
+    parsed: ParsedSource,
+    container: Node,
+    segments: tuple[RouteSegment, ...],
+    rendered: dict[int, str],
+) -> None:
+    statements = _container_statements(container)
+    match = _find_unique_match(parsed, container, segments[0])
+    if not _is_function_body(container):
+        _keep_linear_statements(rendered, parsed, statements[: match.owner_index])
+
+    if match.kind == "case":
+        _render_switch_context(rendered, parsed, match.owner)
+        rendered[match.header_start_line] = parsed.source.line_text(match.header_start_line)
+        if len(segments) == 1:
+            _keep_full_statement(rendered, parsed, match.branch)
+            return
+        _collect_path_from_container(parsed, match.branch, segments[1:], rendered)
+        return
+
+    _render_if_context(rendered, parsed, match)
+    if len(segments) == 1:
+        _keep_branch_body(rendered, parsed, match)
+        _keep_linear_statements(rendered, parsed, statements[match.owner_index + 1 :])
+        return
+
+    _collect_path_from_container(parsed, match.branch, segments[1:], rendered)
+    _keep_branch_closing(rendered, parsed, match)
+
+
+def _find_unique_match(parsed: ParsedSource, container: Node, segment: RouteSegment) -> _RouteMatch:
+    matches = _find_matches(parsed, container, segment)
+    if not matches:
+        raise CiftError(f"route に一致する枝が見つかりません: {segment.raw}")
+    if len(matches) > 1:
+        raise CiftError(f"route に一致する枝が複数あります: {segment.raw}")
+    return matches[0]
+
+
+def _find_matches(parsed: ParsedSource, container: Node, segment: RouteSegment) -> list[_RouteMatch]:
+    matches: list[_RouteMatch] = []
+    statements = _container_statements(container)
+    for index, statement in enumerate(statements):
+        if segment.kind in {"case", "default"} and statement.type == "switch_statement":
+            for case_statement in _switch_cases(statement):
+                if segment.kind == "case" and _case_label(parsed, case_statement) == segment.label:
+                    matches.append(
+                        _RouteMatch(
+                            owner=statement,
+                            owner_index=index,
+                            kind="case",
+                            branch=case_statement,
+                            header_start_line=case_statement.start_point.row + 1,
+                            header_end_line=case_statement.start_point.row + 1,
+                            selected_start_byte=case_statement.start_byte,
+                        )
+                    )
+                if segment.kind == "default" and _is_default_case(case_statement):
+                    matches.append(
+                        _RouteMatch(
+                            owner=statement,
+                            owner_index=index,
+                            kind="case",
+                            branch=case_statement,
+                            header_start_line=case_statement.start_point.row + 1,
+                            header_end_line=case_statement.start_point.row + 1,
+                            selected_start_byte=case_statement.start_byte,
+                        )
+                    )
+        if statement.type != "if_statement":
+            continue
+        if segment.kind == "if" and _normalized_if_condition(parsed, statement) == segment.condition:
+            consequence = statement.named_children[1]
+            matches.append(
+                _RouteMatch(
+                    owner=statement,
+                    owner_index=index,
+                    kind="if",
+                    branch=consequence,
+                    header_start_line=statement.start_point.row + 1,
+                    header_end_line=consequence.start_point.row + 1,
+                    trim_end_byte=_trim_end_byte(statement, consequence),
+                    selected_start_byte=statement.start_byte,
+                )
+            )
+        if segment.kind == "else":
+            else_match = _final_else_match(statement, index)
+            if else_match is not None:
+                matches.append(else_match)
+        if segment.kind == "else_if":
+            matches.extend(_else_if_matches(parsed, statement, index, segment.condition or ""))
+    return matches
+
+
+def _else_if_matches(
+    parsed: ParsedSource,
+    if_node: Node,
+    owner_index: int,
+    condition: str,
+) -> list[_RouteMatch]:
+    matches: list[_RouteMatch] = []
+    current = if_node
+    while True:
+        else_clause = _else_clause(current)
+        if else_clause is None:
+            return matches
+        alternative = else_clause.named_children[-1]
+        if alternative.type != "if_statement":
+            return matches
+        consequence = alternative.named_children[1]
+        if _normalized_if_condition(parsed, alternative) == condition:
+            matches.append(
+                _RouteMatch(
+                    owner=if_node,
+                    owner_index=owner_index,
+                    kind="else_if",
+                    branch=consequence,
+                    header_start_line=else_clause.start_point.row + 1,
+                    header_end_line=consequence.start_point.row + 1,
+                    trim_end_byte=_trim_end_byte(alternative, consequence),
+                    selected_start_byte=alternative.start_byte,
+                )
+            )
+        current = alternative
+
+
+def _final_else_match(if_node: Node, owner_index: int) -> _RouteMatch | None:
+    current = if_node
+    while True:
+        else_clause = _else_clause(current)
+        if else_clause is None:
+            return None
+        alternative = else_clause.named_children[-1]
+        if alternative.type == "if_statement":
+            current = alternative
+            continue
+        return _RouteMatch(
+            owner=if_node,
+            owner_index=owner_index,
+            kind="else",
+            branch=alternative,
+            header_start_line=else_clause.start_point.row + 1,
+            header_end_line=alternative.start_point.row + 1,
+        )
+
+
+def _keep_branch_body(rendered: dict[int, str], parsed: ParsedSource, match: _RouteMatch) -> None:
+    if match.kind == "case":
+        _keep_full_statement(rendered, parsed, match.branch)
+        return
+    branch = match.branch
+    if branch.type == "compound_statement":
+        _keep_original_range(rendered, parsed, branch.start_point.row + 1, branch.end_point.row + 1)
+        _keep_branch_closing(rendered, parsed, match)
+        return
+    _keep_original_range(rendered, parsed, branch.start_point.row + 1, branch.end_point.row + 1)
+
+
+def _keep_branch_closing(rendered: dict[int, str], parsed: ParsedSource, match: _RouteMatch) -> None:
+    _keep_compound_closing(rendered, parsed, match.branch, match.trim_end_byte)
+
+
+def _keep_full_statement(rendered: dict[int, str], parsed: ParsedSource, statement: Node) -> None:
+    _keep_original_range(rendered, parsed, statement.start_point.row + 1, statement.end_point.row + 1)
+
+
+def _render_switch_context(rendered: dict[int, str], parsed: ParsedSource, switch_node: Node) -> None:
+    body = switch_node.named_children[-1]
+    _keep_original_range(rendered, parsed, switch_node.start_point.row + 1, body.start_point.row + 1)
+    rendered[body.end_point.row + 1] = parsed.source.line_text(body.end_point.row + 1)
+
+
+def _render_if_context(rendered: dict[int, str], parsed: ParsedSource, match: _RouteMatch) -> None:
+    if match.kind == "if":
+        _keep_original_range(rendered, parsed, match.header_start_line, match.header_end_line)
+        return
+
+    owner = match.owner
+    owner_consequence = owner.named_children[1]
+    _keep_original_range(rendered, parsed, owner.start_point.row + 1, owner_consequence.start_point.row + 1)
+    _keep_compound_closing(
+        rendered,
+        parsed,
+        owner_consequence,
+        _trim_end_byte(owner, owner_consequence),
+    )
+
+    current = owner
+    while True:
+        else_clause = _else_clause(current)
+        if else_clause is None:
+            raise CiftError("else 連鎖を特定できません")
+
+        alternative = else_clause.named_children[-1]
+        if match.kind == "else" and alternative.start_byte == match.branch.start_byte:
+            _keep_original_range(rendered, parsed, else_clause.start_point.row + 1, match.header_end_line)
+            return
+        if alternative.type != "if_statement":
+            raise CiftError("else if 連鎖を特定できません")
+
+        consequence = alternative.named_children[1]
+        if match.kind == "else_if" and alternative.start_byte == match.selected_start_byte:
+            _keep_original_range(rendered, parsed, else_clause.start_point.row + 1, match.header_end_line)
+            return
+
+        _keep_original_range(rendered, parsed, else_clause.start_point.row + 1, consequence.start_point.row + 1)
+        _keep_compound_closing(
+            rendered,
+            parsed,
+            consequence,
+            _trim_end_byte(alternative, consequence),
+        )
+        current = alternative
+
+
+def _keep_compound_closing(
+    rendered: dict[int, str],
+    parsed: ParsedSource,
+    branch: Node,
+    trim_end_byte: int | None,
+) -> None:
+    if branch.type != "compound_statement":
+        return
+    line_no = branch.end_point.row + 1
+    if trim_end_byte is None:
+        rendered[line_no] = parsed.source.line_text(line_no)
+        return
+    rendered[line_no] = parsed.source.slice_from_line_start(line_no, trim_end_byte)
+
+
+def _keep_linear_statements(
+    rendered: dict[int, str],
+    parsed: ParsedSource,
+    statements: list[Node],
+) -> None:
+    for statement in statements:
+        if not _is_branching_statement(statement):
+            _keep_full_statement(rendered, parsed, statement)
+
+
+def _keep_original_range(
+    rendered: dict[int, str],
+    parsed: ParsedSource,
+    start_line: int,
+    end_line: int,
+) -> None:
+    for line_no in range(start_line, end_line + 1):
+        rendered[line_no] = parsed.source.line_text(line_no)
+
+
+def _container_statements(container: Node) -> list[Node]:
+    if container.type == "compound_statement":
+        return list(container.named_children)
+    if container.type == "case_statement":
+        return [child for child in container.named_children if _is_body_statement(child)]
+    return [container]
+
+
+def _is_body_statement(node: Node) -> bool:
+    return node.type.endswith("_statement") or node.type == "declaration"
+
+
+def _switch_cases(switch_node: Node) -> list[Node]:
+    body = switch_node.named_children[-1]
+    return [child for child in body.named_children if child.type == "case_statement"]
+
+
+def _case_label(parsed: ParsedSource, case_node: Node) -> str | None:
+    if _is_default_case(case_node):
+        return None
+    for child in case_node.named_children:
+        if child.type == "identifier":
+            return node_text(parsed.source, child)
+        if child.type.endswith("_expression") or child.type.endswith("_literal"):
+            return node_text(parsed.source, child).strip()
+    return None
+
+
+def _is_default_case(case_node: Node) -> bool:
+    return bool(case_node.children) and case_node.children[0].type == "default"
+
+
+def _normalized_if_condition(parsed: ParsedSource, if_node: Node) -> str:
+    condition_node = if_node.named_children[0]
+    return normalize_condition_text(condition_text(parsed.source, condition_node))
+
+
+def _else_clause(if_node: Node) -> Node | None:
+    for child in if_node.named_children:
+        if child.type == "else_clause":
+            return child
+    return None
+
+
+def _trim_end_byte(if_node: Node, branch: Node) -> int | None:
+    else_clause = _else_clause(if_node)
+    if else_clause is None:
+        return None
+    if branch.end_point.row != else_clause.start_point.row:
+        return None
+    return branch.end_byte
+
+
+def _is_branching_statement(node: Node) -> bool:
+    return node.type in {"if_statement", "switch_statement", "for_statement", "while_statement", "do_statement"}
+
+
+def _is_function_body(node: Node) -> bool:
+    return node.type == "compound_statement" and node.parent is not None and node.parent.type == "function_definition"

cifter/model.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from itertools import pairwise
+from pathlib import Path
+
+from cifter.errors import CiftError
+
+TRACK_PATH_PATTERN = re.compile(r"^[A-Za-z_]\w*(?:(?:->|\.)[A-Za-z_]\w*)*$")
+
+
+@dataclass(frozen=True)
+class SourceSpan:
+    file: Path
+    start_line: int
+    end_line: int
+
+
+@dataclass(frozen=True)
+class ExtractedLine:
+    line_no: int
+    text: str
+
+
+@dataclass(frozen=True)
+class ExtractionResult:
+    span: SourceSpan
+    lines: tuple[ExtractedLine, ...]
+
+
+@dataclass(frozen=True)
+class TrackPath:
+    raw: str
+    normalized: str
+
+    @classmethod
+    def parse(cls, raw: str) -> TrackPath:
+        value = raw.strip()
+        if not value or not TRACK_PATH_PATTERN.fullmatch(value):
+            raise CiftError(f"不正な --track です: {raw}")
+        return cls(raw=value, normalized=value.replace(" ", ""))
+
+
+@dataclass(frozen=True)
+class RouteSegment:
+    kind: str
+    raw: str
+    label: str | None = None
+    condition: str | None = None
+
+    @classmethod
+    def parse(cls, raw: str) -> RouteSegment:
+        value = raw.strip()
+        if not value:
+            raise CiftError("空の route 要素は指定できません")
+        if value.startswith("case "):
+            label = value[5:].strip()
+            if not label:
+                raise CiftError(f"不正な --route 要素です: {raw}")
+            return cls(kind="case", raw=value, label=label)
+        if value == "default":
+            return cls(kind="default", raw=value)
+        if value.startswith("else if "):
+            condition = value[8:].strip()
+            if not condition:
+                raise CiftError(f"不正な --route 要素です: {raw}")
+            return cls(
+                kind="else_if",
+                raw=value,
+                condition=normalize_condition_text(condition),
+            )
+        if value == "else":
+            return cls(kind="else", raw=value)
+        if value.startswith("if "):
+            condition = value[3:].strip()
+            if not condition:
+                raise CiftError(f"不正な --route 要素です: {raw}")
+            return cls(kind="if", raw=value, condition=normalize_condition_text(condition))
+        raise CiftError(f"不正な --route 要素です: {raw}")
+
+
+def normalize_condition_text(text: str) -> str:
+    value = "".join(text.split())
+    while value.startswith("(") and value.endswith(")") and _covers_entire_text(value):
+        value = value[1:-1]
+    return value
+
+
+def _covers_entire_text(text: str) -> bool:
+    depth = 0
+    for index, char in enumerate(text):
+        if char == "(":
+            depth += 1
+        elif char == ")":
+            depth -= 1
+            if depth == 0 and index != len(text) - 1:
+                return False
+        if depth < 0:
+            return False
+    return depth == 0
+
+
+def parse_route(route: str) -> tuple[RouteSegment, ...]:
+    parts = _split_route(route)
+    if not parts:
+        raise CiftError("空の --route は指定できません")
+    segments = tuple(RouteSegment.parse(part) for part in parts)
+    for left, right in pairwise(segments):
+        if left.kind == "else" and right.kind == "if":
+            raise CiftError("`else > if ...` は非対応です。`else if ...` を使ってください")
+    return segments
+
+
+def _split_route(route: str) -> list[str]:
+    parts: list[str] = []
+    current: list[str] = []
+    index = 0
+    while index < len(route):
+        char = route[index]
+        if char == ">":
+            lookahead = index + 1
+            while lookahead < len(route) and route[lookahead].isspace():
+                lookahead += 1
+            tail = route[lookahead:]
+            if current and _starts_route_segment(tail):
+                parts.append("".join(current).strip())
+                current = []
+                index = lookahead
+                continue
+        current.append(char)
+        index += 1
+    if current:
+        parts.append("".join(current).strip())
+    return [part for part in parts if part]
+
+
+def _starts_route_segment(value: str) -> bool:
+    return any(
+        value.startswith(prefix)
+        for prefix in ("case ", "default", "if ", "else ", "else", "else if ")
+    )

cifter/parser.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import tree_sitter_c
+import tree_sitter_cpp
+from tree_sitter import Language, Node, Parser, Tree
+
+from cifter.errors import CiftError
+from cifter.model import SourceSpan
+from cifter.preprocessor import preprocess_source
+
+CPP_EXTENSIONS = {".cc", ".cpp", ".cxx", ".c++", ".hpp", ".hh", ".hxx", ".h++"}
+
+
+@dataclass(frozen=True)
+class SourceFile:
+    path: Path
+    text: str
+    lines: tuple[str, ...]
+    trailing_newline: bool
+    line_start_bytes: tuple[int, ...]
+
+    @classmethod
+    def from_text(cls, path: Path, text: str) -> SourceFile:
+        trailing_newline = text.endswith("\n")
+        lines = tuple(text.splitlines())
+        start_bytes: list[int] = []
+        offset = 0
+        for index, line in enumerate(lines):
+            start_bytes.append(offset)
+            offset += len(line.encode("utf-8"))
+            if index < len(lines) - 1 or trailing_newline:
+                offset += 1
+        return cls(
+            path=path,
+            text=text,
+            lines=lines,
+            trailing_newline=trailing_newline,
+            line_start_bytes=tuple(start_bytes),
+        )
+
+    def span_for_lines(self, line_numbers: list[int]) -> SourceSpan:
+        return SourceSpan(self.path, min(line_numbers), max(line_numbers))
+
+    def line_text(self, line_no: int) -> str:
+        return self.lines[line_no - 1]
+
+    def line_start_byte(self, line_no: int) -> int:
+        return self.line_start_bytes[line_no - 1]
+
+    def slice_from_line_start(self, line_no: int, end_byte: int) -> str:
+        start_byte = self.line_start_byte(line_no)
+        return self.text.encode("utf-8")[start_byte:end_byte].decode("utf-8").rstrip()
+
+
+@dataclass(frozen=True)
+class ParsedSource:
+    source: SourceFile
+    tree: Tree
+    language_name: str
+
+
+def parse_source(path: Path, defines: list[str]) -> ParsedSource:
+    raw_text = path.read_text(encoding="utf-8")
+    preprocessed = preprocess_source(raw_text, defines)
+    source = SourceFile.from_text(path, preprocessed)
+    parser, language_name = _build_parser(path)
+    tree = parser.parse(source.text.encode("utf-8"))
+    return ParsedSource(source=source, tree=tree, language_name=language_name)
+
+
+def find_function(parsed: ParsedSource, name: str) -> Node:
+    matches = [node for node in _iter_nodes(parsed.tree.root_node) if _is_function_named(node, parsed.source, name)]
+    if not matches:
+        raise CiftError(f"関数が見つかりません: {name}")
+    if len(matches) > 1:
+        raise CiftError(f"同名関数が複数見つかりました: {name}")
+    return matches[0]
+
+
+def function_body(function_node: Node) -> Node:
+    for child in function_node.named_children:
+        if child.type == "compound_statement":
+            return child
+    raise CiftError("関数本体を特定できません")
+
+
+def node_text(source: SourceFile, node: Node) -> str:
+    return source.text.encode("utf-8")[node.start_byte:node.end_byte].decode("utf-8")
+
+
+def condition_text(source: SourceFile, node: Node) -> str:
+    text = node_text(source, node)
+    return text
+
+
+def _build_parser(path: Path) -> tuple[Parser, str]:
+    if path.suffix.lower() in CPP_EXTENSIONS:
+        return Parser(Language(tree_sitter_cpp.language())), "cpp"
+    return Parser(Language(tree_sitter_c.language())), "c"
+
+
+def _iter_nodes(root: Node) -> list[Node]:
+    nodes: list[Node] = []
+    stack = [root]
+    while stack:
+        node = stack.pop()
+        nodes.append(node)
+        stack.extend(reversed(node.named_children))
+    return nodes
+
+
+def _is_function_named(node: Node, source: SourceFile, name: str) -> bool:
+    if node.type != "function_definition":
+        return False
+    declarator = next(
+        (child for child in node.named_children if child.type.endswith("declarator")),
+        None,
+    )
+    if declarator is None:
+        return False
+    return _extract_declarator_name(source, declarator) == name
+
+
+def _extract_declarator_name(source: SourceFile, node: Node) -> str | None:
+    if node.type in {"identifier", "field_identifier"}:
+        return node_text(source, node)
+    if node.type == "qualified_identifier":
+        return node_text(source, node).split("::")[-1]
+    for child in node.named_children:
+        if child.type in {"parameter_list", "template_parameter_list"}:
+            continue
+        name = _extract_declarator_name(source, child)
+        if name is not None:
+            return name
+    return None

cifter/preprocessor.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pcpp import Preprocessor
+
+from cifter.errors import CiftError
+
+
+@dataclass
+class _ConditionalFrame:
+    parent_active: bool
+    current_active: bool
+    branch_taken: bool
+    saw_else: bool = False
+
+
+def preprocess_source(source: str, defines: list[str]) -> str:
+    lines = source.splitlines()
+    trailing_newline = source.endswith("\n")
+    processor = Preprocessor()
+    for define in defines:
+        processor.define(_normalize_define(define))
+
+    output: list[str] = []
+    stack: list[_ConditionalFrame] = []
+
+    for line in lines:
+        directive = _parse_directive(line)
+        active = stack[-1].current_active if stack else True
+
+        if directive is not None and directive.name in {"if", "ifdef", "ifndef", "elif", "else", "endif"}:
+            _handle_conditional_directive(processor, stack, directive)
+            output.append("")
+            continue
+
+        if not active:
+            output.append("")
+            continue
+
+        if directive is not None and directive.name == "define" and directive.body:
+            processor.define(_normalize_define(directive.body))
+        elif directive is not None and directive.name == "undef" and directive.body:
+            processor.undef(directive.body.strip())
+
+        output.append(line)
+
+    if stack:
+        raise CiftError("条件分岐ディレクティブが閉じていません")
+
+    text = "\n".join(output)
+    if trailing_newline:
+        text += "\n"
+    return text
+
+
+@dataclass(frozen=True)
+class _Directive:
+    name: str
+    body: str
+
+
+def _parse_directive(line: str) -> _Directive | None:
+    stripped = line.lstrip()
+    if not stripped.startswith("#"):
+        return None
+    body = stripped[1:].lstrip()
+    if not body:
+        return None
+    name, _, tail = body.partition(" ")
+    if not tail and "\t" in body:
+        name, _, tail = body.partition("\t")
+    return _Directive(name=name, body=tail.lstrip())
+
+
+def _handle_conditional_directive(
+    processor: Preprocessor,
+    stack: list[_ConditionalFrame],
+    directive: _Directive,
+) -> None:
+    name = directive.name
+    if name in {"if", "ifdef", "ifndef"}:
+        parent_active = stack[-1].current_active if stack else True
+        current_active = parent_active and _evaluate_condition(processor, directive)
+        stack.append(
+            _ConditionalFrame(
+                parent_active=parent_active,
+                current_active=current_active,
+                branch_taken=current_active,
+            )
+        )
+        return
+
+    if not stack:
+        raise CiftError(f"対応する開始ディレクティブがありません: #{name}")
+
+    frame = stack[-1]
+    if name == "elif":
+        if frame.saw_else:
+            raise CiftError("#else の後に #elif は指定できません")
+        if frame.branch_taken:
+            frame.current_active = False
+            return
+        frame.current_active = frame.parent_active and _evaluate_condition(processor, directive)
+        frame.branch_taken = frame.current_active
+        return
+    if name == "else":
+        if frame.saw_else:
+            raise CiftError("#else は 1 回だけ指定できます")
+        frame.saw_else = True
+        frame.current_active = frame.parent_active and not frame.branch_taken
+        frame.branch_taken = True
+        return
+    if name == "endif":
+        stack.pop()
+        return
+
+
+def _evaluate_condition(processor: Preprocessor, directive: _Directive) -> bool:
+    if directive.name == "ifdef":
+        return directive.body.strip() in processor.macros
+    if directive.name == "ifndef":
+        return directive.body.strip() not in processor.macros
+    value, _ = processor.evalexpr(processor.tokenize(directive.body))
+    return bool(value)
+
+
+def _normalize_define(value: str) -> str:
+    name, separator, body = value.partition("=")
+    if not separator:
+        return value
+    return f"{name.strip()} {body.strip()}"

cifter/render.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from cifter.model import ExtractionResult
+
+
+def render_result(result: ExtractionResult) -> str:
+    width = len(str(result.lines[-1].line_no))
+    return "\n".join(f"{line.line_no:>{width}}: {line.text}" for line in result.lines)

cifter_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: cifter-cli
+Version: 0.1.0
+Summary: C/C++ の関数実装を抽出する軽量 CLI
+Keywords: c,c++,cpp,cli,tree-sitter,source-extraction,static-analysis
+Author: t-kenji
+Author-email: t-kenji <protect.2501@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: C
+Classifier: Programming Language :: C++
+Classifier: Topic :: Software Development
+Requires-Dist: pcpp>=1.30
+Requires-Dist: tree-sitter>=0.25.2
+Requires-Dist: tree-sitter-c>=0.24.1
+Requires-Dist: tree-sitter-cpp>=0.23.4
+Requires-Dist: typer>=0.24.1
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/t-kenji/cifter
+Project-URL: Repository, https://github.com/t-kenji/cifter
+Project-URL: Issues, https://github.com/t-kenji/cifter/issues
+Project-URL: Changelog, https://github.com/t-kenji/cifter/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# cifter
+
+`cifter` は、C/C++ の関数実装を機械的かつ高速に抽出する CLI です。
+`tree-sitter` で構文を捉え、行番号付き text として返します。重い意味解析や LLM 連携は行いません。
+
+## 概要
+
+- 単一の `--source` ファイルから抽出します
+- 公開サブコマンドは `function` / `flow` / `path` の 3 つです
+- 出力は元ソースと対応付け可能な行番号付き text です
+- `-D NAME[=VALUE]` により条件分岐前処理を評価できます
+
+## Why cifter
+
+- 関数全体をそのまま抜き出したい
+- 分岐の骨格だけを見たい
+- 特定の route だけを細く追いたい
+- 元の行番号を失わずにレビューや調査へ貼りたい
+
+## Installation
+
+PyPI から install:
+
+```sh
+python -m pip install cifter-cli
+```
+
+最小確認:
+
+```sh
+cift --help
+python -m cifter --help
+```
+
+GitHub Release の `wheel` / `sdist` から install することもできます。
+
+```sh
+python -m pip install ./cifter_cli-0.1.0-py3-none-any.whl
+```
+
+開発用:
+
+```sh
+uv sync
+uv run cift --help
+```
+
+## Quick Start
+
+サンプルソース:
+
+```c
+int FooFunction(int x)
+{
+    if (x > 0) {
+        return 1;
+    }
+
+    return 0;
+}
+```
+
+関数全体を抽出:
+
+```sh
+cift function --name FooFunction --source foo.c
+```
+
+出力:
+
+```text
+1: int FooFunction(int x)
+2: {
+3:     if (x > 0) {
+4:         return 1;
+5:     }
+6:
+7:     return 0;
+8: }
+```
+
+## Commands
+
+`function`:
+指定した関数の実装全体をそのまま抽出します。レビュー対象の最小切り出しに向きます。
+
+```sh
+cift function --name FooFunction --source examples/demo.c
+```
+
+`flow`:
+制御構造の骨格だけを残します。`--track` を付けると、完全一致したアクセスパスを含む文を追加保持します。
+
+```sh
+cift flow --function FooFunction --source examples/demo.c --track state
+cift flow --function FooFunction --source examples/demo.c --track 'ctx->state'
+```
+
+`path`:
+指定した route だけを細く抽出します。親構造は残し、route 終端に達したコンテナでは後続の通常文も残します。
+
+```sh
+cift path --function FooFunction --source examples/demo.c --route 'case CMD_HOGE > if ret == OK'
+cift path --function FooFunction --source examples/demo.c --route 'case CMD_HOGE > else if errno == EINT'
+cift path --function ElseRoute --source examples/demo.c --route 'else'
+```
+
+## Preprocessor / Track / Route
+
+`-D`:
+条件分岐前処理の評価に使うマクロを追加します。
+
+```sh
+cift function --name FooFunction --source examples/demo.c -D DEF_FOO -D ENABLE_BAR=1
+```
+
+`--track`:
+`flow` で保持したいアクセスパスです。構文上の完全一致だけを扱います。
+
+- `state`
+- `ctx->state`
+- `a->b.c`
+
+`--route`:
+`path` で辿る最小 DSL です。
+
+- `case CMD_HOGE`
+- `case CMD_HOGE > if ret == OK`
+- `case CMD_HOGE > else if errno == EINT`
+- `default`
+- `else`
+
+## Limitations
+
+- 対象は C/C++ のみです
+- 入力は単一ファイルのみです
+- 出力形式は text のみです
+- 入力文字コードは UTF-8 前提です
+- `.h` は現状 C 扱いです
+- `--route` は `case` / `default` / `if` / `else` / `else if` のみ対応です
+- `--track` は名前解決やスコープ解析を行いません
+- ループ経路、`goto` 横断、意味解析、CFG 構築、JSON 出力は対象外です
+
+## Examples
+
+リポジトリには `examples/demo.c` を含めています。
+
+```sh
+cift function --name FooFunction --source examples/demo.c
+cift flow --function FooFunction --source examples/demo.c --track 'ctx->state'
+cift path --function FooFunction --source examples/demo.c --route 'case CMD_LOOP > if ret == OK'
+```
+
+## Development
+
+開発者向け文書は `docs/` にまとめています。
+
+- [docs/overview.md](/home/tkenji/Repos/cifter/docs/overview.md)
+- [docs/cli.md](/home/tkenji/Repos/cifter/docs/cli.md)
+- [docs/output-format.md](/home/tkenji/Repos/cifter/docs/output-format.md)
+- [docs/pipeline.md](/home/tkenji/Repos/cifter/docs/pipeline.md)
+- [docs/data-model.md](/home/tkenji/Repos/cifter/docs/data-model.md)
+- [docs/architecture.md](/home/tkenji/Repos/cifter/docs/architecture.md)
+- [docs/release.md](/home/tkenji/Repos/cifter/docs/release.md)
+
+仕様の正本は `docs/specs/` にあります。
+
+## License
+
+MIT License で配布します。詳細は `LICENSE` を参照してください。

cifter_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+cifter/__init__.py,sha256=68T9Qi3STMn4RIJnaB5LxEMDE1M2ODGPRAhl-FLJBQo,48
+cifter/__main__.py,sha256=gO8rJ7Ta_JUJqXjSGrshtxWJfafLZod1S8pha5SEO6M,67
+cifter/cli.py,sha256=uMJzJjUnUwvH47fIrBgr68AypMyzD2TssJoeEFcaJ1k,2664
+cifter/errors.py,sha256=Q3yAAXBFK86c7IZgP-SZXDh-H0_AMr5oIshvZNGPwSE,139
+cifter/extract_flow.py,sha256=DZHKIXRfatbvb2Lgqgy_UbD9LrAIozmusVrQqinpe7I,6403
+cifter/extract_function.py,sha256=7xEeEspOlp5gDG0F7Uz7_AkBCJvutelqEvhgUquoNU4,643
+cifter/extract_path.py,sha256=W0m8KpkpWYXWvDGCffHQXFl2zpveI2YYHlUX83WZjMc,13469
+cifter/model.py,sha256=vxwjyQg-iTqjq1nGFsQEihIOb69gcjlTSfjFFihPsiE,4234
+cifter/parser.py,sha256=48-eh3pVoVrWfC-SeMkzmzelhRCDOmRR_Qf0U3CEThE,4502
+cifter/preprocessor.py,sha256=hliAakYaPHS40_xhLiAFoFcGRakkXHpYEMZpZFiohm8,3981
+cifter/render.py,sha256=xvfB-2FrMdOl2ccaz1XBSM86veHL9RJpu9RiceF0khA,266
+cifter_cli-0.1.0.dist-info/licenses/LICENSE,sha256=E53cO1q07FMYhxvM3JtMzhEx47_29e-090jiA1tTWxs,1064
+cifter_cli-0.1.0.dist-info/WHEEL,sha256=Sb1dMJuf3wy6TqB8bzcqZpk8WSKCV8HbGz39HaP5dwE,81
+cifter_cli-0.1.0.dist-info/entry_points.txt,sha256=C6lSWuf3ymAsnFoMp-VJG1_veGSVqL81-g8brdJpwqA,38
+cifter_cli-0.1.0.dist-info/METADATA,sha256=ejqFOg5xuXGXXnB4GObKHIzHRU0svRxJS23BWYDz1lo,5621
+cifter_cli-0.1.0.dist-info/RECORD,,

cifter_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.10.10
+Root-Is-Purelib: true
+Tag: py3-none-any

cifter_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cift = cifter:main
+

cifter_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 t-kenji
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.