Something went wrong. Try again.
A GNU diffutils-compatible suite of file comparison tools written in Rust
Something went wrong. Try again.
30 kB · 946 lines
Rust
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947use std::fs;use std::io::{self, BufRead, Write};use std::path::Path;use std::process;
fn main() { let args: Vec<String> = std::env::args().collect(); let prog = Path::new(&args[0]) .file_name() .unwrap_or_default() .to_string_lossy() .to_string();
match prog.as_str() { "cmp" => cmp_main(&args[1..]), "sdiff" => sdiff_main(&args[1..]), "diff3" => diff3_main(&args[1..]), _ => diff_main(&args[1..]), }}
// ---------------------------------------------------------------------------// diff// ---------------------------------------------------------------------------
fn diff_main(args: &[String]) { let mut opts = DiffOpts::default(); let mut files = Vec::new(); let mut i = 0;
while i < args.len() { match args[i].as_str() { "--version" => { println!("diff (oxidized-diffutils) {}", env!("CARGO_PKG_VERSION")); process::exit(0); } "--help" => { println!("Usage: diff [OPTION]... FILE1 FILE2"); println!("Compare FILE1 and FILE2 line by line."); println!(" -u, -U NUM, --unified[=NUM] unified diff (default 3 context lines)"); println!(" -c, -C NUM, --context[=NUM] context diff"); println!(" -e, --ed output ed script"); println!(" -n, --rcs output RCS format"); println!(" -y, --side-by-side side-by-side output"); println!(" -q, --brief report only whether files differ"); println!(" -s, --report-identical-files report when files are identical"); println!(" -r, --recursive recursively compare directories"); println!(" -N, --new-file treat absent files as empty"); println!(" -i, --ignore-case ignore case differences"); println!(" -w, --ignore-all-space ignore all white space"); println!(" -b, --ignore-space-change ignore changes in amount of white space"); println!(" -B, --ignore-blank-lines ignore blank line changes"); println!(" -a, --text treat all files as text"); println!(" --label LABEL use LABEL for file name"); println!(" --color[=WHEN] colorize output"); println!(" --no-dereference don't follow symlinks"); process::exit(0); } "-u" | "--unified" => opts.format = DiffFormat::Unified(3), "-c" | "--context" => opts.format = DiffFormat::Context(3), "-e" | "--ed" => opts.format = DiffFormat::Ed, "-n" | "--rcs" => opts.format = DiffFormat::Rcs, "-y" | "--side-by-side" => opts.format = DiffFormat::SideBySide, "-q" | "--brief" => opts.brief = true, "-s" | "--report-identical-files" => opts.report_identical = true, "-r" | "--recursive" => opts.recursive = true, "-N" | "--new-file" => opts.new_file = true, "-i" | "--ignore-case" => opts.ignore_case = true, "-w" | "--ignore-all-space" => opts.ignore_all_space = true, "-b" | "--ignore-space-change" => opts.ignore_space_change = true, "-B" | "--ignore-blank-lines" => opts.ignore_blank_lines = true, "-a" | "--text" => opts.text = true, "--label" => { i += 1; if i < args.len() { opts.labels.push(args[i].clone()); } } "--normal" => opts.format = DiffFormat::Normal, "--color" | "--color=always" | "--color=auto" => {} "--color=never" => {} "--no-dereference" => {} "-U" => { i += 1; if i < args.len() { let n: usize = args[i].parse().unwrap_or(3); opts.format = DiffFormat::Unified(n); } } "-C" => { i += 1; if i < args.len() { let n: usize = args[i].parse().unwrap_or(3); opts.format = DiffFormat::Context(n); } } arg if arg.starts_with("-U") => { let n: usize = arg[2..].parse().unwrap_or(3); opts.format = DiffFormat::Unified(n); } arg if arg.starts_with("-C") => { let n: usize = arg[2..].parse().unwrap_or(3); opts.format = DiffFormat::Context(n); } arg if arg.starts_with("--unified=") => { let n: usize = arg.strip_prefix("--unified=").unwrap().parse().unwrap_or(3); opts.format = DiffFormat::Unified(n); } arg if arg.starts_with("--context=") => { let n: usize = arg.strip_prefix("--context=").unwrap().parse().unwrap_or(3); opts.format = DiffFormat::Context(n); } arg if arg.starts_with("--label=") => { opts.labels .push(arg.strip_prefix("--label=").unwrap().to_string()); } arg if arg.starts_with('-') && arg.len() > 1 => { // Ignore unknown options silently for compatibility } _ => files.push(args[i].clone()), } i += 1; }
if files.len() != 2 { eprintln!("diff: missing operand"); process::exit(2); }
let exit_code = diff_files(&files[0], &files[1], &opts); process::exit(exit_code);}
#[derive(Default)]struct DiffOpts { format: DiffFormat, brief: bool, report_identical: bool, recursive: bool, new_file: bool, ignore_case: bool, ignore_all_space: bool, ignore_space_change: bool, ignore_blank_lines: bool, text: bool, labels: Vec<String>,}
#[derive(Default, Clone)]enum DiffFormat { #[default] Normal, Unified(usize), Context(usize), Ed, Rcs, SideBySide,}
fn read_lines(path: &str) -> io::Result<Vec<String>> { if path == "-" { let stdin = io::stdin(); Ok(stdin.lock().lines().collect::<io::Result<Vec<_>>>()?) } else { let content = fs::read_to_string(path)?; Ok(content.lines().map(|s| s.to_string()).collect()) }}
fn normalize_line(line: &str, opts: &DiffOpts) -> String { let mut s = line.to_string(); if opts.ignore_case { s = s.to_lowercase(); } if opts.ignore_all_space { s.retain(|c| !c.is_whitespace()); } else if opts.ignore_space_change { let mut result = String::new(); let mut in_space = false; for c in s.chars() { if c.is_whitespace() { if !in_space { result.push(' '); in_space = true; } } else { result.push(c); in_space = false; } } s = result; } s}
fn diff_files(path1: &str, path2: &str, opts: &DiffOpts) -> i32 { // Handle directories if Path::new(path1).is_dir() && Path::new(path2).is_dir() { if opts.recursive { return diff_dirs(path1, path2, opts); } eprintln!("diff: {path1}: Is a directory"); return 2; }
let lines1 = match read_lines(path1) { Ok(l) => l, Err(e) => { if opts.new_file { Vec::new() } else { eprintln!("diff: {path1}: {e}"); return 2; } } }; let lines2 = match read_lines(path2) { Ok(l) => l, Err(e) => { if opts.new_file { Vec::new() } else { eprintln!("diff: {path2}: {e}"); return 2; } } };
let edits = compute_diff(&lines1, &lines2, opts);
if edits.is_empty() { if opts.report_identical { println!("Files {path1} and {path2} are identical"); } return 0; }
if opts.brief { println!("Files {path1} and {path2} differ"); return 1; }
let stdout = io::stdout(); let mut out = stdout.lock(); match &opts.format { DiffFormat::Normal => print_normal(&edits, &lines1, &lines2, &mut out), DiffFormat::Unified(ctx) => { let label1 = opts.labels.first().map(|s| s.as_str()).unwrap_or(path1); let label2 = opts.labels.get(1).map(|s| s.as_str()).unwrap_or(path2); print_unified(&edits, &lines1, &lines2, *ctx, label1, label2, &mut out); } DiffFormat::Context(ctx) => { let label1 = opts.labels.first().map(|s| s.as_str()).unwrap_or(path1); let label2 = opts.labels.get(1).map(|s| s.as_str()).unwrap_or(path2); print_context(&edits, &lines1, &lines2, *ctx, label1, label2, &mut out); } DiffFormat::Ed => print_ed(&edits, &lines2, &mut out), DiffFormat::Rcs => print_rcs(&edits, &lines1, &lines2, &mut out), DiffFormat::SideBySide => print_side_by_side(&edits, &lines1, &lines2, &mut out), }
1}
fn diff_dirs(dir1: &str, dir2: &str, opts: &DiffOpts) -> i32 { let mut entries1: Vec<String> = fs::read_dir(dir1) .unwrap_or_else(|_| { eprintln!("diff: {dir1}: No such file or directory"); process::exit(2); }) .filter_map(|e| e.ok().map(|e| e.file_name().to_string_lossy().to_string())) .collect(); let mut entries2: Vec<String> = fs::read_dir(dir2) .unwrap_or_else(|_| { eprintln!("diff: {dir2}: No such file or directory"); process::exit(2); }) .filter_map(|e| e.ok().map(|e| e.file_name().to_string_lossy().to_string())) .collect(); entries1.sort(); entries2.sort();
let mut all: Vec<String> = entries1.clone(); for e in &entries2 { if !all.contains(e) { all.push(e.clone()); } } all.sort();
let mut result = 0; for name in &all { let p1 = format!("{dir1}/{name}"); let p2 = format!("{dir2}/{name}"); let in1 = entries1.contains(name); let in2 = entries2.contains(name);
if in1 && in2 { let r = diff_files(&p1, &p2, opts); if r > result { result = r; } } else if in1 && !in2 { if opts.new_file { let r = diff_files(&p1, &p2, opts); if r > result { result = r; } } else { println!("Only in {dir1}: {name}"); if result < 1 { result = 1; } } } else { if opts.new_file { let r = diff_files(&p1, &p2, opts); if r > result { result = r; } } else { println!("Only in {dir2}: {name}"); if result < 1 { result = 1; } } } } result}
// ---------------------------------------------------------------------------// Myers diff algorithm// ---------------------------------------------------------------------------
#[derive(Debug, Clone)]enum Edit { Equal(usize, usize), // (line_idx_in_a, line_idx_in_b) Delete(usize), // line_idx_in_a Insert(usize), // line_idx_in_b}
fn compute_diff(a: &[String], b: &[String], opts: &DiffOpts) -> Vec<Edit> { let na: Vec<String> = a.iter().map(|l| normalize_line(l, opts)).collect(); let nb: Vec<String> = b.iter().map(|l| normalize_line(l, opts)).collect();
let n = na.len(); let m = nb.len();
if n == 0 && m == 0 { return Vec::new(); } if n == 0 { return (0..m).map(Edit::Insert).collect(); } if m == 0 { return (0..n).map(Edit::Delete).collect(); }
// Myers algorithm for shortest edit script let max = n + m; let sz = 2 * max + 1; let mut v = vec![0i64; sz]; let mut trace: Vec<Vec<i64>> = Vec::new();
let idx = |k: i64| -> usize { (k + max as i64) as usize };
'outer: for d in 0..=(max as i64) { trace.push(v.clone()); let mut k = -d; while k <= d { let mut x = if k == -d || (k != d && v[idx(k - 1)] < v[idx(k + 1)]) { v[idx(k + 1)] } else { v[idx(k - 1)] + 1 }; let mut y = x - k; while (x as usize) < n && (y as usize) < m && na[x as usize] == nb[y as usize] { x += 1; y += 1; } v[idx(k)] = x; if x as usize >= n && y as usize >= m { break 'outer; } k += 2; } }
// Backtrack to build edit script let mut edits = Vec::new(); let mut x = n as i64; let mut y = m as i64;
for d in (0..trace.len()).rev() { let v = &trace[d]; let d = d as i64; let k = x - y;
let prev_k = if k == -d || (k != d && v[idx(k - 1)] < v[idx(k + 1)]) { k + 1 } else { k - 1 };
let prev_x = v[idx(prev_k)]; let prev_y = prev_x - prev_k;
// Diagonal (equal lines) while x > prev_x && y > prev_y { x -= 1; y -= 1; edits.push(Edit::Equal(x as usize, y as usize)); }
if d > 0 { if x == prev_x { // Insert y -= 1; edits.push(Edit::Insert(y as usize)); } else { // Delete x -= 1; edits.push(Edit::Delete(x as usize)); } } }
edits.reverse();
// Filter blank line changes if requested if opts.ignore_blank_lines { edits.retain(|e| match e { Edit::Delete(i) => !a[*i].trim().is_empty(), Edit::Insert(i) => !b[*i].trim().is_empty(), Edit::Equal(_, _) => true, }); }
// Check if there are actual changes if edits.iter().all(|e| matches!(e, Edit::Equal(_, _))) { return Vec::new(); }
edits}
// ---------------------------------------------------------------------------// Output formats// ---------------------------------------------------------------------------
fn print_normal(edits: &[Edit], a: &[String], b: &[String], out: &mut impl Write) { // Group consecutive edits into hunks let mut i = 0; while i < edits.len() { match &edits[i] { Edit::Equal(_, _) => { i += 1; } Edit::Delete(ai) => { let start = *ai; let mut end = start; let mut j = i + 1; while j < edits.len() { if let Edit::Delete(aj) = &edits[j] { if *aj == end + 1 { end = *aj; j += 1; } else { break; } } else { break; } } // Check for following inserts (change) let mut ins_start = None; let mut ins_end = 0; let mut k = j; while k < edits.len() { if let Edit::Insert(bi) = &edits[k] { if ins_start.is_none() { ins_start = Some(*bi); } ins_end = *bi; k += 1; } else { break; } } if let Some(is) = ins_start { // Change let _ = writeln!( out, "{}{}c{}{}", start + 1, if end > start { format!(",{}", end + 1) } else { String::new() }, is + 1, if ins_end > is { format!(",{}", ins_end + 1) } else { String::new() } ); for idx in start..=end { let _ = writeln!(out, "< {}", a[idx]); } let _ = writeln!(out, "---"); for idx in is..=ins_end { let _ = writeln!(out, "> {}", b[idx]); } i = k; } else { // Delete let _ = writeln!( out, "{}{}d{}", start + 1, if end > start { format!(",{}", end + 1) } else { String::new() }, start ); // approximate for idx in start..=end { let _ = writeln!(out, "< {}", a[idx]); } i = j; } } Edit::Insert(bi) => { let start = *bi; let mut end = start; let mut j = i + 1; while j < edits.len() { if let Edit::Insert(bj) = &edits[j] { if *bj == end + 1 { end = *bj; j += 1; } else { break; } } else { break; } } // Find the position in file a let a_pos = edits[..i] .iter() .rev() .find_map(|e| match e { Edit::Equal(ai, _) | Edit::Delete(ai) => Some(*ai + 1), _ => None, }) .unwrap_or(0); let _ = writeln!( out, "{}a{}{}", a_pos, start + 1, if end > start { format!(",{}", end + 1) } else { String::new() } ); for idx in start..=end { let _ = writeln!(out, "> {}", b[idx]); } i = j; } } }}
fn print_unified( edits: &[Edit], a: &[String], b: &[String], ctx: usize, label1: &str, label2: &str, out: &mut impl Write,) { let _ = writeln!(out, "--- {}", label1); let _ = writeln!(out, "+++ {}", label2);
// Build hunks with context let hunks = build_hunks(edits, ctx); for hunk in hunks { let (a_start, a_count, b_start, b_count) = hunk_range(&hunk, a.len(), b.len()); let _ = writeln!( out, "@@ -{},{} +{},{} @@", a_start + 1, a_count, b_start + 1, b_count ); for edit in &hunk { match edit { Edit::Equal(ai, _) => { let _ = writeln!(out, " {}", a[*ai]); } Edit::Delete(ai) => { let _ = writeln!(out, "-{}", a[*ai]); } Edit::Insert(bi) => { let _ = writeln!(out, "+{}", b[*bi]); } } } }}
fn print_context( edits: &[Edit], a: &[String], b: &[String], ctx: usize, label1: &str, label2: &str, out: &mut impl Write,) { let _ = writeln!(out, "*** {}", label1); let _ = writeln!(out, "--- {}", label2);
let hunks = build_hunks(edits, ctx); for hunk in hunks { let (a_start, a_count, b_start, b_count) = hunk_range(&hunk, a.len(), b.len()); let _ = writeln!(out, "***************"); let _ = writeln!(out, "*** {},{} ****", a_start + 1, a_start + a_count); for edit in &hunk { match edit { Edit::Equal(ai, _) => { let _ = writeln!(out, " {}", a[*ai]); } Edit::Delete(ai) => { let _ = writeln!(out, "- {}", a[*ai]); } Edit::Insert(_) => {} } } let _ = writeln!(out, "--- {},{} ----", b_start + 1, b_start + b_count); for edit in &hunk { match edit { Edit::Equal(_, bi) => { let _ = writeln!(out, " {}", b[*bi]); } Edit::Delete(_) => {} Edit::Insert(bi) => { let _ = writeln!(out, "+ {}", b[*bi]); } } } }}
fn print_ed(edits: &[Edit], b: &[String], out: &mut impl Write) { // ed format: output changes in reverse order let mut i = edits.len(); while i > 0 { i -= 1; match &edits[i] { Edit::Equal(_, _) => {} Edit::Delete(ai) => { let _ = writeln!(out, "{}d", ai + 1); } Edit::Insert(bi) => { let a_pos = edits[..=i] .iter() .rev() .find_map(|e| match e { Edit::Equal(ai, _) | Edit::Delete(ai) => Some(*ai + 1), _ => None, }) .unwrap_or(0); let _ = writeln!(out, "{}a", a_pos); let _ = writeln!(out, "{}", b[*bi]); let _ = writeln!(out, "."); } } }}
fn print_rcs(edits: &[Edit], a: &[String], b: &[String], out: &mut impl Write) { for edit in edits { match edit { Edit::Equal(_, _) => {} Edit::Delete(ai) => { let _ = writeln!(out, "d{} 1", ai + 1); } Edit::Insert(bi) => { let a_pos = edits .iter() .take_while(|e| !std::ptr::eq(*e, edit)) .filter_map(|e| match e { Edit::Equal(ai, _) | Edit::Delete(ai) => Some(*ai + 1), _ => None, }) .last() .unwrap_or(0); let _ = writeln!(out, "a{} 1", a_pos); let _ = writeln!(out, "{}", b[*bi]); } } } let _ = a; // suppress warning}
fn print_side_by_side(edits: &[Edit], a: &[String], b: &[String], out: &mut impl Write) { let width = 80; let col = (width - 3) / 2; for edit in edits { match edit { Edit::Equal(ai, _) => { let _ = writeln!( out, "{:<col$} {}", truncate(&a[*ai], col), truncate(&a[*ai], col) ); } Edit::Delete(ai) => { let _ = writeln!(out, "{:<col$} <", truncate(&a[*ai], col)); } Edit::Insert(bi) => { let _ = writeln!(out, "{:<col$} > {}", "", truncate(&b[*bi], col)); } } }}
fn truncate(s: &str, max: usize) -> String { if s.len() <= max { s.to_string() } else { format!("{}...", &s[..max.saturating_sub(3)]) }}
fn build_hunks(edits: &[Edit], ctx: usize) -> Vec<Vec<Edit>> { let mut hunks: Vec<Vec<Edit>> = Vec::new(); let mut current: Vec<Edit> = Vec::new(); let mut last_change = None;
for (i, edit) in edits.iter().enumerate() { let is_change = !matches!(edit, Edit::Equal(_, _)); if is_change { // Add context before let ctx_start = if i >= ctx { i - ctx } else { 0 }; if current.is_empty() { for j in ctx_start..i { if matches!(edits[j], Edit::Equal(_, _)) { current.push(edits[j].clone()); } } } else if let Some(lc) = last_change { // Fill gap between last change and this one for j in (lc + 1)..i { current.push(edits[j].clone()); } } current.push(edit.clone()); last_change = Some(i); } else if let Some(lc) = last_change { if i - lc <= ctx * 2 { current.push(edit.clone()); } else if i - lc == ctx * 2 + 1 { // Add remaining context and start new hunk current.push(edit.clone()); } else if i - lc == ctx + 1 { // Just finished context after current.push(edit.clone()); } else if !current.is_empty() && i == lc + ctx + 1 { // One past context } else if !current.is_empty() { hunks.push(current); current = Vec::new(); last_change = None; } } }
// Add trailing context if let Some(lc) = last_change { for j in (lc + 1)..edits.len().min(lc + ctx + 1) { if matches!(edits[j], Edit::Equal(_, _)) { current.push(edits[j].clone()); } } }
if !current.is_empty() { hunks.push(current); }
hunks}
fn hunk_range(hunk: &[Edit], _a_len: usize, _b_len: usize) -> (usize, usize, usize, usize) { let mut a_start = usize::MAX; let mut a_end = 0; let mut b_start = usize::MAX; let mut b_end = 0;
for edit in hunk { match edit { Edit::Equal(ai, bi) => { a_start = a_start.min(*ai); a_end = a_end.max(*ai + 1); b_start = b_start.min(*bi); b_end = b_end.max(*bi + 1); } Edit::Delete(ai) => { a_start = a_start.min(*ai); a_end = a_end.max(*ai + 1); } Edit::Insert(bi) => { b_start = b_start.min(*bi); b_end = b_end.max(*bi + 1); } } }
if a_start == usize::MAX { a_start = 0; } if b_start == usize::MAX { b_start = 0; }
(a_start, a_end - a_start, b_start, b_end - b_start)}
// ---------------------------------------------------------------------------// cmp// ---------------------------------------------------------------------------
fn cmp_main(args: &[String]) { let mut silent = false; let mut files = Vec::new();
for arg in args { match arg.as_str() { "--version" => { println!("cmp (oxidized-diffutils) {}", env!("CARGO_PKG_VERSION")); process::exit(0); } "-s" | "--silent" | "--quiet" => silent = true, "-l" | "--verbose" => {} // TODO arg if arg.starts_with('-') => {} _ => files.push(arg.clone()), } }
if files.len() < 2 { eprintln!("cmp: missing operand"); process::exit(2); }
let data1 = match fs::read(&files[0]) { Ok(d) => d, Err(e) => { eprintln!("cmp: {}: {e}", files[0]); process::exit(2); } }; let data2 = match fs::read(&files[1]) { Ok(d) => d, Err(e) => { eprintln!("cmp: {}: {e}", files[1]); process::exit(2); } };
let mut byte_pos = 0usize; let mut line = 1usize;
for (b1, b2) in data1.iter().zip(data2.iter()) { byte_pos += 1; if *b1 == b'\n' { line += 1; } if b1 != b2 { if !silent { println!( "{} {} differ: byte {byte_pos}, line {line}", files[0], files[1] ); } process::exit(1); } }
if data1.len() != data2.len() { if !silent { let shorter = if data1.len() < data2.len() { &files[0] } else { &files[1] }; eprintln!("cmp: EOF on {shorter}"); } process::exit(1); }
process::exit(0);}
// ---------------------------------------------------------------------------// sdiff (stub)// ---------------------------------------------------------------------------
fn sdiff_main(args: &[String]) { for arg in args { if arg == "--version" { println!("sdiff (oxidized-diffutils) {}", env!("CARGO_PKG_VERSION")); process::exit(0); } } // sdiff is side-by-side diff; delegate to diff -y let mut new_args = vec!["-y".to_string()]; new_args.extend_from_slice(args); diff_main(&new_args);}
// ---------------------------------------------------------------------------// diff3 (stub)// ---------------------------------------------------------------------------
fn diff3_main(args: &[String]) { for arg in args { if arg == "--version" { println!("diff3 (oxidized-diffutils) {}", env!("CARGO_PKG_VERSION")); process::exit(0); } } eprintln!("diff3: not yet implemented"); process::exit(2);}