cobolx 1.0.0

package/src/cobol/layout.rs

@@ -0,0 +1,278 @@
+use crate::cobol::model::ParsedDataItem;
+use std::collections::HashMap;
+
+#[derive(Debug)]
+struct Frame {
+    idx: usize,
+    level: u16,
+    base_offset: i64,
+    cursor: i64,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct Storage {
+    bytes: Option<i64>,
+    kind: &'static str,
+    status: &'static str,
+}
+
+pub(crate) fn compute_physical_layout(items: &mut [ParsedDataItem]) {
+    let mut stack = vec![Frame {
+        idx: usize::MAX,
+        level: 0,
+        base_offset: 0,
+        cursor: 0,
+    }];
+    let mut known_offsets = HashMap::<String, i64>::with_capacity(items.len());
+
+    for idx in 0..items.len() {
+        let level = items[idx].level;
+        while stack.last().is_some_and(|frame| frame.level >= level) {
+            close_group(items, &mut stack, &mut known_offsets);
+        }
+
+        if matches!(level, 66 | 88) {
+            items[idx].byte_offset = current_cursor(&stack);
+            items[idx].byte_size = Some(0);
+            items[idx].storage_kind = Some(
+                if level == 66 {
+                    "rename"
+                } else {
+                    "condition-name"
+                }
+                .to_string(),
+            );
+            items[idx].layout_status = Some("no-storage".to_string());
+            known_offsets.insert(items[idx].name.clone(), items[idx].byte_offset.unwrap_or(0));
+            continue;
+        }
+
+        let offset = items[idx]
+            .redefines
+            .as_ref()
+            .and_then(|name| known_offsets.get(name).copied())
+            .unwrap_or_else(|| current_cursor(&stack).unwrap_or(0));
+
+        items[idx].byte_offset = Some(offset);
+
+        let storage = classify_storage(&items[idx]);
+        if storage.kind == "group" {
+            items[idx].storage_kind = Some("group".to_string());
+            items[idx].layout_status = Some("pending".to_string());
+            stack.push(Frame {
+                idx,
+                level,
+                base_offset: offset,
+                cursor: offset,
+            });
+            known_offsets.insert(items[idx].name.clone(), offset);
+            continue;
+        }
+
+        let occurs = item_occurs(&items[idx]);
+        let total_bytes = storage.bytes.map(|bytes| bytes.saturating_mul(occurs));
+        items[idx].byte_size = total_bytes;
+        items[idx].storage_kind = Some(storage.kind.to_string());
+        items[idx].layout_status = Some(storage.status.to_string());
+
+        if let Some(total) = total_bytes {
+            advance_parent(&mut stack, offset.saturating_add(total));
+        }
+        known_offsets.insert(items[idx].name.clone(), offset);
+    }
+
+    while stack.len() > 1 {
+        close_group(items, &mut stack, &mut known_offsets);
+    }
+}
+
+fn close_group(
+    items: &mut [ParsedDataItem],
+    stack: &mut Vec<Frame>,
+    known_offsets: &mut HashMap<String, i64>,
+) {
+    let Some(frame) = stack.pop() else {
+        return;
+    };
+
+    let unit_bytes = frame.cursor.saturating_sub(frame.base_offset);
+    let total_bytes = unit_bytes.saturating_mul(item_occurs(&items[frame.idx]));
+    items[frame.idx].byte_size = Some(total_bytes);
+    items[frame.idx].layout_status = Some("derived".to_string());
+    advance_parent(stack, frame.base_offset.saturating_add(total_bytes));
+    known_offsets.insert(items[frame.idx].name.clone(), frame.base_offset);
+}
+
+fn current_cursor(stack: &[Frame]) -> Option<i64> {
+    stack.last().map(|frame| frame.cursor)
+}
+
+fn advance_parent(stack: &mut [Frame], end_offset: i64) {
+    if let Some(parent) = stack.last_mut() {
+        parent.cursor = parent.cursor.max(end_offset);
+    }
+}
+
+fn item_occurs(item: &ParsedDataItem) -> i64 {
+    item.occurs.unwrap_or(1).max(1)
+}
+
+fn classify_storage(item: &ParsedDataItem) -> Storage {
+    let usage = item
+        .usage_clause
+        .as_deref()
+        .map(normalize_usage)
+        .unwrap_or_else(|| "DISPLAY".to_string());
+
+    if item.pic.is_none() {
+        return match usage.as_str() {
+            "COMP-1" | "COMPUTATIONAL-1" => Storage {
+                bytes: Some(4),
+                kind: "float",
+                status: "exact",
+            },
+            "COMP-2" | "COMPUTATIONAL-2" => Storage {
+                bytes: Some(8),
+                kind: "float",
+                status: "exact",
+            },
+            "POINTER" => Storage {
+                bytes: Some(8),
+                kind: "pointer",
+                status: "estimated",
+            },
+            "INDEX" => Storage {
+                bytes: Some(4),
+                kind: "index",
+                status: "estimated",
+            },
+            _ => Storage {
+                bytes: None,
+                kind: "group",
+                status: "pending",
+            },
+        };
+    }
+
+    let pic = item.pic.as_deref().unwrap_or_default();
+    match usage.as_str() {
+        "COMP-3" | "COMPUTATIONAL-3" | "PACKED-DECIMAL" => {
+            let digits = picture_digits(pic);
+            Storage {
+                bytes: digits.map(|d| (d + 2) / 2),
+                kind: "packed-decimal",
+                status: "exact",
+            }
+        }
+        "BINARY" | "COMP" | "COMP-4" | "COMP-5" | "COMPUTATIONAL" | "COMPUTATIONAL-4"
+        | "COMPUTATIONAL-5" => {
+            let digits = picture_digits(pic);
+            Storage {
+                bytes: digits.and_then(binary_bytes_for_digits),
+                kind: "binary",
+                status: "estimated",
+            }
+        }
+        "COMP-1" | "COMPUTATIONAL-1" => Storage {
+            bytes: Some(4),
+            kind: "float",
+            status: "exact",
+        },
+        "COMP-2" | "COMPUTATIONAL-2" => Storage {
+            bytes: Some(8),
+            kind: "float",
+            status: "exact",
+        },
+        "NATIONAL" => Storage {
+            bytes: picture_positions(pic).map(|positions| positions.saturating_mul(2)),
+            kind: "national",
+            status: "estimated",
+        },
+        _ => {
+            let positions = picture_positions(pic);
+            let has_national = expanded_picture_chars(pic).any(|ch| ch == 'N');
+            Storage {
+                bytes: positions.map(|n| if has_national { n.saturating_mul(2) } else { n }),
+                kind: "display",
+                status: if has_national { "estimated" } else { "exact" },
+            }
+        }
+    }
+}
+
+fn normalize_usage(usage: &str) -> String {
+    usage
+        .split_whitespace()
+        .filter(|part| *part != "IS")
+        .collect::<Vec<_>>()
+        .join("-")
+        .to_ascii_uppercase()
+}
+
+fn binary_bytes_for_digits(digits: i64) -> Option<i64> {
+    match digits {
+        1..=4 => Some(2),
+        5..=9 => Some(4),
+        10..=18 => Some(8),
+        _ => None,
+    }
+}
+
+fn picture_digits(pic: &str) -> Option<i64> {
+    let digits = expanded_picture_chars(pic)
+        .filter(|ch| matches!(*ch, '9' | 'Z' | '*'))
+        .count() as i64;
+    (digits > 0).then_some(digits)
+}
+
+fn picture_positions(pic: &str) -> Option<i64> {
+    let positions = expanded_picture_chars(pic)
+        .filter(|ch| !matches!(*ch, 'S' | 'V' | 'P'))
+        .count() as i64;
+    (positions > 0).then_some(positions)
+}
+
+fn expanded_picture_chars(pic: &str) -> impl Iterator<Item = char> + '_ {
+    PictureChars {
+        chars: pic.chars().peekable(),
+        repeat_char: None,
+        repeat_left: 0,
+    }
+}
+
+struct PictureChars<I: Iterator<Item = char>> {
+    chars: std::iter::Peekable<I>,
+    repeat_char: Option<char>,
+    repeat_left: usize,
+}
+
+impl<I: Iterator<Item = char>> Iterator for PictureChars<I> {
+    type Item = char;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.repeat_left > 0 {
+            self.repeat_left -= 1;
+            return self.repeat_char;
+        }
+
+        let ch = self.chars.next()?.to_ascii_uppercase();
+        if self.chars.peek() == Some(&'(') {
+            self.chars.next();
+            let mut n = String::new();
+            while let Some(next) = self.chars.peek().copied() {
+                self.chars.next();
+                if next == ')' {
+                    break;
+                }
+                n.push(next);
+            }
+            let repeat = n.parse::<usize>().unwrap_or(1);
+            if repeat > 1 {
+                self.repeat_char = Some(ch);
+                self.repeat_left = repeat - 1;
+            }
+        }
+
+        Some(ch)
+    }
+}

