test(conformance): gate scanf scansets, printf positional/*, ecvt/fcvt rounding

Probed three complex, hand-rolled, previously-ungated code paths vs host glibc
and verified each matches exactly — now permanent gates (run in the suite, no
#[ignore]):

- conformance_diff_scanf_scanset: %[...] edge cases — negation, ranges, ] as the
  first set member, '-' at set ends, reversed ranges (c-a), width limits, the
  A-z punctuation span. Distinct hand-rolled state machine, not the numeric
  parsers.
- conformance_diff_printf_positional: %N$ positional args + dynamic width/
  precision (*) incl. %21$.*3-style combinations — the argument-reordering
  path, across flags and several int triples.
- conformance_diff_ecvt_rounding: ecvt/fcvt over NORMAL values x ndigit in
  {0, negative, huge} — digit string + decpt + sign — complementing the existing
  specials-only cvt gate.

All pass with 0 divergences vs host glibc. No fixes needed (these paths are
already conformant) — the gates protect them from future regression. (Also
verified clean this session, not promoted: strfmon C-locale formatting.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Dicklesworthstone

crates/frankenlibc-abi/tests/conformance_diff_ecvt_rounding.rs

@@ -0,0 +1,48 @@
+#![cfg(target_os = "linux")]
+#![allow(unsafe_code)]
+use frankenlibc_abi::stdlib_abi as fl;
+use std::ffi::{CStr, c_char, c_int};
+unsafe extern "C" {
+    fn ecvt(v: f64, n: c_int, dp: *mut c_int, sg: *mut c_int) -> *mut c_char;
+    fn fcvt(v: f64, n: c_int, dp: *mut c_int, sg: *mut c_int) -> *mut c_char;
+}
+fn tup(eng: u8, v: f64, n: c_int, fc: bool) -> (String, c_int, c_int) {
+    let mut dp: c_int = -999; let mut sg: c_int = -999;
+    let r = match (eng, fc) {
+        (0, false) => unsafe { fl::ecvt(v, n, &mut dp, &mut sg) },
+        (0, true) => unsafe { fl::fcvt(v, n, &mut dp, &mut sg) },
+        (_, false) => unsafe { ecvt(v, n, &mut dp, &mut sg) },
+        (_, true) => unsafe { fcvt(v, n, &mut dp, &mut sg) },
+    };
+    let s = if r.is_null() { "<null>".into() } else { unsafe { CStr::from_ptr(r) }.to_string_lossy().into_owned() };
+    (s, dp, sg)
+}
+#[test]
+fn ecvt_fcvt_rounding_parity() {
+    let vals: &[f64] = &[
+        1.0, 3.14159265358979, 9.999999999, 0.0001234567, 2.5, 0.5, 1.5, 0.15, 0.25, 0.35,
+        99.5, 100.5, 0.000099995, 123456.789, 9.9999999e10, 1e-10, 2.0/3.0, 1.0/3.0,
+        0.1, 0.2, 0.3, 99999.9999995, 0.99999999999999, 1000000.0, -3.14159, -0.5, -2.5,
+        12345.6785, 12345.6795, 0.00012345005, 5.0e-5, 9.95, 0.045, 2.675,
+    ];
+    let ndigits: &[c_int] = &[0, 1, 2, 3, 5, 6, 10, 15, 17, 20, -1, -5, 50];
+    let mut div = Vec::new();
+    for &fc in &[false, true] {
+        let name = if fc { "fcvt" } else { "ecvt" };
+        for &v in vals {
+            for &n in ndigits {
+                let f = tup(0, v, n, fc);
+                let g = tup(1, v, n, fc);
+                if f != g {
+                    div.push(format!("{name}({v:e}, n={n}): fl=({:?},dp {},sg {}) glibc=({:?},dp {},sg {})",
+                        f.0, f.1, f.2, g.0, g.1, g.2));
+                }
+            }
+        }
+    }
+    if !div.is_empty() {
+        eprintln!("ECVT/FCVT ROUNDING DIVERGENCES ({}):", div.len());
+        for d in div.iter().take(80) { eprintln!("  {d}"); }
+    }
+    assert!(div.is_empty(), "{} ecvt/fcvt rounding divergences", div.len());
+}

crates/frankenlibc-abi/tests/conformance_diff_printf_positional.rs

@@ -0,0 +1,42 @@
+#![cfg(target_os = "linux")]
+#![allow(unsafe_code)]
+use frankenlibc_abi::stdio_abi as fl;
+use std::ffi::{CString, c_char, c_int};
+unsafe extern "C" {
+    fn snprintf(b: *mut c_char, s: usize, f: *const c_char, ...) -> i32;
+}
+// render with 3 int args + 1 string arg available (callers pick via positional)
+fn r_iii(eng: u8, fmt: &CString, a: c_int, b: c_int, c: c_int) -> (String, i32) {
+    let mut buf = [0u8; 256];
+    let n = if eng == 0 { unsafe { fl::snprintf(buf.as_mut_ptr() as *mut c_char, 256, fmt.as_ptr(), a, b, c) } }
+            else { unsafe { snprintf(buf.as_mut_ptr() as *mut c_char, 256, fmt.as_ptr(), a, b, c) } };
+    (String::from_utf8_lossy(&buf[..n.max(0) as usize]).into_owned(), n)
+}
+#[test]
+fn printf_positional_star_parity() {
+    // positional + dynamic width/precision via '*'
+    let fmts = [
+        "%1$d", "%2$d %1$d", "%3$d-%1$d-%2$d", "%1$d %1$d %1$d",
+        "%*d", "%-*d|", "%.*d", "%*.*d", "%2$*1$d", "%3$*2$.*1$d",
+        "%1$*2$d", "%0*d", "%+*d", "%*.*x", "%2$5d|%1$-5d|",
+        "%1$d%%%2$d", "%*1$d",  // %*1$d is invalid-ish; check both agree
+        "[%1$3d][%2$03d][%3$+d]",
+    ];
+    let mut div = Vec::new();
+    let triples = [(5, 42, 7), (3, -1, 100), (0, 8, -250), (10, 2, 0)];
+    for fmt in fmts {
+        let cf = match CString::new(fmt) { Ok(c) => c, Err(_) => continue };
+        for (a, b, c) in triples {
+            let f = r_iii(0, &cf, a, b, c);
+            let g = r_iii(1, &cf, a, b, c);
+            if f != g {
+                div.push(format!("snprintf({fmt:?}, {a},{b},{c}): fl=({:?},ret {}) glibc=({:?},ret {})", f.0, f.1, g.0, g.1));
+            }
+        }
+    }
+    if !div.is_empty() {
+        eprintln!("PRINTF POSITIONAL/STAR DIVERGENCES ({}):", div.len());
+        for d in div.iter().take(80) { eprintln!("  {d}"); }
+    }
+    assert!(div.is_empty(), "{} printf positional/star divergences", div.len());
+}

crates/frankenlibc-abi/tests/conformance_diff_scanf_scanset.rs

@@ -0,0 +1,47 @@
+#![cfg(target_os = "linux")]
+#![allow(unsafe_code)]
+use frankenlibc_abi::stdio_abi as fl;
+use std::ffi::{CString, c_char, c_int};
+unsafe extern "C" {
+    fn sscanf(s: *const c_char, f: *const c_char, ...) -> c_int;
+}
+// scan one string field into a 64-byte buf; return (ret, captured-string)
+fn scan1(eng: u8, input: &CString, fmt: &CString) -> (c_int, String) {
+    let mut buf = [0u8; 64];
+    let r = if eng == 0 { unsafe { fl::sscanf(input.as_ptr(), fmt.as_ptr(), buf.as_mut_ptr() as *mut c_char) } }
+            else { unsafe { sscanf(input.as_ptr(), fmt.as_ptr(), buf.as_mut_ptr() as *mut c_char) } };
+    let s = buf.iter().position(|&b| b == 0).map(|n| String::from_utf8_lossy(&buf[..n]).into_owned()).unwrap_or_default();
+    (r, s)
+}
+#[test]
+fn scanf_scanset_parity() {
+    // (input, format) pairs exercising scanset edge cases
+    let cases: &[(&str, &str)] = &[
+        ("abc123", "%[a-c]"), ("abc123", "%[^0-9]"), ("abc123", "%[abc]"),
+        ("]abc", "%[]a]"), ("a]bc", "%[]a]"), ("^abc", "%[^]"),  // ] handling
+        ("abc", "%[^]abc"),  // unterminated set
+        ("a-c", "%[a-c]"), ("-abc", "%[-a]"), ("abc-", "%[a-]"),  // - at ends
+        ("HELLOworld", "%[A-Z]"), ("12.5e3", "%[0-9.eE+-]"),
+        ("aaabbb", "%3[a]"), ("   abc", "%[^ ]"), ("  abc", "%[ a-c]"),
+        ("xyz", "%[^xyz]"), ("", "%[a-z]"), ("ZZ", "%[A-Za-z]"),
+        ("a1b2c3", "%[a-c0-9]"), ("Hello, World!", "%[^,]"),
+        ("\t\nabc", "%[^a]"), ("ABCabc", "%[A-z]"),  // A-z spans punctuation
+        ("123abc456", "%[0-9]"), ("...", "%[.]"), ("a]]b", "%[]a]"),
+        ("ccba", "%[c-a]"),  // reversed range (glibc: only 'c'? or empty?)
+    ];
+    let mut div = Vec::new();
+    for (inp, fmt) in cases {
+        let ci = CString::new(*inp).unwrap();
+        let cf = CString::new(*fmt).unwrap();
+        let f = scan1(0, &ci, &cf);
+        let g = scan1(1, &ci, &cf);
+        if f != g {
+            div.push(format!("sscanf({inp:?}, {fmt:?}): fl=(ret {},{:?}) glibc=(ret {},{:?})", f.0, f.1, g.0, g.1));
+        }
+    }
+    if !div.is_empty() {
+        eprintln!("SCANF SCANSET DIVERGENCES ({}):", div.len());
+        for d in &div { eprintln!("  {d}"); }
+    }
+    assert!(div.is_empty(), "{} scanf scanset divergences", div.len());
+}