SpectraRust/.claude/skills/f2r-check/SKILL.md

name	description
f2r-check	Fortran 到 Rust 模块一致性检查与修复。触发条件： - 用户提到 "检查模块"、"对比模块"、"f2r_check"、"f2r check"、"下一个模块" - 用户询问 Rust 模块是否与 Fortran 源码匹配 - 用户想验证或修复 Rust 实现的正确性 核心工作流：获取推荐 → 检查差异 → **直接修复** → 验证编译 → **继续下一个** **自动化模式**：检查发现差异后必须立即修复，禁止询问用户，禁止生成总结报告。

F2R Check - Fortran 到 Rust 自动化修复（两阶段检查）

这是一个自动化任务。检查发现差异后必须立即修复，修复完成后自动继续下一个模块。

关键规则（必须遵守）

┌─────────────────────────────────────────────────────────────────┐
│  禁止事项：                                                       │
│  ❌ 禁止生成总结报告后询问"是否继续"                              │
│  ❌ 禁止说"这个模块很复杂，是否要修复"                             │
│  ❌ 禁止只检查不修复                                              │
│  ❌ 禁止输出冗长的检查报告                                        │
│  ❌ 禁止因为模块复杂就跳过                                        │
│  ❌ 禁止自行判断"这个差异不重要"然后跳过                          │
│  ❌ 禁止跳过 I/O 语句（write/read/print）                         │
│                                                                   │
│  必须事项：                                                       │
│  ✅ 只有脚本返回 "✅ match" 且无 HIGH_RISK 才能跳过              │
│  ✅ 任何 non-match 状态都必须修复                                 │
│  ✅ ✅ match + HIGH_RISK 必须进行 Phase 2 深度检查               │
│  ✅ I/O 语句必须实现（用 log::debug! 或条件打印）                 │
│  ✅ 检查发现差异 → 立即修复                                       │
│  ✅ 修复完成 → 立即验证编译                                       │
│  ✅ 编译通过 → 立即继续下一个模块                                 │
│  ✅ 只输出：修复了什么 + 编译结果                                 │
│  ✅ 遇到复杂模块也要修复，分解为小步骤逐步完成                     │
└─────────────────────────────────────────────────────────────────┘

两阶段检查流程

Phase 1: Python 快速风险检测（自动）

步骤 1: 获取推荐模块
$ python3 .claude/skills/f2r-check/scripts/next_module.py
        │
        ▼
步骤 2: 快速检查差异
$ python3 .claude/skills/f2r-check/scripts/f2r_check.py --diff <MODULE>
        │
        ├── ❌ mismatch/partial → 立即修复（现有流程）→ 步骤 4
        │
        └── ✅ match → 步骤 3: 风险评估
                │
                ▼
步骤 3: $ python3 .claude/skills/f2r-check/scripts/f2r_check.py --risk <MODULE>
        │
        ├── 有 HIGH_RISK → 进入 Phase 2
        │
        └── 无风险 → 输出 "模块已完整，跳过" → 继续步骤 1

Phase 2: Claude 深度语义对比（手动触发或自动）

Phase 1 发现 HIGH_RISK 后，Claude 逐行对比 Fortran 和 Rust：

Phase 2 步骤:
1. 读取 Fortran 源码
2. 读取 Rust 源码
3. 读取 INCLUDE 的 COMMON 定义文件
4. 读取 use 引用的 Rust struct 文件
5. 逐块对比（变量映射、索引转换、数组维度、赋值完整性）
6. 发现 bug → 立即修复 → cargo build 验证
7. 无 bug → 输出 "深度检查通过" → 继续下一个

Phase 2 检查清单

对每个 HIGH_RISK 模块，必须逐项检查：

[ ] COMMON 变量 → 正确的 Rust struct 字段
    使用: python3 scripts/common_db.py --module <MODULE>