package/src/cobol/lexer.rs

@@ -0,0 +1,135 @@
+use crate::cobol::model::{LogicalLine, Token};
+
+pub(crate) fn logical_lines(content: &str) -> Vec<LogicalLine> {
+    let mut lines = Vec::new();
+    let mut current = String::new();
+    let mut current_start = 0usize;
+    let mut current_len = 0usize;
+    let mut offset = 0usize;
+
+    for raw_line in content.lines() {
+        let raw_start = offset;
+        let raw_len = raw_line.len();
+        offset += raw_len + 1;
+
+        let Some(code) = code_line(raw_line) else {
+            continue;
+        };
+        let trimmed = code.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+
+        if current.is_empty() {
+            current_start = raw_start + code.find(trimmed).unwrap_or(0);
+            current_len = raw_len;
+        } else {
+            current.push(' ');
+            current_len = (raw_start + raw_len).saturating_sub(current_start);
+        }
+        current.push_str(trimmed);
+
+        if has_statement_terminator(trimmed) {
+            lines.push(LogicalLine {
+                text: std::mem::take(&mut current),
+                start_offset: current_start,
+                byte_len: current_len,
+            });
+            current_len = 0;
+        }
+    }
+
+    if !current.is_empty() {
+        lines.push(LogicalLine {
+            text: current,
+            start_offset: current_start,
+            byte_len: current_len,
+        });
+    }
+
+    lines
+}
+
+pub(crate) fn tokenize(line: &str) -> Vec<Token> {
+    let bytes = line.as_bytes();
+    let mut tokens = Vec::new();
+    let mut i = 0usize;
+
+    while i < bytes.len() {
+        let b = bytes[i];
+        if b == b'\'' || b == b'"' {
+            let quote = b;
+            let start = i;
+            i += 1;
+            let text_start = i;
+            while i < bytes.len() && bytes[i] != quote {
+                i += 1;
+            }
+            tokens.push(Token {
+                text: line[text_start..i].to_ascii_uppercase(),
+                start,
+                quoted: true,
+            });
+            if i < bytes.len() {
+                i += 1;
+            }
+        } else if is_name_byte(b) {
+            let start = i;
+            while i < bytes.len() && is_name_byte(bytes[i]) {
+                i += 1;
+            }
+            tokens.push(Token {
+                text: line[start..i].to_ascii_uppercase(),
+                start,
+                quoted: false,
+            });
+        } else {
+            i += 1;
+        }
+    }
+
+    tokens
+}
+
+pub(crate) fn clean_name(name: &str) -> String {
+    name.trim_matches('.')
+        .trim_matches(',')
+        .trim()
+        .to_ascii_uppercase()
+}
+
+fn code_line(line: &str) -> Option<&str> {
+    let trimmed = line.trim_start();
+    if trimmed.is_empty() || trimmed.starts_with('*') {
+        return None;
+    }
+    if matches!(line.as_bytes().get(6), Some(b'*' | b'/')) {
+        return None;
+    }
+    line.split("*>").next().map(str::trim_end)
+}
+
+fn has_statement_terminator(line: &str) -> bool {
+    let mut quote = None::<u8>;
+    let bytes = line.as_bytes();
+
+    for (idx, b) in bytes.iter().enumerate() {
+        match (quote, *b) {
+            (Some(q), c) if c == q => quote = None,
+            (None, b'\'' | b'"') => quote = Some(*b),
+            (None, b'.') => {
+                let next = bytes.get(idx + 1).copied();
+                if next.map_or(true, |c| c.is_ascii_whitespace()) {
+                    return true;
+                }
+            }
+            _ => {}
+        }
+    }
+
+    false
+}
+
+fn is_name_byte(b: u8) -> bool {
+    b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'$' | b'#' | b'@')
+}

