infocmp -C: apply terminfo islong caret/octal heuristic to termcap control bytes

Derived from the oracle (clean-room): termcap control-byte rendering follows the
same "long value" test as terminfo -- caret form ^X for short values (or when the
next byte is a digit), octal \nnn once the non-control weight exceeds 3 (or >10
caret-eligible controls). Across 400 sampled terminals this predicts 332/350 octal
cases, the apparent low-weight exceptions all being the NUL->\0 special case.

Extracted the weight/islong computation from tic_expand into a shared
noncontrol_islong() helper and threaded islong + next-byte context through
tc_escape_byte / try_translate / tc_xlat.

Termcap (-C) content match 27.7% -> 31.6%, exact 20.5% (was 18.1%). terminfo -1
remains 100%; unit tests green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CbiPgWC3PHKmrTNvZzXcWQ

Author: claude

crates/ncurses-tools/src/bin/infocmp.rs

@@ -59,29 +59,12 @@ fn is_caret_control(b: u8) -> bool {
     matches!(b, 0x01..=0x1f if !matches!(b, b'\n' | b'\r' | 0x1b)) || b == 0x7f
 }
 
-/// ncurses terminfo string escaping (the inverse of `tic`), reproducing `_nc_tic_expand`'s
-/// byte-exact output as verified against real `tic`/`infocmp` across the whole terminfo DB:
-///   * `\E` (ESC), `\n` (0x0a), `\r` (0x0d) -- always letter-escaped, regardless of context;
-///   * byte 0x80 -> `\0`; other high bytes (0x81..=0xff) -> 3-digit octal `\nnn`;
-///   * `\s` for a space that is the first byte OR part of the trailing all-space run
-///     (interior spaces stay literal);
-///   * `\,` and `\^` for comma/caret; backslash is doubled (`\\`) unless the previous source
-///     byte is `^`, in which case it stays a single `\`;
-///   * a `%` immediately followed by a printable byte takes that byte verbatim (so terminfo
-///     operators like `%^`, `%:`, `%\` survive un-escaped), the lone exception being a comma,
-///     which is always protected as `\,`;
-///   * caret-eligible control bytes (see [`is_caret_control`]) use caret form `^X`
-///     (`X = ch ^ 0x40`) when the value is "short" -- the summed escaped width of all *other*
-///     bytes is <= 3 -- or (for `0x01..=0x1f`) when the next byte is an ASCII digit; otherwise
-///     octal `\nnn`;
-///   * all remaining printables (incl. `:`, `!`, `%`) are emitted literally.
-fn tic_expand(v: &[u8]) -> String {
-    let mut s = String::new();
-    // ncurses' "long value" test drives the caret-vs-octal choice for control bytes: sum the
-    // escaped width of every *non*-caret-control byte (control bytes themselves count as zero);
-    // once that exceeds 3, control bytes render as octal rather than caret. The walk mirrors the
-    // emission below so that a `%`-operator's verbatim byte is weighted as it actually renders
-    // (e.g. `%^` is two columns, not the three a standalone `\^` would cost).
+/// ncurses' "long value" test, driving the caret-vs-octal choice for control bytes: sum the escaped
+/// width of every *non*-caret-control byte (control bytes themselves count as zero); once that
+/// exceeds 3 -- or more than ten caret-eligible control bytes appear -- control bytes render as octal
+/// rather than caret. The walk mirrors the emission so that a `%`-operator's verbatim byte is
+/// weighted as it actually renders (e.g. `%^` is two columns, not the three a standalone `\^` costs).
+fn noncontrol_islong(v: &[u8]) -> bool {
     let noncontrol_weight: usize = {
         let width = |b: u8| -> usize {
             match b {
@@ -111,10 +94,29 @@ fn tic_expand(v: &[u8]) -> String {
         }
         w
     };
-    // A value packed with caret-eligible control bytes also tips "long": more than ten of them
-    // forces octal even when there is no other content to lengthen the estimate.
     let caret_control_count = v.iter().filter(|&&b| is_caret_control(b)).count();
-    let islong = noncontrol_weight > 3 || caret_control_count > 10;
+    noncontrol_weight > 3 || caret_control_count > 10
+}
+
+/// ncurses terminfo string escaping (the inverse of `tic`), reproducing `_nc_tic_expand`'s
+/// byte-exact output as verified against real `tic`/`infocmp` across the whole terminfo DB:
+///   * `\E` (ESC), `\n` (0x0a), `\r` (0x0d) -- always letter-escaped, regardless of context;
+///   * byte 0x80 -> `\0`; other high bytes (0x81..=0xff) -> 3-digit octal `\nnn`;
+///   * `\s` for a space that is the first byte OR part of the trailing all-space run
+///     (interior spaces stay literal);
+///   * `\,` and `\^` for comma/caret; backslash is doubled (`\\`) unless the previous source
+///     byte is `^`, in which case it stays a single `\`;
+///   * a `%` immediately followed by a printable byte takes that byte verbatim (so terminfo
+///     operators like `%^`, `%:`, `%\` survive un-escaped), the lone exception being a comma,
+///     which is always protected as `\,`;
+///   * caret-eligible control bytes (see [`is_caret_control`]) use caret form `^X`
+///     (`X = ch ^ 0x40`) when the value is "short" -- the summed escaped width of all *other*
+///     bytes is <= 3 -- or (for `0x01..=0x1f`) when the next byte is an ASCII digit; otherwise
+///     octal `\nnn`;
+///   * all remaining printables (incl. `:`, `!`, `%`) are emitted literally.
+fn tic_expand(v: &[u8]) -> String {
+    let mut s = String::new();
+    let islong = noncontrol_islong(v);
 
     let mut i = 0;
     while i < v.len() {
@@ -211,7 +213,7 @@ fn termcap_code(name: &str, names: &[&str], codes: &[&str]) -> Option<String> {
 
 /// Escape one byte for a termcap value: like terminfo but `:` (the field separator) becomes `\072`,
 /// and 0x7f is octal `\177` rather than caret.
-fn tc_escape_byte(out: &mut String, b: u8) {
+fn tc_escape_byte(out: &mut String, b: u8, islong: bool, next: Option<u8>) {
     match b {
         0x1b => out.push_str("\\E"),
         b'\n' => out.push_str("\\n"),
@@ -220,9 +222,17 @@ fn tc_escape_byte(out: &mut String, b: u8) {
         0x80 => out.push_str("\\0"),
         0x7f => out.push_str("\\177"),
         b'\\' => out.push_str("\\\\"),
+        // Control bytes follow the same caret-vs-octal "long value" heuristic as terminfo: caret
+        // form `^X` for short values (or when the next byte is a digit, to avoid octal ambiguity),
+        // octal `\nnn` once the value is long.
         0x00..=0x1f => {
-            out.push('^');
-            out.push((b ^ 0x40) as char);
+            let next_is_digit = next.is_some_and(|n| n.is_ascii_digit());
+            if !islong || next_is_digit {
+                out.push('^');
+                out.push((b ^ 0x40) as char);
+            } else {
+                out.push_str(&format!("\\{b:03o}"));
+            }
         }
         0x81..=0xff => out.push_str(&format!("\\{b:03o}")),
         _ => out.push(b as char),
@@ -267,7 +277,7 @@ fn extract_padding(v: &[u8]) -> (Vec<u8>, String) {
 /// `%2d`->`%2`, `%03d`->`%3`, `%c`->`%.`, `%i`, `%%`, `%'X'%+%c`->`%+X`, reversed args -> leading
 /// `%r`). Returns `None` if any operator has no termcap equivalent (stack ops, `%?`/`%t`/`%e`/`%;`,
 /// `%{`, `%x`, ...), in which case the caller keeps the value verbatim, exactly as ncurses does.
-fn try_translate(v: &[u8]) -> Option<String> {
+fn try_translate(v: &[u8], islong: bool) -> Option<String> {
     // Decide whether the two parameters are used in reverse order (`%p2` before `%p1`).
     let mut order: Vec<u8> = Vec::new();
     let mut i = 0;
@@ -295,7 +305,7 @@ fn try_translate(v: &[u8]) -> Option<String> {
     let mut i = 0;
     while i < v.len() {
         if v[i] != b'%' {
-            tc_escape_byte(&mut out, v[i]);
+            tc_escape_byte(&mut out, v[i], islong, v.get(i + 1).copied());
             i += 1;
             continue;
         }
@@ -357,7 +367,7 @@ fn try_translate(v: &[u8]) -> Option<String> {
                     r_pending = false;
                 }
                 out.push_str("%+");
-                tc_escape_byte(&mut out, v[i + 2]);
+                tc_escape_byte(&mut out, v[i + 2], islong, v.get(i + 3).copied());
                 i += 8;
             }
             _ => return None,
@@ -372,10 +382,11 @@ fn try_translate(v: &[u8]) -> Option<String> {
 /// `_nc_infotocap`, which keeps untranslatable caps rather than dropping them.
 fn tc_xlat(raw: &[u8]) -> String {
     let (v, delay) = extract_padding(raw);
-    let body = try_translate(&v).unwrap_or_else(|| {
+    let islong = noncontrol_islong(&v);
+    let body = try_translate(&v, islong).unwrap_or_else(|| {
         let mut s = String::new();
-        for &b in &v {
-            tc_escape_byte(&mut s, b);
+        for i in 0..v.len() {
+            tc_escape_byte(&mut s, v[i], islong, v.get(i + 1).copied());
         }
         s
     });