fix(printf): use shared SHELL_ESCAPE for %q format

Fix EscapedShellQuoter to match bash printf %q behavior.
Remove redundant PrintfQuoter implementation.
Both ls and printf now share same quoting logic.

Author: naoNao89

src/uucore/src/lib/features/format/spec.rs

@@ -13,7 +13,12 @@ use super::{
     },
     parse_escape_only,
 };
-use crate::{format::FormatArguments, os_str_as_bytes};
+use crate::{
+    format::FormatArguments,
+    i18n::UEncoding,
+    os_str_as_bytes,
+    quoting_style::{QuotingStyle, escape_name},
+};
 use std::{io::Write, num::NonZero, ops::ControlFlow};
 
 /// A parsed specification for formatting a value
@@ -399,7 +404,11 @@ impl Spec {
                 writer.write_all(&parsed).map_err(FormatError::IoError)
             }
             Self::QuotedString { position } => {
-                let s = crate::quoting_style::printf_quote(args.next_string(position));
+                let s = escape_name(
+                    args.next_string(position),
+                    QuotingStyle::SHELL_ESCAPE,
+                    UEncoding::Utf8,
+                );
                 let bytes = os_str_as_bytes(&s)?;
                 writer.write_all(bytes).map_err(FormatError::IoError)
             }

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

@@ -18,7 +18,6 @@ pub use escaped_char::{EscapeState, EscapedChar};
 
 mod c_quoter;
 mod literal_quoter;
-mod printf_quoter;
 mod shell_quoter;
 
 /// The quoting style to use when escaping a name.
@@ -229,18 +228,6 @@ pub fn locale_aware_escape_dir_name(name: &OsStr, style: QuotingStyle) -> OsStri
     escape_dir_name(name, style, i18n::get_locale_encoding())
 }
 
-/// Escape a string for printf %q format specifier (bash-compatible shell quoting).
-/// This uses a simpler algorithm than SHELL_ESCAPE:
-/// - Empty strings become ''
-/// - Simple alphanumeric strings are unchanged
-/// - Strings with shell metacharacters but no control chars use backslash escaping
-/// - Strings with control characters use $'...' ANSI-C quoting
-pub fn printf_quote(name: &OsStr) -> OsString {
-    let name = crate::os_str_as_bytes_lossy(name);
-    crate::os_string_from_vec(printf_quoter::PrintfQuoter::quote(&name))
-        .expect("all byte sequences should be valid for platform")
-}
-
 impl fmt::Display for QuotingStyle {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {

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

@@ -100,6 +100,9 @@ pub(super) struct EscapedShellQuoter<'a> {
     /// Whether the name should be quoted.
     must_quote: bool,
 
+    /// Whether we committed to dollar quoting for the entire string.
+    committed_dollar: bool,
+
     /// Whether we are currently in a dollar escaped environment.
     in_dollar: bool,
 
@@ -109,24 +112,35 @@ pub(super) struct EscapedShellQuoter<'a> {
 impl<'a> EscapedShellQuoter<'a> {
     pub fn new(reference: &'a [u8], always_quote: bool, dirname: bool, size_hint: usize) -> Self {
         let (quotes, must_quote) = initial_quoting(reference, dirname, always_quote);
+
+        // Pre-scan to check if we have any control characters
+        // If so, commit to $'...' quoting for the entire string
+        let has_control_chars = reference.iter().any(|&b| b.is_ascii_control());
+
+        let mut buffer = Vec::with_capacity(size_hint);
+        if has_control_chars {
+            buffer.extend(b"$'");
+        }
+
         Self {
             reference,
             quotes,
             must_quote,
-            in_dollar: false,
-            buffer: Vec::with_capacity(size_hint),
+            committed_dollar: has_control_chars,
+            in_dollar: has_control_chars,
+            buffer,
         }
     }
 
     fn enter_dollar(&mut self) {
-        if !self.in_dollar {
+        if !self.committed_dollar && !self.in_dollar {
             self.buffer.extend(b"'$'");
             self.in_dollar = true;
         }
     }
 
     fn exit_dollar(&mut self) {
-        if self.in_dollar {
+        if !self.committed_dollar && self.in_dollar {
             self.buffer.extend(b"''");
             self.in_dollar = false;
         }
@@ -137,22 +151,52 @@ impl Quoter for EscapedShellQuoter<'_> {
     fn push_char(&mut self, input: char) {
         let escaped = EscapedChar::new_shell(input, true, self.quotes);
         match escaped.state {
+            // Single quotes need escaping - check BEFORE general Char(x)
+            EscapeState::Backslash('\'') | EscapeState::Char('\'') => {
+                if self.committed_dollar {
+                    // In committed dollar mode, escape as \'
+                    self.must_quote = true;
+                    self.buffer.extend(b"\\'");
+                } else {
+                    // In backslash mode (no control chars), escape as \'
+                    self.exit_dollar();
+                    self.must_quote = true;
+                    self.buffer.push(b'\\');
+                    self.buffer.push(b'\'');
+                }
+            }
+            EscapeState::Backslash('\\') => {
+                if self.committed_dollar {
+                    // In committed dollar mode, escape as \\
+                    self.must_quote = true;
+                    self.buffer.extend(b"\\\\");
+                } else {
+                    self.enter_dollar();
+                    self.must_quote = true;
+                    self.buffer.extend(b"\\\\");
+                }
+            }
             EscapeState::Char(x) => {
-                self.exit_dollar();
-                self.buffer.extend(x.to_string().as_bytes());
+                if self.committed_dollar {
+                    // In committed dollar mode, regular chars are literal
+                    self.buffer.extend(x.to_string().as_bytes());
+                } else {
+                    self.exit_dollar();
+                    self.buffer.extend(x.to_string().as_bytes());
+                }
             }
             EscapeState::ForceQuote(x) => {
-                self.exit_dollar();
-                self.must_quote = true;
-                self.buffer.extend(x.to_string().as_bytes());
-            }
-            // Single quotes are not put in dollar expressions, but are escaped
-            // if the string also contains double quotes. In that case, they
-            // must be handled separately.
-            EscapeState::Backslash('\'') => {
-                self.exit_dollar();
-                self.must_quote = true;
-                self.buffer.extend(b"'\\''");
+                if self.committed_dollar {
+                    // In committed dollar mode, shell metacharacters are literal (no escaping needed)
+                    self.must_quote = true;
+                    self.buffer.extend(x.to_string().as_bytes());
+                } else {
+                    // Outside committed dollar mode, use backslash escaping
+                    self.exit_dollar();
+                    self.must_quote = true;
+                    self.buffer.push(b'\\');
+                    self.buffer.extend(x.to_string().as_bytes());
+                }
             }
             _ => {
                 self.enter_dollar();
@@ -179,8 +223,21 @@ impl Quoter for EscapedShellQuoter<'_> {
         );
     }
 
-    fn finalize(self: Box<Self>) -> Vec<u8> {
-        finalize_shell_quoter(self.buffer, self.reference, self.must_quote, self.quotes)
+    fn finalize(mut self: Box<Self>) -> Vec<u8> {
+        // Close the committed dollar quote if needed
+        if self.committed_dollar {
+            self.buffer.push(b'\'');
+            return self.buffer;
+        }
+
+        // Empty string special case - return ''
+        if self.reference.is_empty() {
+            return b"''".to_vec();
+        }
+
+        // For backslash escaping mode (no control chars), don't add outer quotes
+        // This matches bash printf %q behavior
+        self.buffer
     }
 }