//! column -- format stdin/files into columns use std::ffi::OsString;use std::io::{self, BufRead, BufReader, Write}; pub fn main(args: Vec<OsString>) -> i32 {    let str_args: Vec<String> = args        .iter()        .skip(1)        .map(|a| a.to_string_lossy().to_string())        .collect();     let mut table_mode = false;    let mut separator = String::new(); // empty = default whitespace splitting    let mut filenames: Vec<String> = Vec::new();     let mut i = 0;    while i < str_args.len() {        match str_args[i].as_str() {            "-t" => table_mode = true,            "-s" => {                i += 1;                if i >= str_args.len() {                    eprintln!("column: option '-s' requires an argument");                    return 1;                }                separator = str_args[i].clone();            }            s if s.starts_with("-s") && s.len() > 2 => {                separator = s[2..].to_string();            }            s if s.starts_with('-') && s.len() > 1 => {                eprintln!("column: unknown option '{}'", s);                return 1;            }            _ => filenames.push(str_args[i].clone()),        }        i += 1;    }     // Collect all input lines    let mut lines: Vec<String> = Vec::new();    if filenames.is_empty() {        let stdin = io::stdin();        for line in stdin.lock().lines() {            match line {                Ok(l) => lines.push(l),                Err(e) => {                    eprintln!("column: {}", e);                    return 1;                }            }        }    } else {        for filename in &filenames {            match std::fs::File::open(filename) {                Ok(f) => {                    for line in BufReader::new(f).lines() {                        match line {                            Ok(l) => lines.push(l),                            Err(e) => {                                eprintln!("column: {}: {}", filename, e);                                return 1;                            }                        }                    }                }                Err(e) => {                    eprintln!("column: {}: {}", filename, e);                    return 1;                }            }        }    }     let stdout = io::stdout();    let mut out = stdout.lock();     let result = if table_mode {        format_table(&lines, &separator, &mut out)    } else {        format_columns(&lines, &mut out)    }    .and_then(|()| out.flush());     if let Err(error) = result {        eprintln!("column: failed to write output: {error}");        return 1;    }     0} /// Table mode (-t): split each line into fields and pad to column widths.fn format_table<W: Write>(lines: &[String], separator: &str, out: &mut W) -> io::Result<()> {    // Split lines into rows of fields    let rows: Vec<Vec<&str>> = lines        .iter()        .map(|line| {            if separator.is_empty() {                line.split_whitespace().collect()            } else {                line.split(&separator[..]).collect()            }        })        .collect();     if rows.is_empty() {        return Ok(());    }     // Find max width for each column    let max_cols = rows.iter().map(|r| r.len()).max().unwrap_or(0);    let mut col_widths = vec![0usize; max_cols];    for row in &rows {        for (j, field) in row.iter().enumerate() {            let width = field.chars().count();            if width > col_widths[j] {                col_widths[j] = width;            }        }    }     // Print padded rows    for row in &rows {        for (j, field) in row.iter().enumerate() {            if j > 0 {                write!(out, "  ")?;            }            if j + 1 < row.len() {                // Pad all columns except the last                let width = field.chars().count();                write!(out, "{}", field)?;                for _ in width..col_widths[j] {                    write!(out, " ")?;                }            } else {                write!(out, "{}", field)?;            }        }        writeln!(out)?;    }     Ok(())} /// Default mode: fill columns across the terminal width (simplified: 80 chars).fn format_columns<W: Write>(lines: &[String], out: &mut W) -> io::Result<()> {    // Filter out empty lines    let entries: Vec<&str> = lines        .iter()        .map(|s| s.as_str())        .filter(|s| !s.is_empty())        .collect();    if entries.is_empty() {        return Ok(());    }     let term_width: usize = 80;    let max_entry_width = entries.iter().map(|e| e.chars().count()).max().unwrap_or(0);    let col_width = max_entry_width + 2; // 2-char padding     if col_width == 0 || col_width > term_width {        // One per line        for entry in &entries {            writeln!(out, "{}", entry)?;        }        return Ok(());    }     let num_cols = term_width / col_width;    let num_cols = if num_cols == 0 { 1 } else { num_cols };     for (i, entry) in entries.iter().enumerate() {        let is_last_in_row = (i + 1) % num_cols == 0 || i + 1 == entries.len();        if is_last_in_row {            writeln!(out, "{}", entry)?;        } else {            let width = entry.chars().count();            write!(out, "{}", entry)?;            for _ in width..col_width {                write!(out, " ")?;            }        }    }     Ok(())}