[ ] 2D 数组下标顺序（Fortran 列主序 → Rust 行主序）
    Fortran XDO(3,MHOD) 第一个下标变化最快
    Rust xdo[[mhod_idx][3_idx] 需要交换下标

[ ] 1-based → 0-based 索引一致性
    IJ00=1 → ij00=0
    DO I=1,N → for i in 0..n

[ ] 循环边界转换
    DO I=1,N → for i in 0..n (不是 0..n-1)
    DO I=N,1,-1 → for i in (0..n).rev()

[ ] IF 条件完整保留
    <= vs <, >= vs >, .EQ. vs ==
    .AND. vs &&, .OR. vs ||

[ ] 所有赋值目标存在（无遗漏的 LINEXP 等）
    检查每个 Fortran 赋值语句是否有对应 Rust 赋值

[ ] CALL 顺序和数量一致
    每个 CALL 都有对应 Rust 函数调用
    调用顺序与 Fortran 一致

[ ] 类型转换正确
    INTEGER → i32, REAL*8 → f64, LOGICAL → bool
    REAL*4 → f32, INTEGER*2 → i16

判断标准

脚本输出	风险等级	行动	允许跳过？
✅ match + 无风险	无	跳过	✅ 是
✅ match + HIGH_RISK	高	Phase 2 深度检查	❌ 否
✅ match + MEDIUM_RISK	中	Phase 2 深度检查	❌ 否
⚠️ partial	—	立即修复	❌ 否
❌ mismatch	—	立即修复	❌ 否
❓ missing	—	立即实现	❌ 否

输出格式（严格遵守）

只输出以下简洁格式：

检查: <模块名> - <状态>
风险: <N HIGH, M MEDIUM> (如有)
修复: <修复内容简述>
编译: <成功/失败>

禁止输出：

• 长表格总结
• "是否需要继续..."
• "建议..."
• "如需..."

脚本命令

获取下一个模块

python3 .claude/skills/f2r-check/scripts/next_module.py              # 全局推荐
python3 .claude/skills/f2r-check/scripts/next_module.py --path START # 从 START 追踪

Phase 1 检查

# 快速检查
python3 .claude/skills/f2r-check/scripts/f2r_check.py START

# 详细差异报告（含风险标记）
python3 .claude/skills/f2r-check/scripts/f2r_check.py --diff START

# 风险评估
python3 .claude/skills/f2r-check/scripts/f2r_check.py --risk START

# 随机审计 5 个 match 模块
python3 .claude/skills/f2r-check/scripts/f2r_check.py --audit

Phase 2 辅助工具

# 查看模块使用的 COMMON 变量映射
python3 .claude/skills/f2r-check/scripts/common_db.py --module ODFHYS

# 查看 COMMON 块定义
python3 .claude/skills/f2r-check/scripts/common_db.py --block ODFCTR

# 生成深度检查文件列表
python3 .claude/skills/f2r-check/scripts/deep_check_prompt.py ODFHYS

# 查看映射统计
python3 .claude/skills/f2r-check/scripts/common_db.py --mapping

状态处理

状态	行动	输出	允许跳过？
✅ match (无风险)	跳过	"模块已完整，跳过"	✅
✅ match (有风险)	Phase 2	"风险: 2 HIGH → 深度检查"	❌
⚠️ partial	立即修复	"修复: 添加缺失调用..."	❌
❌ mismatch	立即修复	"修复: 修正逻辑..."	❌
❓ missing	立即实现	"修复: 实现模块..."	❌

修复原则

1. 严格对照 Fortran: 按 Fortran 代码行号，逐行对比 Rust 实现
2. 保持调用顺序: Fortran 中的 CALL 顺序必须严格保持
3. 正确映射 COMMON: Fortran COMMON 块变量 → Rust 结构体字段
   • 使用 common_db.py --module <NAME> 查看映射
4. 控制流程等价: IF/DO/SELECT CASE 逻辑必须一致
5. 数组下标转换: Fortran 列主序 → Rust 行主序，1-based → 0-based
6. 复杂模块分解: 遇到复杂模块，分步骤修复，每步验证编译

文件路径

• Fortran: /home/fmq/program/tlusty/tl208-s54/rust/tlusty/extracted/
• Rust: /home/fmq/.zeroclaw/workspace/SpectraRust/src/
• COMMON 定义: /home/fmq/program/tlusty/tl208-s54/tlusty/*.FOR
• Rust struct: /home/fmq/.zeroclaw/workspace/SpectraRust/src/tlusty/state/

脚本修复规则

重要：如果发现脚本报告有误（误报），必须修复脚本！

脚本误报类型

误报类型	原因	修复方法
函数别名未识别	COMPT0 vs compt0_brte	添加到 FUNCTION_ALIASES
注释 I/O 被检测	c write(...) 被当作必须实现	已修复：忽略注释行
辅助函数调用未检测	主函数调用辅助函数，辅助函数包含关键调用	已修复：扫描整个文件

如何修复脚本

1. 添加函数别名：编辑 scripts/f2r_check.py，在 FUNCTION_ALIASES 字典中添加
2. 添加调用提取模式：在 call_patterns 列表中添加新模式
3. 修复后验证：python3 f2r_check.py --diff <MODULE>

风险检测器说明

检测器 A: 2D 数组转置风险

扫描 INCLUDE 文件中的 2D 数组声明（如 XDO(3,MHOD)）， 标记所有访问该数组的模块需要验证下标顺序。

检测器 B: 跨 COMMON 变量混淆

检测已知的易混淆变量对（如 JNDODF vs IJTF）， 当模块同时使用这些变量时标记。

检测器 C: f2r_depends 诚实性检查

对比 // f2r_depends: 注释中声明的函数 vs 代码中实际的调用， 标记声明了但未实际调用的函数。

检测器 D: 索引累加器模式

检测 IJ00=1, IJQ=IJ00+IJ 等索引算术模式， 标记需要验证 1-based → 0-based 转换。