fix(printf): implement selective dollar-quoting for %q format

Fixes CI failure from PR #9640 where GNU test suite update (commit ba3442f4f)
exposed fundamental design flaws in printf %q shell-quoting implementation.

Problem:
Original code pre-scanned for control characters and wrapped ENTIRE strings
in $'...' if ANY control char was present (e.g., "a\r" → $'a\r').

Solution:
Implemented selective quoting that only wraps control characters themselves
(e.g., "a\r" → a$'\r'), matching GNU coreutils behavior.

Key Changes:
- Removed has_control_chars() pre-scanning logic
- Never start in dollar mode - enter/exit dynamically
- Exit dollar mode when encountering regular chars (selective quoting)
- Keep consecutive control chars in single dollar quote
- Handle apostrophes by exiting dollar mode and using \' escape
- Updated test expectations to match selective quoting behavior

Examples:
- 'a\tb' → a$'\t'b (not $'a\tb')
- '\x01\x02\x03' → $'\001\002\003' (not $'\001'$'\002'$'\003')
- 'hello\x01world' → hello$'\001'world (not $'hello\001world')

Author: naoNao89

src/uucore/src/lib/features/quoting_style/shell_quoter.rs

@@ -126,55 +126,33 @@ impl<'a> EscapedShellQuoter<'a> {
         let (quotes, must_quote) = initial_quoting(reference, dirname, always_quote);
 
         // commit_dollar_mode controls quoting strategy:
-        // true (printf %q): committed dollar mode - wrap entire string in $'...' when control chars present
-        // false (ls): selective dollar mode - only wrap individual control chars in $'...'
+        // true (printf %q): use selective dollar-quoting (same as ls)
+        // false (ls): use selective dollar-quoting
+        // Both modes use selective quoting: enter $'...' only for control chars
         let commit_dollar = commit_dollar_mode;
 
-        // Pre-scan for control chars or non-ASCII if we're in committed mode
-        let has_control_chars = commit_dollar
-            && reference
-                .iter()
-                .any(|&b| b.is_ascii_control() || !b.is_ascii());
-
-        let mut buffer = Vec::with_capacity(size_hint);
-        if has_control_chars {
-            buffer.extend(b"$'");
-        }
-
         Self {
             reference,
             quotes,
             always_quote,
             commit_dollar,
             must_quote,
-            in_dollar: has_control_chars,
+            in_dollar: false, // Never start in dollar mode - enter it dynamically
             in_quote_section: false,
-            buffer,
+            buffer: Vec::with_capacity(size_hint),
         }
     }
 
     fn enter_dollar(&mut self) {
         if !self.in_dollar {
-            if self.buffer.is_empty() {
-                // Starting with dollar quote - prepend empty quotes to indicate no prefix
-                // GNU coreutils does this for strings that start with only invalid bytes
-                self.buffer.extend(b"''$'");
-            } else {
-                // Had previous content
-                if self.in_quote_section {
-                    // Close the existing quote section
-                    self.buffer.push(b'\'');
-                    self.in_quote_section = false;
-                } else {
-                    // We have unquoted content - need to quote it first
-                    let mut temp = Vec::with_capacity(self.buffer.len() + 2);
-                    temp.push(b'\'');
-                    temp.extend(&self.buffer);
-                    temp.push(b'\'');
-                    self.buffer = temp;
-                }
-                self.buffer.extend(b"$'");
+            // In printf %q mode (commit_dollar), regular text doesn't need wrapping
+            // Just append $' directly - only control chars go inside $'...'
+            if self.in_quote_section {
+                // Close any existing quote section first
+                self.buffer.push(b'\'');
+                self.in_quote_section = false;
             }
+            self.buffer.extend(b"$'");
             self.in_dollar = true;
         }
     }
@@ -196,18 +174,20 @@ impl Quoter for EscapedShellQuoter<'_> {
             // Single quotes need escaping - check BEFORE general Char(x)
             EscapeState::Backslash('\'') | EscapeState::Char('\'') => {
                 if self.in_dollar {
-                    // Inside an existing $'...' section, escape as \'
+                    // Inside $'...' section - need to exit, then handle apostrophe
+                    self.exit_dollar();
                     self.must_quote = true;
+                    // Backslash-escape the apostrophe
                     self.buffer.extend(b"\\'");
                 } else if self.commit_dollar {
-                    // printf %q mode (commit_dollar), not in dollar section:
-                    // Check if this is a standalone single quote (buffer still empty = first char)
+                    // printf %q mode, not in dollar section
+                    // Check if this is a standalone single quote
                     if self.buffer.is_empty() && self.reference.len() == 1 {
                         // Standalone single quote uses double quotes: "'"
                         self.must_quote = true;
                         self.buffer.extend(b"\"'\"");
                     } else {
-                        // Embedded quote (like in "it's") - backslash escape
+                        // Embedded quote - backslash escape
                         self.must_quote = true;
                         self.buffer.extend(b"\\'");
                     }
@@ -236,8 +216,10 @@ impl Quoter for EscapedShellQuoter<'_> {
             }
             EscapeState::Char(x) => {
                 if self.in_dollar {
+                    // Exit dollar mode before writing regular char (selective quoting)
+                    self.exit_dollar();
                     if self.commit_dollar {
-                        // In committed dollar mode (printf), regular chars are literal
+                        // In committed dollar mode (printf), regular chars don't need quoting
                         self.buffer.extend(x.to_string().as_bytes());
                     } else {
                         // In selective dollar mode (ls), exit dollar and start new quoted section
@@ -286,6 +268,7 @@ impl Quoter for EscapedShellQuoter<'_> {
                 self.enter_dollar();
                 self.must_quote = true;
                 self.buffer.extend(escaped.collect::<String>().as_bytes());
+                // Don't exit - let regular chars exit when needed for selective quoting
             }
         }
     }

tests/by-util/test_printf.rs

@@ -186,10 +186,11 @@ fn sub_q_control_chars_basic() {
 #[test]
 fn sub_q_control_chars_with_apostrophe() {
     // Bug #9638: control char + apostrophe + control char
+    // GNU outputs: $'\001'\'$'\001'
     new_ucmd!()
         .args(&["%q\n", "\x01'\x01"])
         .succeeds()
-        .stdout_only("$'\\001\\'\\001'\n");
+        .stdout_only("$'\\001'\\'$'\\001'\n");
 }
 
 #[test]
@@ -257,31 +258,31 @@ fn sub_q_newline() {
     new_ucmd!()
         .args(&["%q\n", "a\nb"])
         .succeeds()
-        .stdout_only("$'a\\nb'\n");
+        .stdout_only("a$'\\n'b\n");
 }
 
 #[test]
 fn sub_q_tab() {
     new_ucmd!()
         .args(&["%q\n", "a\tb"])
         .succeeds()
-        .stdout_only("$'a\\tb'\n");
+        .stdout_only("a$'\\t'b\n");
 }
 
 #[test]
 fn sub_q_mixed_control_and_text() {
     new_ucmd!()
         .args(&["%q\n", "hello\x01world"])
         .succeeds()
-        .stdout_only("$'hello\\001world'\n");
+        .stdout_only("hello$'\\001'world\n");
 }
 
 #[test]
 fn sub_q_apostrophe_in_dollar_quote() {
     new_ucmd!()
         .args(&["%q\n", "it's\na\nthing"])
         .succeeds()
-        .stdout_only("$'it\\'s\\na\\nthing'\n");
+        .stdout_only("it\\'s$'\\n'a$'\\n'thing\n");
 }
 
 #[test]
@@ -329,7 +330,7 @@ fn sub_q_mixed_escapes() {
     new_ucmd!()
         .args(&["%q\n", "a b\nc"])
         .succeeds()
-        .stdout_only("$'a b\\nc'\n");
+        .stdout_only("a\\ b$'\\n'c\n");
 }
 
 #[test]