OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rollup merge of #28896 - mkpankov:core-fmt, r=nrc 

<!-- Reviewable:start -->
[<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/rust-lang/rust/28896)
<!-- Reviewable:end -->
This commit is contained in:
Steve Klabnik 2015-10-07 18:18:38 -04:00
parent fb09639d92 11a7773a3a
commit 0fbf7eaf81
5 changed files with 93 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
src/libcore/fmt/builders.rs
View File

@ -61,7 +61,8 @@ pub struct DebugStruct<'a, 'b: 'a> {
has_fields: bool,
}
pub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str)
pub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>,
name: &str)
-> DebugStruct<'a, 'b> {
let result = fmt.write_str(name);
DebugStruct {
@ -84,7 +85,8 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
if self.is_pretty() {
let mut writer = PadAdapter::new(self.fmt);
fmt::write(&mut writer, format_args!("{}\n{}: {:#?}", prefix, name, value))
fmt::write(&mut writer,
format_args!("{}\n{}: {:#?}", prefix, name, value))
} else {
write!(self.fmt, "{} {}: {:?}", prefix, name, value)
}
@ -195,10 +197,18 @@ impl<'a, 'b: 'a> DebugInner<'a, 'b> {
self.result = self.result.and_then(|_| {
if self.is_pretty() {
let mut writer = PadAdapter::new(self.fmt);
let prefix = if self.has_fields { "," } else { "" };
let prefix = if self.has_fields {
","
} else {
""
};
fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, entry))
} else {
let prefix = if self.has_fields { ", " } else { "" };
let prefix = if self.has_fields {
", "
} else {
""
};
write!(self.fmt, "{}{:?}", prefix, entry)
}
});
@ -207,7 +217,11 @@ impl<'a, 'b: 'a> DebugInner<'a, 'b> {
}
pub fn finish(&mut self) {
let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" };
let prefix = if self.is_pretty() && self.has_fields {
"\n"
} else {
""
};
self.result = self.result.and_then(|_| self.fmt.write_str(prefix));
}
@ -232,7 +246,7 @@ pub fn debug_set_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugSet<'a, 'b
fmt: fmt,
result: result,
has_fields: false,
}
},
}
}
@ -247,7 +261,9 @@ impl<'a, 'b: 'a> DebugSet<'a, 'b> {
/// Adds the contents of an iterator of entries to the set output.
#[stable(feature = "debug_builders", since = "1.2.0")]
pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>
where D: fmt::Debug, I: IntoIterator<Item=D> {
where D: fmt::Debug,
I: IntoIterator<Item = D>
{
for entry in entries {
self.entry(&entry);
}
@ -278,7 +294,7 @@ pub fn debug_list_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugList<'a,
fmt: fmt,
result: result,
has_fields: false,
}
},
}
}
@ -293,7 +309,9 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> {
/// Adds the contents of an iterator of entries to the list output.
#[stable(feature = "debug_builders", since = "1.2.0")]
pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugList<'a, 'b>
where D: fmt::Debug, I: IntoIterator<Item=D> {
where D: fmt::Debug,
I: IntoIterator<Item = D>
{
for entry in entries {
self.entry(&entry);
}
@ -335,10 +353,19 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
self.result = self.result.and_then(|_| {
if self.is_pretty() {
let mut writer = PadAdapter::new(self.fmt);
let prefix = if self.has_fields { "," } else { "" };
fmt::write(&mut writer, format_args!("{}\n{:#?}: {:#?}", prefix, key, value))
let prefix = if self.has_fields {
","
} else {
""
};
fmt::write(&mut writer,
format_args!("{}\n{:#?}: {:#?}", prefix, key, value))
} else {
let prefix = if self.has_fields { ", " } else { "" };
let prefix = if self.has_fields {
", "
} else {
""
};
write!(self.fmt, "{}{:?}: {:?}", prefix, key, value)
}
});
@ -350,7 +377,10 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
/// Adds the contents of an iterator of entries to the map output.
#[stable(feature = "debug_builders", since = "1.2.0")]
pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
where K: fmt::Debug, V: fmt::Debug, I: IntoIterator<Item=(K, V)> {
where K: fmt::Debug,
V: fmt::Debug,
I: IntoIterator<Item = (K, V)>
{
for (k, v) in entries {
self.entry(&k, &v);
}
@ -360,7 +390,11 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
/// Finishes output and returns any error encountered.
#[stable(feature = "debug_builders", since = "1.2.0")]
pub fn finish(&mut self) -> fmt::Result {
let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" };
let prefix = if self.is_pretty() && self.has_fields {
"\n"
} else {
""
};
self.result.and_then(|_| write!(self.fmt, "{}}}", prefix))
}

22
src/libcore/fmt/num.rs
View File

@ -48,7 +48,9 @@ trait GenericRadix {
fn base(&self) -> u8;
/// A radix-specific prefix string.
fn prefix(&self) -> &'static str { "" }
fn prefix(&self) -> &'static str {
""
}
/// Converts an integer to corresponding radix digit.
fn digit(&self, x: u8) -> u8;
@ -70,7 +72,10 @@ trait GenericRadix {
x = x / base; // Deaccumulate the number.
*byte = self.digit(n.to_u8()); // Store the digit in the buffer.
curr -= 1;
if x == zero { break }; // No more digits left to accumulate.
if x == zero {
// No more digits left to accumulate.
break
};
}
} else {
// Do the same as above, but accounting for two's complement.
@ -79,7 +84,10 @@ trait GenericRadix {
x = x / base; // Deaccumulate the number.
*byte = self.digit(n.to_u8()); // Store the digit in the buffer.
curr -= 1;
if x == zero { break }; // No more digits left to accumulate.
if x == zero {
// No more digits left to accumulate.
break
};
}
}
let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) };
@ -141,13 +149,17 @@ pub struct Radix {
impl Radix {
fn new(base: u8) -> Radix {
assert!(2 <= base && base <= 36, "the base must be in the range of 2..36: {}", base);
assert!(2 <= base && base <= 36,
"the base must be in the range of 2..36: {}",
base);
Radix { base: base }
}
}
impl GenericRadix for Radix {
fn base(&self) -> u8 { self.base }
fn base(&self) -> u8 {
self.base
}
fn digit(&self, x: u8) -> u8 {
match x {
x @ 0 ... 9 => b'0' + x,

2
src/libcore/fmt/rt/v1.rs
View File

@ -53,5 +53,5 @@ pub enum Count {
#[derive(Copy, Clone)]
pub enum Position {
Next,
At(usize)
At(usize),
}

31
src/libcore/hash/mod.rs
View File

@ -100,7 +100,9 @@ pub trait Hash {
/// Feeds a slice of this type into the state provided.
#[stable(feature = "hash_slice", since = "1.3.0")]
fn hash_slice<H: Hasher>(data: &[Self], state: &mut H) where Self: Sized {
fn hash_slice<H: Hasher>(data: &[Self], state: &mut H)
where Self: Sized
{
for piece in data {
piece.hash(state);
}
@ -121,7 +123,9 @@ pub trait Hasher {
/// Write a single `u8` into this hasher
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_u8(&mut self, i: u8) { self.write(&[i]) }
fn write_u8(&mut self, i: u8) {
self.write(&[i])
}
/// Write a single `u16` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
@ -145,8 +149,7 @@ pub trait Hasher {
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_usize(&mut self, i: usize) {
let bytes = unsafe {
::slice::from_raw_parts(&i as *const usize as *const u8,
mem::size_of::<usize>())
::slice::from_raw_parts(&i as *const usize as *const u8, mem::size_of::<usize>())
};
self.write(bytes);
}
@ -154,23 +157,33 @@ pub trait Hasher {
/// Write a single `i8` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_i8(&mut self, i: i8) { self.write_u8(i as u8) }
fn write_i8(&mut self, i: i8) {
self.write_u8(i as u8)
}
/// Write a single `i16` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_i16(&mut self, i: i16) { self.write_u16(i as u16) }
fn write_i16(&mut self, i: i16) {
self.write_u16(i as u16)
}
/// Write a single `i32` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_i32(&mut self, i: i32) { self.write_u32(i as u32) }
fn write_i32(&mut self, i: i32) {
self.write_u32(i as u32)
}
/// Write a single `i64` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_i64(&mut self, i: i64) { self.write_u64(i as u64) }
fn write_i64(&mut self, i: i64) {
self.write_u64(i as u64)
}
/// Write a single `isize` into this hasher.
#[inline]
#[stable(feature = "hasher_write", since = "1.3.0")]
fn write_isize(&mut self, i: isize) { self.write_usize(i as usize) }
fn write_isize(&mut self, i: isize) {
self.write_usize(i as usize)
}
}
//////////////////////////////////////////////////////////////////////////////

11
src/libcore/hash/sip.rs
View File

@ -37,12 +37,12 @@ pub struct SipHasher {
// and simd implementations of SipHash will use vectors
// of v02 and v13. By placing them in this order in the struct,
// the compiler can pick up on just a few simd optimizations by itself.
v0: u64, // hash state
v0: u64, // hash state
v2: u64,
v1: u64,
v3: u64,
tail: u64, // unprocessed bytes le
ntail: usize, // how many bytes in tail are valid
ntail: usize, // how many bytes in tail are valid
}
// sadly, these macro definitions can't appear later,
@ -80,8 +80,7 @@ macro_rules! u8to64_le {
unsafe fn load_u64_le(buf: &[u8], i: usize) -> u64 {
debug_assert!(i + 8 <= buf.len());
let mut data = 0u64;
ptr::copy_nonoverlapping(buf.get_unchecked(i),
&mut data as *mut _ as *mut u8, 8);
ptr::copy_nonoverlapping(buf.get_unchecked(i), &mut data as *mut _ as *mut u8, 8);
data.to_le()
}
@ -152,12 +151,12 @@ impl Hasher for SipHasher {
if self.ntail != 0 {
needed = 8 - self.ntail;
if length < needed {
self.tail |= u8to64_le!(msg, 0, length) << 8*self.ntail;
self.tail |= u8to64_le!(msg, 0, length) << 8 * self.ntail;
self.ntail += length;
return
}
let m = self.tail | u8to64_le!(msg, 0, needed) << 8*self.ntail;
let m = self.tail | u8to64_le!(msg, 0, needed) << 8 * self.ntail;
self.v3 ^= m;
compress!(self.v0, self.v1, self.v2, self.v3);