extract Base enum

src/uu/echo/src/echo.rs

@@ -21,8 +21,24 @@ mod options {
  pub const DISABLE_BACKSLASH_ESCAPE: &str = "disable_backslash_escape";
 }
 
+#[repr(u8)]
+#[derive(Clone, Copy)]
+enum Base {
+ Oct = 8,
+ Hex = 16,
+}
+
+impl Base {
+ fn max_digits(&self) -> u8 {
+ match self {
+ Self::Oct => 3,
+ Self::Hex => 2,
+ }
+ }
+}
+
 /// Parse the numeric part of the `\xHHH` and `\0NNN` escape sequences
-fn parse_code(input: &mut Peekable<Chars>, base: u8, max_digits: u32) -> Option<char> {
+fn parse_code(input: &mut Peekable<Chars>, base: Base) -> Option<char> {
  // All arithmetic on `ret` needs to be wrapping, because octal input can
  // take 3 digits, which is 9 bits, and therefore more than what fits in a
  // `u8`. GNU just seems to wrap these values.
@@ -31,15 +47,15 @@ fn parse_code(input: &mut Peekable<Chars>, base: u8, max_digits: u32) -> Option<
  // `u8::MAX` as unicode.
  let mut ret = input.peek().and_then(|c| c.to_digit(base as u32))? as u8;
 
- // We can safely ifgnore the None case because we just peeked it.
+ // We can safely ignore the None case because we just peeked it.
  let _ = input.next();
 
- for _ in 1..max_digits {
+ for _ in 1..base.max_digits() {
  match input.peek().and_then(|c| c.to_digit(base as u32)) {
- Some(n) => ret = ret.wrapping_mul(base).wrapping_add(n as u8),
+ Some(n) => ret = ret.wrapping_mul(base as u8).wrapping_add(n as u8),
  None => break,
  }
- // We can safely ifgnore the None case because we just peeked it.
+ // We can safely ignore the None case because we just peeked it.
  let _ = input.next();
  }
 
@@ -58,7 +74,7 @@ fn print_escaped(input: &str, mut output: impl Write) -> io::Result<bool> {
  // Note that '0' is intentionally omitted because that
  // would be the \0NNN syntax.
  if let Some('1'..='8') = iter.peek() {
- if let Some(parsed) = parse_code(&mut iter, 8, 3) {
+ if let Some(parsed) = parse_code(&mut iter, Base::Oct) {
  write!(output, "{parsed}")?;
  continue;
  }
@@ -77,14 +93,14 @@ fn print_escaped(input: &str, mut output: impl Write) -> io::Result<bool> {
  't' => '\t',
  'v' => '\x0b',
  'x' => {
- if let Some(c) = parse_code(&mut iter, 16, 2) {
+ if let Some(c) = parse_code(&mut iter, Base::Hex) {
  c
  } else {
  write!(output, "\\")?;
  'x'
  }
  }
- '0' => parse_code(&mut iter, 8, 3).unwrap_or('\0'),
+ '0' => parse_code(&mut iter, Base::Oct).unwrap_or('\0'),
  c => {
  write!(output, "\\")?;
  c

tests/by-util/test_echo.rs

@@ -270,9 +270,9 @@ fn old_octal_syntax() {
 
  new_ucmd!()
  .arg("-e")
- .arg("\\101foo")
+ .arg("\\101 foo")
  .succeeds()
- .stdout_is("Afoo\n");
+ .stdout_is("A foo\n");
 
  new_ucmd!()
  .arg("-e")