Skip to content

Commit 16981ba

Browse files
reitermarkusreitermarkus
committed
Avoid panicking branch in EscapeIterInner.
1 parent e3fc97b commit 16981ba

File tree

4 files changed

+137
-81
lines changed

4 files changed

+137
-81
lines changed

‎library/core/src/ascii.rs

+9-5
Original file line numberDiff line numberDiff line change
@@ -91,17 +91,21 @@ pub struct EscapeDefault(escape::EscapeIterInner<4>);
9191
/// ```
9292
#[stable(feature = "rust1", since = "1.0.0")]
9393
pub fn escape_default(c: u8) -> EscapeDefault {
94-
let mut data = [Char::Null; 4];
95-
let range = escape::escape_ascii_into(&mut data, c);
96-
EscapeDefault(escape::EscapeIterInner::new(data, range))
94+
EscapeDefault::new(c)
9795
}
9896

9997
impl EscapeDefault {
98+
#[inline]
99+
pub(crate) const fn new(c: u8) -> Self {
100+
Self(escape::EscapeIterInner::ascii(c))
101+
}
102+
103+
#[inline]
100104
pub(crate) fn empty() -> Self {
101-
let data = [Char::Null; 4];
102-
EscapeDefault(escape::EscapeIterInner::new(data, 0..0))
105+
EscapeDefault(escape::EscapeIterInner::empty())
103106
}
104107

108+
#[inline]
105109
pub(crate) fn as_str(&self) -> &str {
106110
self.0.as_str()
107111
}

‎library/core/src/char/methods.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -449,10 +449,10 @@ impl char {
449449
'\"' if args.escape_double_quote => EscapeDebug::backslash(ascii::Char::QuotationMark),
450450
'\'' if args.escape_single_quote => EscapeDebug::backslash(ascii::Char::Apostrophe),
451451
_ if args.escape_grapheme_extended && self.is_grapheme_extended() => {
452-
EscapeDebug::from_unicode(self.escape_unicode())
452+
EscapeDebug::unicode(self)
453453
}
454454
_ if is_printable(self) => EscapeDebug::printable(self),
455-
_ => EscapeDebug::from_unicode(self.escape_unicode()),
455+
_ => EscapeDebug::unicode(self),
456456
}
457457
}
458458

@@ -555,9 +555,9 @@ impl char {
555555
'\t' => EscapeDefault::backslash(ascii::Char::SmallT),
556556
'\r' => EscapeDefault::backslash(ascii::Char::SmallR),
557557
'\n' => EscapeDefault::backslash(ascii::Char::SmallN),
558-
'\\' | '\'' | '"' => EscapeDefault::backslash(self.as_ascii().unwrap()),
558+
'\\' | '\'' | '\"' => EscapeDefault::backslash(self.as_ascii().unwrap()),
559559
'\x20'..='\x7e' => EscapeDefault::printable(self.as_ascii().unwrap()),
560-
_ => EscapeDefault::from_unicode(self.escape_unicode()),
560+
_ => EscapeDefault::unicode(self),
561561
}
562562
}
563563

‎library/core/src/char/mod.rs

