Merge pull request #23 from rodrimati1992/char_support

Added char support, 0.2.19 release

Author: rodrimati1992

.github/workflows/rust.yml

@@ -12,7 +12,7 @@ jobs:
     strategy:
       max-parallel: 2
       matrix:
-        rust: [stable, beta, nightly, 1.46.0]
+        rust: [stable, beta, nightly, 1.46.0, 1.51.0]
 
     steps:
     - uses: actions/checkout@v2
@@ -29,10 +29,10 @@ jobs:
 
     - uses: actions/checkout@v2
     - name: ci-stable
-      # apparently github hadn't updated stable by 2021-03-27?
-      if: ${{ matrix.rust == 'beta' }}
+      if: ${{ matrix.rust == '1.51.0' }}
       run: |
         cargo update
+
         cd "${{github.workspace}}/const_format/"
         cargo test --features "testing const_generics"
 
@@ -69,10 +69,5 @@ jobs:
 
         cargo clean 
 
-        cargo miri test --features "testing"
-        cargo miri test --features "testing fmt"
-        cargo miri test --features "testing assert"
-        cargo miri test --features "testing derive"
-        cargo miri test --features "testing constant_time_as_str"
-        cargo miri test --features "testing derive constant_time_as_str"
-        cargo miri test --features "testing derive constant_time_as_str assert"
+        cargo miri test --tests --features "testing derive fmt assert"
+        cargo miri test --features "testing derive fmt constant_time_as_str assert"

Changelog.md

