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

Fixes CI failure from PR uutils#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,49 @@ 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;
+            if self.in_quote_section {
+                // Close any existing quote section first
+                self.buffer.push(b'\'');
+                self.in_quote_section = false;
+            } else if !self.commit_dollar {
+                // ls mode: handle buffer content before entering dollar mode
+                if self.buffer.is_empty() {
+                    // Empty buffer: add empty quotes to match GNU (e.g., ''$'\360\237\230\201')
+                    self.buffer.extend(b"''");
                 } 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;
+                    // Has content: wrap it in quotes
+                    let quote = if self.quotes == Quotes::Single {
+                        b'\''
+                    } else {
+                        b'"'
+                    };
+                    let mut quoted = Vec::with_capacity(self.buffer.len() + 2);
+                    quoted.push(quote);
+                    quoted.extend_from_slice(&self.buffer);
+                    quoted.push(quote);
+                    self.buffer = quoted;
                 }
-                self.buffer.extend(b"$'");
             }
+            self.buffer.extend(b"$'");
             self.in_dollar = true;
         }
     }
@@ -196,18 +190,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"\\'");
                     }
@@ -237,7 +233,8 @@ impl Quoter for EscapedShellQuoter<'_> {
             EscapeState::Char(x) => {
                 if self.in_dollar {
                     if self.commit_dollar {
-                        // In committed dollar mode (printf), regular chars are literal
+                        // In committed dollar mode (printf), exit and write regular char as-is
+                        self.exit_dollar();
                         self.buffer.extend(x.to_string().as_bytes());
                     } else {
                         // In selective dollar mode (ls), exit dollar and start new quoted section
@@ -253,7 +250,7 @@ impl Quoter for EscapedShellQuoter<'_> {
                     }
                 } else {
                     // Not in dollar mode - just add the character
-                    // Outer quoting will be handled in finalize if needed
+                    // Quoting will be handled by enter_dollar (when control chars appear) or finalize
                     self.buffer.extend(x.to_string().as_bytes());
                 }
             }
@@ -286,6 +283,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]