+27-21
Original file line numberDiff line numberDiff line change
@@ -152,10 +152,9 @@ pub const fn from_digit(num: u32, radix: u32) -> Option<char> {
152152
pub struct EscapeUnicode(escape::EscapeIterInner<10>);
153153

154154
impl EscapeUnicode {
155-
fn new(chr: char) -> Self {
156-
let mut data = [ascii::Char::Null; 10];
157-
let range = escape::escape_unicode_into(&mut data, chr);
158-
Self(escape::EscapeIterInner::new(data, range))
155+
#[inline]
156+
const fn new(c: char) -> Self {
157+
Self(escape::EscapeIterInner::unicode(c))
159158
}
160159
}
161160

@@ -219,18 +218,24 @@ impl fmt::Display for EscapeUnicode {
219218
pub struct EscapeDefault(escape::EscapeIterInner<10>);
220219

221220
impl EscapeDefault {
222-
fn printable(chr: ascii::Char) -> Self {
223-
let data = [chr];
224-
Self(escape::EscapeIterInner::from_array(data))
221+
#[inline]
222+
const fn printable(c: ascii::Char) -> Self {
223+
Self::ascii(c.to_u8())
225224
}
226225

227-
fn backslash(chr: ascii::Char) -> Self {
228-
let data = [ascii::Char::ReverseSolidus, chr];
229-
Self(escape::EscapeIterInner::from_array(data))
226+
#[inline]
227+
const fn backslash(c: ascii::Char) -> Self {
228+
Self(escape::EscapeIterInner::backslash(c))
230229
}
231230

232-
fn from_unicode(esc: EscapeUnicode) -> Self {
233-
Self(esc.0)
231+
#[inline]
232+
const fn ascii(c: u8) -> Self {
233+
Self(escape::EscapeIterInner::ascii(c))
234+
}
235+
236+
#[inline]
237+
const fn unicode(c: char) -> Self {
238+
Self(escape::EscapeIterInner::unicode(c))
234239
}
235240
}
236241

@@ -304,23 +309,24 @@ enum EscapeDebugInner {
304309
}
305310

306311
impl EscapeDebug {
307-
fn printable(chr: char) -> Self {
312+
#[inline]
313+
const fn printable(chr: char) -> Self {
308314
Self(EscapeDebugInner::Char(chr))
309315
}
310316

311-
fn backslash(chr: ascii::Char) -> Self {
312-
let data = [ascii::Char::ReverseSolidus, chr];
313-
let iter = escape::EscapeIterInner::from_array(data);
314-
Self(EscapeDebugInner::Bytes(iter))
317+
#[inline]
318+
const fn backslash(c: ascii::Char) -> Self {
319+
Self(EscapeDebugInner::Bytes(escape::EscapeIterInner::backslash(c)))
315320
}
316321

317-
fn from_unicode(esc: EscapeUnicode) -> Self {
318-
Self(EscapeDebugInner::Bytes(esc.0))
322+
#[inline]
323+
const fn unicode(c: char) -> Self {
324+
Self(EscapeDebugInner::Bytes(escape::EscapeIterInner::unicode(c)))
319325
}
320326

327+
#[inline]
321328
fn clear(&mut self) {
322-
let bytes = escape::EscapeIterInner::from_array([]);
323-
self.0 = EscapeDebugInner::Bytes(bytes);
329+
self.0 = EscapeDebugInner::Bytes(escape::EscapeIterInner::empty());
324330
}
325331
}
326332

‎library/core/src/escape.rs

+97-51
Original file line numberDiff line numberDiff line change
@@ -6,56 +6,85 @@ use crate::ops::Range;
66

77
const HEX_DIGITS: [ascii::Char; 16] = *b"0123456789abcdef".as_ascii().unwrap();
88

9-
/// Escapes a byte into provided buffer; returns length of escaped
10-
/// representation.
11-
pub(crate) fn escape_ascii_into(output: &mut [ascii::Char; 4], byte: u8) -> Range<u8> {
12-
#[inline]
13-
fn backslash(a: ascii::Char) -> ([ascii::Char; 4], u8) {
14-
([ascii::Char::ReverseSolidus, a, ascii::Char::Null, ascii::Char::Null], 2)
15-
}
9+
#[inline]
10+
const fn backslash<const N: usize>(a: ascii::Char) -> ([ascii::Char; N], u8) {
11+
const { assert!(N >= 2) };
12+
13+
let mut output = [ascii::Char::Null; N];
14+
15+
output[0] = ascii::Char::ReverseSolidus;
16+
output[1] = a;
17+
18+
(output, 2)
19+
}
20+
21+
/// Escapes an ASCII character.
22+
///
23+
/// Returns a buffer and the length of the escaped representation.
24+
const fn escape_ascii<const N: usize>(byte: u8) -> ([ascii::Char; N], u8) {
25+
const { assert!(N >= 4) };
1626

17-
let (data, len) = match byte {
27+
match byte {
1828
b'\t' => backslash(ascii::Char::SmallT),
1929
b'\r' => backslash(ascii::Char::SmallR),
2030
b'\n' => backslash(ascii::Char::SmallN),
2131
b'\\' => backslash(ascii::Char::ReverseSolidus),
2232
b'\'' => backslash(ascii::Char::Apostrophe),
2333
b'\"' => backslash(ascii::Char::QuotationMark),
24-
_ => {
25-
if let Some(a) = byte.as_ascii()
34+
byte => {
35+
let mut output = [ascii::Char::Null; N];
36+
37+
if let Some(c) = byte.as_ascii()
2638
&& !byte.is_ascii_control()
2739
{
28-
([a, ascii::Char::Null, ascii::Char::Null, ascii::Char::Null], 1)
40+
output[0] = c;
41+
(output, 1)
2942
} else {
30-
let hi = HEX_DIGITS[usize::from(byte >> 4)];
31-
let lo = HEX_DIGITS[usize::from(byte & 0xf)];
32-
([ascii::Char::ReverseSolidus, ascii::Char::SmallX, hi, lo], 4)
43+
let hi = HEX_DIGITS[(byte >> 4) as usize];
44+
let lo = HEX_DIGITS[(byte & 0xf) as usize];
45+
46+
output[0] = ascii::Char::ReverseSolidus;
47+
output[1] = ascii::Char::SmallX;
48+
output[2] = hi;
49+
output[3] = lo;
50+
51+
(output, 4)
3352
}
3453
}
35-
};
36-
*output = data;
37-
0..len
54+
}
3855
}
3956

40-
/// Escapes a character into provided buffer using `\u{NNNN}` representation.
41-
pub(crate) fn escape_unicode_into(output: &mut [ascii::Char; 10], ch: char) -> Range<u8> {
42-
output[9] = ascii::Char::RightCurlyBracket;
43-
44-
let ch = ch as u32;
45-
output[3] = HEX_DIGITS[((ch >> 20) & 15) as usize];
46-
output[4] = HEX_DIGITS[((ch >> 16) & 15) as usize];
47-
output[5] = HEX_DIGITS[((ch >> 12) & 15) as usize];
48-
output[6] = HEX_DIGITS[((ch >> 8) & 15) as usize];
49-
output[7] = HEX_DIGITS[((ch >> 4) & 15) as usize];
50-
output[8] = HEX_DIGITS[((ch >> 0) & 15) as usize];
51-
52-
// or-ing 1 ensures that for ch==0 the code computes that one digit should
53-
// be printed.
54-
let start = (ch | 1).leading_zeros() as usize / 4 - 2;
55-
const UNICODE_ESCAPE_PREFIX: &[ascii::Char; 3] = b"\\u{".as_ascii().unwrap();
56-
output[start..][..3].copy_from_slice(UNICODE_ESCAPE_PREFIX);
57-
58-
(start as u8)..10
57+
/// Escapes a character `\u{NNNN}` representation.
58+
///
59+
/// Returns a buffer and the length of the escaped representation.
60+
const fn escape_unicode<const N: usize>(c: char) -> ([ascii::Char; N], u8) {
61+
const { assert!(N >= 10) };
62+
63+
let c = c as u32;
64+
65+
// OR-ing `1` ensures that for `c == 0` the code computes that
66+
// one digit should be printed.
67+
let u_len = (8 - (c | 1).leading_zeros() / 4) as usize;
68+
69+
let closing_paren_offset = 3 + u_len;
70+
71+
let mut output = [ascii::Char::Null; N];
72+
73+
output[0] = ascii::Char::ReverseSolidus;
74+
output[1] = ascii::Char::SmallU;
75+
output[2] = ascii::Char::LeftCurlyBracket;
76+
77+
output[3 + u_len.saturating_sub(6)] = HEX_DIGITS[((c >> 20) & 0x0f) as usize];
78+
output[3 + u_len.saturating_sub(5)] = HEX_DIGITS[((c >> 16) & 0x0f) as usize];
79+
output[3 + u_len.saturating_sub(4)] = HEX_DIGITS[((c >> 12) & 0x0f) as usize];
80+
output[3 + u_len.saturating_sub(3)] = HEX_DIGITS[((c >> 8) & 0x0f) as usize];
81+
output[3 + u_len.saturating_sub(2)] = HEX_DIGITS[((c >> 4) & 0x0f) as usize];
82+
output[3 + u_len.saturating_sub(1)] = HEX_DIGITS[((c >> 0) & 0x0f) as usize];
83+
84+
output[closing_paren_offset] = ascii::Char::RightCurlyBracket;
85+
86+
let len = (closing_paren_offset + 1) as u8;
87+
(output, len)
5988
}
6089

6190
/// An iterator over an fixed-size array.
@@ -65,45 +94,62 @@ pub(crate) fn escape_unicode_into(output: &mut [ascii::Char; 10], ch: char) -> R
6594
#[derive(Clone, Debug)]
6695
pub(crate) struct EscapeIterInner<const N: usize> {
6796
// The element type ensures this is always ASCII, and thus also valid UTF-8.
68-
pub(crate) data: [ascii::Char; N],
97+
data: [ascii::Char; N],
6998

70-
// Invariant: alive.start <= alive.end <= N.
71-
pub(crate) alive: Range<u8>,
99+
// Invariant: `alive.start <= alive.end <= N`
100+
alive: Range<u8>,
72101
}
73102

74103
impl<const N: usize> EscapeIterInner<N> {
75-
pub fn new(data: [ascii::Char; N], alive: Range<u8>) -> Self {
76-
const { assert!(N < 256) };
77-
debug_assert!(alive.start <= alive.end && usize::from(alive.end) <= N, "{alive:?}");
78-
Self { data, alive }
104+
pub const fn backslash(c: ascii::Char) -> Self {
105+
let (data, len) = backslash(c);
106+
Self { data, alive: 0..len }
79107
}
80108

81-
pub fn from_array<const M: usize>(array: [ascii::Char; M]) -> Self {
82-
const { assert!(M <= N) };
109+
pub const fn ascii(c: u8) -> Self {
110+
let (data, len) = escape_ascii(c);
111+
Self { data, alive: 0..len }
112+
}
83113

84-
let mut data = [ascii::Char::Null; N];
85-
data[..M].copy_from_slice(&array);
86-
Self::new(data, 0..M as u8)
114+
pub const fn unicode(c: char) -> Self {
115+
let (data, len) = escape_unicode(c);
116+
Self { data, alive: 0..len }
117+
}
118+
119+
#[inline]
120+
pub const fn empty() -> Self {
121+
Self { data: [ascii::Char::Null; N], alive: 0..0 }
87122
}
88123

89124
pub fn as_ascii(&self) -> &[ascii::Char] {
90-
&self.data[usize::from(self.alive.start)..usize::from(self.alive.end)]
125+
// SAFETY: `self.alive` is guaranteed to be a valid range for indexing `self.data`.
126+
unsafe {
127+
self.data.get_unchecked(usize::from(self.alive.start)..usize::from(self.alive.end))
128+
}
91129
}
92130

131+
#[inline]
93132
pub fn as_str(&self) -> &str {
94133
self.as_ascii().as_str()
95134
}
96135

136+
#[inline]
97137
pub fn len(&self) -> usize {
98138
usize::from(self.alive.end - self.alive.start)
99139
}
100140

101141
pub fn next(&mut self) -> Option<u8> {
102-
self.alive.next().map(|i| self.data[usize::from(i)].to_u8())
142+
let i = self.alive.next()?;
143+
144+
// SAFETY: `i` is guaranteed to be a valid index for `self.data`.
145+
unsafe { Some(self.data.get_unchecked(usize::from(i)).to_u8()) }
103146
}
104147

105148
pub fn next_back(&mut self) -> Option<u8> {
106-
self.alive.next_back().map(|i| self.data[usize::from(i)].to_u8())
149+
let i = self.alive.next_back()?;
150+
151+
// SAFETY: `i` is guaranteed to be a valid index for `self.data`.
152+
unsafe { Some(self.data.get_unchecked(usize::from(i)).to_u8()) }
107153
}
108154

109155
pub fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {

0 commit comments

Comments
 (0)