@@ -2,6 +2,22 @@ This is the changelog,summarising changes in each version(some minor changes may
 
 # 0.2 
 
+### 0.2.19
+
+Added `char` support to all formatting macros.
+
+Added `char`, `&[char]`, and `Option<char>` impls of FormatMarker trait, with debug formatting methods.
+
+Added `Formatter::{write_char, write_char_debug}` methods.
+
+Added `StrWriterMut::{as_str_alt, write_char, write_char_debug}` methods.
+
+Added `StrWriter::{as_str_alt, unsize}` methods.
+
+Deprecated `strwriter_as_str` macro, superceded by `StrWriter::as_str_alt`.
+
+Bumped the minimum required nightly version to 2021-07-05 due to use of const-stabilized `core::str::from_utf8_unchecked`.
+
 ### 0.2.18
 
 Fixed potential soundness bug where unions used to do pointer casts were not `#[repr(C)]`

README.md

@@ -21,10 +21,10 @@ the sections below describe the features that are available for each version.
 These macros are the only things available in Rust 1.46.0:
 
 - [`concatcp`]:
-Concatenates `integers`, `bool`, and `&str` constants into a `&'static str` constant.
+Concatenates `integers`, `bool`, `char`, and `&str` constants into a `&'static str` constant.
 
 - [`formatcp`]:
-[`format`]-like formatting which takes `integers`, `bool`, and `&str` constants,
+[`format`]-like formatting which takes `integers`, `bool`, `char`, and `&str` constants,
 and emits a `&'static str` constant.
 
 - [`str_get`]: 
@@ -37,7 +37,7 @@ Indexes a `&'static str` constant.
 Creates a `&'static str` by repeating a `&'static str` constant `times` times.
 
 - [`str_splice`]: 
-Replaces a substring in a &'static str constant.
+Replaces a substring in a `&'static str` constant.
 
 ### Rust 1.51.0
 
@@ -160,7 +160,7 @@ panicking at compile-time requires a nightly feature.
 ```rust
 #![feature(const_mut_refs)]
 
-use const_format::{StrWriter, assertc_ne, strwriter_as_str, writec};
+use const_format::{StrWriter, assertc_ne, writec};
 use const_format::utils::str_eq;
 
 macro_rules! check_valid_pizza{
@@ -286,9 +286,7 @@ provides the [`ConstDebug`] derive macro to format user-defined types at compile
 This implicitly uses the `syn` crate, so clean compiles take a bit longer than without the feature.
 
 - "assert": implies the "fmt" feature,
-enables the assertion macros.<br>
-This is a separate cargo feature because 
-it uses nightly Rust features that are less stable than the "fmt" feature does.
+enables the assertion macros.
 
 - "constant_time_as_str": implies the "fmt" feature.
 An optimization that requires a few additional nightly features,

const_format/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "const_format"
-version = "0.2.18"
+version = "0.2.19"
 authors = ["rodrimati1992 <[email protected]>"]
 edition = "2018"
 license = "Zlib"

const_format/src/__str_methods.rs

@@ -2,7 +2,7 @@
 mod str_replace;
 
 #[cfg(feature = "const_generics")]
-pub use self::str_replace::{str_replace, str_replace_length, ReplaceInput, ReplaceInputConv};
+pub use self::str_replace::{ReplaceInput, ReplaceInputConv};
 
 mod str_repeat;
 pub use str_repeat::StrRepeatArgs;

const_format/src/__str_methods/str_replace.rs

@@ -1,38 +1,62 @@
 use super::{bytes_find, AsciiByte};
 
-pub struct ReplaceInputConv<T>(pub T);
+pub struct ReplaceInputConv<T>(pub &'static str, pub T, pub &'static str);
 
 impl ReplaceInputConv<u8> {
     pub const fn conv(self) -> ReplaceInput {
-        ReplaceInput::AsciiByte(AsciiByte::new(self.0))
+        ReplaceInput {
+            str: self.0,
+            pattern: ReplacePattern::AsciiByte(AsciiByte::new(self.1)),
+            replaced_with: self.2,
+        }
     }
 }
 
 impl ReplaceInputConv<&'static str> {
     pub const fn conv(self) -> ReplaceInput {
-        ReplaceInput::Str(self.0)
+        ReplaceInput {
+            str: self.0,
+            pattern: ReplacePattern::Str(self.1),
+            replaced_with: self.2,
+        }
     }
 }
 
-pub enum ReplaceInput {
+pub struct ReplaceInput {
+    str: &'static str,
+    pattern: ReplacePattern,
+    replaced_with: &'static str,
+}
+
+#[derive(Copy, Clone)]
+pub enum ReplacePattern {
     AsciiByte(AsciiByte),
     Str(&'static str),
 }
 
-pub const fn str_replace_length(inp: &str, r: ReplaceInput, replaced_with: &str) -> usize {
+impl ReplaceInput {
+    pub const fn replace_length(&self) -> usize {
+        str_replace_length(self.str, self.pattern, self.replaced_with)
+    }
+    pub const fn replace<const L: usize>(&self) -> [u8; L] {
+        str_replace(self.str, self.pattern, self.replaced_with)
+    }
+}
+
+const fn str_replace_length(inp: &str, r: ReplacePattern, replaced_with: &str) -> usize {
     let inp = inp.as_bytes();
 
     let replaced_len = replaced_with.len();
     let mut out_len = 0;
 
     match r {
-        ReplaceInput::AsciiByte(byte) => {
+        ReplacePattern::AsciiByte(byte) => {
             let byte = byte.get();
             iter_copy_slice! {b in inp =>
                 out_len += if b == byte { replaced_len } else { 1 };
             }
         }
-        ReplaceInput::Str(str) => {
+        ReplacePattern::Str(str) => {
             if str.is_empty() {
                 return inp.len();
             }
@@ -50,11 +74,7 @@ pub const fn str_replace_length(inp: &str, r: ReplaceInput, replaced_with: &str)
     out_len
 }
 
-pub const fn str_replace<const L: usize>(
-    inp: &str,
-    r: ReplaceInput,
-    replaced_with: &str,
-) -> [u8; L] {
+const fn str_replace<const L: usize>(inp: &str, r: ReplacePattern, replaced_with: &str) -> [u8; L] {
     let inp = inp.as_bytes();
 
     let replaced_with_bytes = replaced_with.as_bytes();
@@ -77,7 +97,7 @@ pub const fn str_replace<const L: usize>(
     }
 
     match r {
-        ReplaceInput::AsciiByte(byte) => {
+        ReplacePattern::AsciiByte(byte) => {
             let byte = byte.get();
             iter_copy_slice! {b in inp =>
                 if b == byte {
@@ -87,7 +107,7 @@ pub const fn str_replace<const L: usize>(
                 }
             }
         }
-        ReplaceInput::Str(str) => {
+        ReplacePattern::Str(str) => {
             if str.is_empty() {
                 iter_copy_slice! {b in inp =>
                     write_byte!(b);

const_format/src/char_encoding.rs

@@ -0,0 +1,107 @@
+use crate::formatting::hex_as_ascii;
+
+#[cfg(any(test, feature = "fmt"))]
+pub(crate) const fn char_display_len(c: char) -> usize {
+    match c as u32 {
+        0..=127 => 1,
+        0x80..=0x7FF => 2,
+        0x800..=0xFFFF => 3,
+        0x10000..=u32::MAX => 4,
+    }
+}
+
+#[cfg(any(test, feature = "fmt"))]
+pub(crate) const fn char_debug_len(c: char) -> usize {
+    let inner = match c {
+        '\t' | '\r' | '\n' | '\\' | '\'' | '\"' => 2,
+        '\x00'..='\x1F' => 4,
+        _ => char_display_len(c),
+    };
+    inner + 2
+}
+
+const fn char_to_utf8(char: char) -> ([u8; 4], usize) {
+    let u32 = char as u32;
+    match u32 {
+        0..=127 => ([u32 as u8, 0, 0, 0], 1),
+        0x80..=0x7FF => {
+            let b0 = 0b1100_0000 | (u32 >> 6) as u8;
+            let b1 = 0b1000_0000 | (u32 & 0b0011_1111) as u8;
+            ([b0, b1, 0, 0], 2)
+        }
+        0x800..=0xFFFF => {
+            let b0 = 0b1110_0000 | (u32 >> 12) as u8;
+            let b1 = 0b1000_0000 | ((u32 >> 6) & 0b0011_1111) as u8;
+            let b2 = 0b1000_0000 | (u32 & 0b0011_1111) as u8;
+            ([b0, b1, b2, 0], 3)
+        }
+        0x10000..=u32::MAX => {
+            let b0 = 0b1111_0000 | (u32 >> 18) as u8;
+            let b1 = 0b1000_0000 | ((u32 >> 12) & 0b0011_1111) as u8;
+            let b2 = 0b1000_0000 | ((u32 >> 6) & 0b0011_1111) as u8;
+            let b3 = 0b1000_0000 | (u32 & 0b0011_1111) as u8;
+            ([b0, b1, b2, b3], 4)
+        }
+    }
+}
+
+pub(crate) const fn char_to_display(char: char) -> FmtChar {
+    let ([b0, b1, b2, b3], len) = char_to_utf8(char);
+    FmtChar {
+        encoded: [b0, b1, b2, b3, 0, 0],
+        len: len as u8,
+    }
+}
+
+pub(crate) const fn char_to_debug(c: char) -> FmtChar {
+    let ([b0, b1, b2, b3], len) = match c {
+        '\t' => (*br#"\t  "#, 2),
+        '\r' => (*br#"\r  "#, 2),
+        '\n' => (*br#"\n  "#, 2),
+        '\\' => (*br#"\\  "#, 2),
+        '\'' => (*br#"\'  "#, 2),
+        '\"' => (*br#"\"  "#, 2),
+        '\x00'..='\x1F' => {
+            let n = c as u8;
+            (
+                [b'\\', b'x', hex_as_ascii(n >> 4), hex_as_ascii(n & 0b1111)],
+                4,
+            )
+        }
+        _ => char_to_utf8(c),
+    };
+
+    let mut encoded = [b'\'', b0, b1, b2, b3, 0];
+    encoded[len + 1] = b'\'';
+
+    FmtChar {
+        encoded,
+        len: (len as u8) + 2,
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct FmtChar {
+    encoded: [u8; 6],
+    len: u8,
+}
+
+impl FmtChar {
+    /// Array which contains the pre-len display/debug-formatted  `char`,
+    /// only `&self.encoded[][..self.len()]` should be copied.
+    pub const fn encoded(&self) -> &[u8; 6] {
+        &self.encoded
+    }
+
+    pub const fn len(&self) -> usize {
+        self.len as usize
+    }
+
+    #[cfg(test)]
+    fn as_bytes(&self) -> &[u8] {
+        &self.encoded[..self.len()]
+    }
+}
+
+#[cfg(all(test, not(miri)))]
+mod tests;