package/src/cobol/model.rs

@@ -0,0 +1,196 @@
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CallKind {
+    Static,
+    Dynamic,
+}
+
+impl CallKind {
+    pub(crate) fn as_str(self) -> &'static str {
+        match self {
+            CallKind::Static => "static",
+            CallKind::Dynamic => "dynamic",
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct CallSummary {
+    pub target: String,
+    pub kind: CallKind,
+    pub using_count: usize,
+}
+
+#[derive(Debug, Clone)]
+pub struct CopybookSummary {
+    pub name: String,
+    pub resolved_path: Option<PathBuf>,
+    pub has_replacing: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct ProgramSummary {
+    pub name: String,
+    pub path: PathBuf,
+    pub copybooks: Vec<CopybookSummary>,
+    pub calls: Vec<CallSummary>,
+    pub data_items: usize,
+}
+
+#[derive(Debug, Clone)]
+pub struct IndexReport {
+    pub files: Vec<crate::cobol::scanner::CobolFileEntry>,
+    pub source_count: usize,
+    pub copybook_count: usize,
+    pub programs: Vec<ProgramSummary>,
+    pub copybook_uses: usize,
+    pub resolved_copybooks: usize,
+    pub unresolved_copybooks: Vec<String>,
+    pub static_calls: usize,
+    pub dynamic_calls: usize,
+    pub data_items: usize,
+}
+
+impl IndexReport {
+    pub fn to_message(&self, db_path: &Path) -> String {
+        let mut out = format!(
+            "Project index initialized.\n  Files: {} (sources: {}, copybooks: {})\n  Programs: {}\n  COPY uses: {} resolved / {} total\n  CALL edges: {} static, {} dynamic\n  DATA items: {}\n  SQLite: {}",
+            self.files.len(),
+            self.source_count,
+            self.copybook_count,
+            self.programs.len(),
+            self.resolved_copybooks,
+            self.copybook_uses,
+            self.static_calls,
+            self.dynamic_calls,
+            self.data_items,
+            db_path.to_string_lossy(),
+        );
+
+        if !self.programs.is_empty() {
+            out.push_str("\n\nPrograms:");
+            for program in self.programs.iter().take(20) {
+                out.push_str(&format!(
+                    "\n  - {} ({})",
+                    program.name,
+                    program.path.to_string_lossy()
+                ));
+                if !program.copybooks.is_empty() {
+                    let names = program
+                        .copybooks
+                        .iter()
+                        .map(|c| {
+                            if c.resolved_path.is_some() {
+                                if c.has_replacing {
+                                    format!("{}:resolved+replacing", c.name)
+                                } else {
+                                    format!("{}:resolved", c.name)
+                                }
+                            } else {
+                                format!("{}:missing", c.name)
+                            }
+                        })
+                        .collect::<Vec<_>>()
+                        .join(", ");
+                    out.push_str(&format!("\n      COPY: {}", names));
+                }
+                if !program.calls.is_empty() {
+                    let calls = program
+                        .calls
+                        .iter()
+                        .map(|c| {
+                            format!("{}({}; USING {})", c.target, c.kind.as_str(), c.using_count)
+                        })
+                        .collect::<Vec<_>>()
+                        .join(", ");
+                    out.push_str(&format!("\n      CALL: {}", calls));
+                }
+                if program.data_items > 0 {
+                    out.push_str(&format!("\n      DATA: {} item(s)", program.data_items));
+                }
+            }
+            if self.programs.len() > 20 {
+                out.push_str(&format!(
+                    "\n  ... {} more program(s)",
+                    self.programs.len() - 20
+                ));
+            }
+        }
+
+        if !self.unresolved_copybooks.is_empty() {
+            out.push_str("\n\nUnresolved COPY:");
+            for name in self.unresolved_copybooks.iter().take(20) {
+                out.push_str(&format!("\n  - {}", name));
+            }
+        }
+
+        out
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ParsedProgram {
+    pub(crate) name: String,
+    pub(crate) start_offset: usize,
+    pub(crate) byte_len: usize,
+}
+
+#[derive(Debug)]
+pub(crate) struct ParsedCopy {
+    pub(crate) name: String,
+    pub(crate) start_offset: usize,
+    pub(crate) byte_len: usize,
+    pub(crate) replacing_text: Option<String>,
+}
+
+#[derive(Debug)]
+pub(crate) struct ParsedCall {
+    pub(crate) caller_name: Option<String>,
+    pub(crate) target: String,
+    pub(crate) kind: CallKind,
+    pub(crate) start_offset: usize,
+    pub(crate) byte_len: usize,
+    pub(crate) using_count: usize,
+}
+
+#[derive(Debug)]
+pub(crate) struct ParsedDataItem {
+    pub(crate) source_path: PathBuf,
+    pub(crate) name: String,
+    pub(crate) level: u16,
+    pub(crate) parent_name: Option<String>,
+    pub(crate) pic: Option<String>,
+    pub(crate) usage_clause: Option<String>,
+    pub(crate) occurs: Option<i64>,
+    pub(crate) redefines: Option<String>,
+    pub(crate) section: Option<String>,
+    pub(crate) byte_offset: Option<i64>,
+    pub(crate) byte_size: Option<i64>,
+    pub(crate) storage_kind: Option<String>,
+    pub(crate) layout_status: Option<String>,
+    pub(crate) start_offset: usize,
+    pub(crate) byte_len: usize,
+}
+
+#[derive(Debug)]
+pub(crate) struct ParsedFile {
+    pub(crate) path: PathBuf,
+    pub(crate) programs: Vec<ParsedProgram>,
+    pub(crate) copies: Vec<ParsedCopy>,
+    pub(crate) calls: Vec<ParsedCall>,
+}
+
+#[derive(Debug)]
+pub(crate) struct Token {
+    pub(crate) text: String,
+    pub(crate) start: usize,
+    pub(crate) quoted: bool,
+}
+
+#[derive(Debug)]
+pub(crate) struct LogicalLine {
+    pub(crate) text: String,
+    pub(crate) start_offset: usize,
+    pub(crate) byte_len: usize,
+}

package/src/cobol/scanner.rs

@@ -0,0 +1,72 @@
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum CobolFileType {
+    Source,   // .cbl, .cob, .coo
+    Copybook, // .cpy
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct CobolFileEntry {
+    pub path: PathBuf,
+    pub file_type: CobolFileType,
+    pub size_bytes: u64,
+}
+
+/// Recursively scans `dir` for COBOL source and copybook files, ignoring common directories.
+/// The root directory is always scanned; exclusion rules only apply to subdirectories.
+pub fn scan_sandbox(dir: &Path) -> std::io::Result<Vec<CobolFileEntry>> {
+    let mut files = Vec::new();
+    scan_dir_entries(dir, &mut files)?;
+    files.sort_by(|a, b| a.path.cmp(&b.path));
+    Ok(files)
+}
+
+/// Returns true if a directory name should be excluded from scanning.
+fn should_exclude_dir(name: &str) -> bool {
+    name.starts_with('.')
+        || name == "target"
+        || name == "node_modules"
+        || name == "vendor"
+        || name == "build"
+}
+
+/// Scans entries within `dir`. Does NOT check exclusion on `dir` itself —
+/// callers are responsible for filtering before recursing.
+fn scan_dir_entries(dir: &Path, files: &mut Vec<CobolFileEntry>) -> std::io::Result<()> {
+    if !dir.is_dir() {
+        return Ok(());
+    }
+
+    for entry in std::fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_dir() {
+            // Apply exclusion only to child directories, not the root
+            if let Some(name) = path.file_name().and_then(|s| s.to_str()) {
+                if should_exclude_dir(name) {
+                    continue;
+                }
+            }
+            scan_dir_entries(&path, files)?;
+        } else if path.is_file() {
+            if let Some(ext) = path.extension().and_then(|s| s.to_str()) {
+                let ext_lower = ext.to_lowercase();
+                let file_type = match ext_lower.as_str() {
+                    "cbl" | "cob" | "coo" => Some(CobolFileType::Source),
+                    "cpy" => Some(CobolFileType::Copybook),
+                    _ => None,
+                };
+                if let Some(ft) = file_type {
+                    let size_bytes = entry.metadata()?.len();
+                    files.push(CobolFileEntry {
+                        path,
+                        file_type: ft,
+                        size_bytes,
+                    });
+                }
+            }
+        }
+    }
+    Ok(())
+}