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,14 @@ impl Spec {
                 writer.write_all(&parsed).map_err(FormatError::IoError)
             }
             Self::QuotedString { position } => {
-                let s = crate::quoting_style::printf_quote(args.next_string(position));
+                // printf %q uses committed dollar mode (entire string in $'...' when control chars present)
+                let printf_style = QuotingStyle::Shell {
+                    escape: true,
+                    always_quote: false,
+                    show_control: false,
+                    commit_dollar_mode: true, // printf %q style
+                };
+                let s = escape_name(args.next_string(position), printf_style, UEncoding::Utf8);
                 let bytes = os_str_as_bytes(&s)?;
                 writer.write_all(bytes).map_err(FormatError::IoError)
             }

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

@@ -26,19 +26,19 @@ pub enum EscapeState {
 }
 
 /// Bytes we need to present as escaped octal, in the form of `\nnn` per byte.
-/// Only supports characters up to 2 bytes long in UTF-8.
+/// Supports characters up to 4 bytes long in UTF-8.
 pub struct EscapeOctal {
-    c: [u8; 2],
+    bytes: [u8; 4],
+    num_bytes: usize,
+    byte_idx: usize,
+    digit_idx: u8,
     state: EscapeOctalState,
-    idx: u8,
 }
 
 enum EscapeOctalState {
     Done,
-    FirstBackslash,
-    FirstValue,
-    LastBackslash,
-    LastValue,
+    Backslash,
+    Value,
 }
 
 fn byte_to_octal_digit(byte: u8, idx: u8) -> u8 {
@@ -51,30 +51,23 @@ impl Iterator for EscapeOctal {
     fn next(&mut self) -> Option<char> {
         match self.state {
             EscapeOctalState::Done => None,
-            EscapeOctalState::FirstBackslash => {
-                self.state = EscapeOctalState::FirstValue;
+            EscapeOctalState::Backslash => {
+                self.state = EscapeOctalState::Value;
                 Some('\\')
             }
-            EscapeOctalState::LastBackslash => {
-                self.state = EscapeOctalState::LastValue;
-                Some('\\')
-            }
-            EscapeOctalState::FirstValue => {
-                let octal_digit = byte_to_octal_digit(self.c[0], self.idx);
-                if self.idx == 0 {
-                    self.state = EscapeOctalState::LastBackslash;
-                    self.idx = 2;
-                } else {
-                    self.idx -= 1;
-                }
-                Some(from_digit(octal_digit.into(), 8).unwrap())
-            }
-            EscapeOctalState::LastValue => {
-                let octal_digit = byte_to_octal_digit(self.c[1], self.idx);
-                if self.idx == 0 {
-                    self.state = EscapeOctalState::Done;
+            EscapeOctalState::Value => {
+                let octal_digit = byte_to_octal_digit(self.bytes[self.byte_idx], self.digit_idx);
+                if self.digit_idx == 0 {
+                    // Move to next byte
+                    self.byte_idx += 1;
+                    if self.byte_idx >= self.num_bytes {
+                        self.state = EscapeOctalState::Done;
+                    } else {
+                        self.state = EscapeOctalState::Backslash;
+                        self.digit_idx = 2;
+                    }
                 } else {
-                    self.idx -= 1;
+                    self.digit_idx -= 1;
                 }
                 Some(from_digit(octal_digit.into(), 8).unwrap())
             }
@@ -88,20 +81,24 @@ impl EscapeOctal {
             return Self::from_byte(c as u8);
         }
 
-        let mut buf = [0; 2];
-        let _s = c.encode_utf8(&mut buf);
+        let mut bytes = [0; 4];
+        let len = c.encode_utf8(&mut bytes).len();
         Self {
-            c: buf,
-            idx: 2,
-            state: EscapeOctalState::FirstBackslash,
+            bytes,
+            num_bytes: len,
+            byte_idx: 0,
+            digit_idx: 2,
+            state: EscapeOctalState::Backslash,
         }
     }
 
     fn from_byte(b: u8) -> Self {
         Self {
-            c: [0, b],
-            idx: 2,
-            state: EscapeOctalState::LastBackslash,
+            bytes: [b, 0, 0, 0],
+            num_bytes: 1,
+            byte_idx: 0,
+            digit_idx: 2,
+            state: EscapeOctalState::Backslash,
         }
     }
 }

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.
@@ -36,6 +35,11 @@ pub enum QuotingStyle {
 
         /// Whether to show control and non-unicode characters, or replace them with `?`.
         show_control: bool,
+
+        /// Whether to commit to dollar quoting for the entire string (printf %q style).
+        /// true: committed mode - wrap entire string in $'...' when control chars present
+        /// false: selective mode (ls style) - only wrap individual control chars in $'...'
+        commit_dollar_mode: bool,
     },
 
     /// Escape the name as a C string.
@@ -59,24 +63,28 @@ impl QuotingStyle {
         escape: false,
         always_quote: false,
         show_control: false,
+        commit_dollar_mode: false, // ls style - selective dollar mode
     };
 
     pub const SHELL_ESCAPE: Self = Self::Shell {
         escape: true,
         always_quote: false,
         show_control: false,
+        commit_dollar_mode: false, // ls style - selective dollar mode
     };
 
     pub const SHELL_QUOTE: Self = Self::Shell {
         escape: false,
         always_quote: true,
         show_control: false,
+        commit_dollar_mode: false, // ls style - selective dollar mode
     };
 
     pub const SHELL_ESCAPE_QUOTE: Self = Self::Shell {
         escape: true,
         always_quote: true,
         show_control: false,
+        commit_dollar_mode: false, // ls style - selective dollar mode
     };
 
     pub const C_NO_QUOTES: Self = Self::C {
@@ -95,11 +103,13 @@ impl QuotingStyle {
             Shell {
                 escape,
                 always_quote,
+                commit_dollar_mode,
                 ..
             } => Shell {
                 escape,
                 always_quote,
                 show_control,
+                commit_dollar_mode,
             },
             Literal { .. } => Literal { show_control },
             C { .. } => self,
@@ -162,17 +172,20 @@ fn escape_name_inner(
         QuotingStyle::Shell {
             escape: true,
             always_quote,
+            commit_dollar_mode,
             ..
         } => Box::new(EscapedShellQuoter::new(
             name,
             always_quote,
             dirname,
+            commit_dollar_mode,
             name.len(),
         )),
         QuotingStyle::Shell {
             escape: false,
             always_quote,
             show_control,
+            ..
         } => Box::new(NonEscapedShellQuoter::new(
             name,
             show_control,
@@ -229,25 +242,14 @@ 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 {
             Self::Shell {
                 escape,
                 always_quote,
                 show_control,
+                ..
             } => {
                 let mut style = "shell".to_string();
                 if escape {