bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

int audit - libcore::fmt

Browse source
This commit is contained in:
Nick Cameron 2015-02-23 16:07:38 +13:00
parent dcc6ce2c77
commit 67b03fbc3d
7 changed files with 73 additions and 51 deletions
Download patch file Download diff file Expand all files Collapse all files

22
src/libcore/fmt/float.rs
View file

@ -40,10 +40,10 @@ pub enum ExponentFormat {
pub enum SignificantDigits { pub enum SignificantDigits {
/// At most the given number of digits will be printed, truncating any /// At most the given number of digits will be printed, truncating any
/// trailing zeroes. /// trailing zeroes.
DigMax(uint), DigMax(usize),
/// Precisely the given number of digits will be printed. /// Precisely the given number of digits will be printed.
DigExact(uint) DigExact(usize)
} }
/// How to emit the sign of a number. /// How to emit the sign of a number.
@ -240,27 +240,27 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
// If reached left end of number, have to // If reached left end of number, have to
// insert additional digit: // insert additional digit:
if i < 0 if i < 0
|| buf[i as uint] == b'-' || buf[i as usize] == b'-'
|| buf[i as uint] == b'+' { || buf[i as usize] == b'+' {
for j in (i as uint + 1..end).rev() { for j in (i as usize + 1..end).rev() {
buf[j + 1] = buf[j]; buf[j + 1] = buf[j];
} }
buf[(i + 1) as uint] = value2ascii(1); buf[(i + 1) as usize] = value2ascii(1);
end += 1; end += 1;
break; break;
} }
// Skip the '.' // Skip the '.'
if buf[i as uint] == b'.' { i -= 1; continue; } if buf[i as usize] == b'.' { i -= 1; continue; }
// Either increment the digit, // Either increment the digit,
// or set to 0 if max and carry the 1. // or set to 0 if max and carry the 1.
let current_digit = ascii2value(buf[i as uint]); let current_digit = ascii2value(buf[i as usize]);
if current_digit < (radix - 1) { if current_digit < (radix - 1) {
buf[i as uint] = value2ascii(current_digit+1); buf[i as usize] = value2ascii(current_digit+1);
break; break;
} else { } else {
buf[i as uint] = value2ascii(0); buf[i as usize] = value2ascii(0);
i -= 1; i -= 1;
} }
} }
@ -311,7 +311,7 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
struct Filler<'a> { struct Filler<'a> {
buf: &'a mut [u8], buf: &'a mut [u8],
end: &'a mut uint, end: &'a mut usize,
} }
impl<'a> fmt::Write for Filler<'a> { impl<'a> fmt::Write for Filler<'a> {

61
src/libcore/fmt/mod.rs
View file

@ -110,11 +110,14 @@ pub trait Write {
/// traits. /// traits.
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub struct Formatter<'a> { pub struct Formatter<'a> {
flags: uint, #[cfg(not(stage0))]
flags: u32,
#[cfg(stage0)]
flags: usize,
fill: char, fill: char,
align: rt::v1::Alignment, align: rt::v1::Alignment,
width: Option<uint>, width: Option<usize>,
precision: Option<uint>, precision: Option<usize>,
buf: &'a mut (Write+'a), buf: &'a mut (Write+'a),
curarg: slice::Iter<'a, ArgumentV1<'a>>, curarg: slice::Iter<'a, ArgumentV1<'a>>,
@ -140,7 +143,7 @@ pub struct ArgumentV1<'a> {
impl<'a> ArgumentV1<'a> { impl<'a> ArgumentV1<'a> {
#[inline(never)] #[inline(never)]
fn show_uint(x: &uint, f: &mut Formatter) -> Result { fn show_usize(x: &usize, f: &mut Formatter) -> Result {
Display::fmt(x, f) Display::fmt(x, f)
} }
@ -156,15 +159,22 @@ impl<'a> ArgumentV1<'a> {
} }
} }
#[cfg(stage0)]
#[doc(hidden)] #[doc(hidden)]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn from_uint(x: &uint) -> ArgumentV1 { pub fn from_uint(x: &uint) -> ArgumentV1 {
ArgumentV1::new(x, ArgumentV1::show_uint) ArgumentV1::new(x, ArgumentV1::show_usize)
}
#[cfg(not(stage0))]
#[doc(hidden)]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn from_usize(x: &usize) -> ArgumentV1 {
ArgumentV1::new(x, ArgumentV1::show_usize)
} }
fn as_uint(&self) -> Option<uint> { fn as_usize(&self) -> Option<usize> {
if self.formatter as uint == ArgumentV1::show_uint as uint { if self.formatter as usize == ArgumentV1::show_usize as usize {
Some(unsafe { *(self.value as *const _ as *const uint) }) Some(unsafe { *(self.value as *const _ as *const usize) })
} else { } else {
None None
} }
@ -194,7 +204,7 @@ impl<'a> Arguments<'a> {
/// The `pieces` array must be at least as long as `fmt` to construct /// The `pieces` array must be at least as long as `fmt` to construct
/// a valid Arguments structure. Also, any `Count` within `fmt` that is /// a valid Arguments structure. Also, any `Count` within `fmt` that is
/// `CountIsParam` or `CountIsNextParam` has to point to an argument /// `CountIsParam` or `CountIsNextParam` has to point to an argument
/// created with `argumentuint`. However, failing to do so doesn't cause /// created with `argumentusize`. However, failing to do so doesn't cause
/// unsafety, but will ignore invalid . /// unsafety, but will ignore invalid .
#[doc(hidden)] #[inline] #[doc(hidden)] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
@ -434,15 +444,15 @@ impl<'a> Formatter<'a> {
(value.formatter)(value.value, self) (value.formatter)(value.value, self)
} }
fn getcount(&mut self, cnt: &rt::v1::Count) -> Option<uint> { fn getcount(&mut self, cnt: &rt::v1::Count) -> Option<usize> {
match *cnt { match *cnt {
rt::v1::Count::Is(n) => Some(n), rt::v1::Count::Is(n) => Some(n),
rt::v1::Count::Implied => None, rt::v1::Count::Implied => None,
rt::v1::Count::Param(i) => { rt::v1::Count::Param(i) => {
self.args[i].as_uint() self.args[i].as_usize()
} }
rt::v1::Count::NextParam => { rt::v1::Count::NextParam => {
self.curarg.next().and_then(|arg| arg.as_uint()) self.curarg.next().and_then(|arg| arg.as_usize())
} }
} }
} }
@ -476,12 +486,12 @@ impl<'a> Formatter<'a> {
let mut sign = None; let mut sign = None;
if !is_positive { if !is_positive {
sign = Some('-'); width += 1; sign = Some('-'); width += 1;
} else if self.flags & (1 << (FlagV1::SignPlus as uint)) != 0 { } else if self.flags & (1 << (FlagV1::SignPlus as u32)) != 0 {
sign = Some('+'); width += 1; sign = Some('+'); width += 1;
} }
let mut prefixed = false; let mut prefixed = false;
if self.flags & (1 << (FlagV1::Alternate as uint)) != 0 { if self.flags & (1 << (FlagV1::Alternate as u32)) != 0 {
prefixed = true; width += prefix.char_len(); prefixed = true; width += prefix.char_len();
} }
@ -511,7 +521,7 @@ impl<'a> Formatter<'a> {
} }
// The sign and prefix goes before the padding if the fill character // The sign and prefix goes before the padding if the fill character
// is zero // is zero
Some(min) if self.flags & (1 << (FlagV1::SignAwareZeroPad as uint)) != 0 => { Some(min) if self.flags & (1 << (FlagV1::SignAwareZeroPad as u32)) != 0 => {
self.fill = '0'; self.fill = '0';
try!(write_prefix(self)); try!(write_prefix(self));
self.with_padding(min - width, Alignment::Right, |f| { self.with_padding(min - width, Alignment::Right, |f| {
@ -581,7 +591,7 @@ impl<'a> Formatter<'a> {
/// Runs a callback, emitting the correct padding either before or /// Runs a callback, emitting the correct padding either before or
/// afterwards depending on whether right or left alignment is requested. /// afterwards depending on whether right or left alignment is requested.
fn with_padding<F>(&mut self, padding: uint, default: Alignment, fn with_padding<F>(&mut self, padding: usize, default: Alignment,
f: F) -> Result f: F) -> Result
where F: FnOnce(&mut Formatter) -> Result, where F: FnOnce(&mut Formatter) -> Result,
{ {
@ -627,6 +637,11 @@ impl<'a> Formatter<'a> {
write(self.buf, fmt) write(self.buf, fmt)
} }
#[cfg(not(stage0))]
/// Flags for formatting (packed version of rt::Flag)
#[stable(feature = "rust1", since = "1.0.0")]
pub fn flags(&self) -> u32 { self.flags }
#[cfg(stage0)]
/// Flags for formatting (packed version of rt::Flag) /// Flags for formatting (packed version of rt::Flag)
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn flags(&self) -> usize { self.flags } pub fn flags(&self) -> usize { self.flags }
@ -641,11 +656,11 @@ impl<'a> Formatter<'a> {
/// Optionally specified integer width that the output should be /// Optionally specified integer width that the output should be
#[unstable(feature = "core", reason = "method was just created")] #[unstable(feature = "core", reason = "method was just created")]
pub fn width(&self) -> Option<uint> { self.width } pub fn width(&self) -> Option<usize> { self.width }
/// Optionally specified precision for numeric types /// Optionally specified precision for numeric types
#[unstable(feature = "core", reason = "method was just created")] #[unstable(feature = "core", reason = "method was just created")]
pub fn precision(&self) -> Option<uint> { self.precision } pub fn precision(&self) -> Option<usize> { self.precision }
} }
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
@ -731,9 +746,9 @@ impl Display for char {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
impl<T> Pointer for *const T { impl<T> Pointer for *const T {
fn fmt(&self, f: &mut Formatter) -> Result { fn fmt(&self, f: &mut Formatter) -> Result {
f.flags |= 1 << (FlagV1::Alternate as uint); f.flags |= 1 << (FlagV1::Alternate as u32);
let ret = LowerHex::fmt(&(*self as uint), f); let ret = LowerHex::fmt(&(*self as u32), f);
f.flags &= !(1 << (FlagV1::Alternate as uint)); f.flags &= !(1 << (FlagV1::Alternate as u32));
ret ret
} }
} }
@ -889,7 +904,7 @@ impl<'a> Debug for &'a (any::Any+'a) {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
impl<T: Debug> Debug for [T] { impl<T: Debug> Debug for [T] {
fn fmt(&self, f: &mut Formatter) -> Result { fn fmt(&self, f: &mut Formatter) -> Result {
if f.flags & (1 << (FlagV1::Alternate as uint)) == 0 { if f.flags & (1 << (FlagV1::Alternate as u32)) == 0 {
try!(write!(f, "[")); try!(write!(f, "["));
} }
let mut is_first = true; let mut is_first = true;
@ -901,7 +916,7 @@ impl<T: Debug> Debug for [T] {
} }
try!(write!(f, "{:?}", *x)) try!(write!(f, "{:?}", *x))
} }
if f.flags & (1 << (FlagV1::Alternate as uint)) == 0 { if f.flags & (1 << (FlagV1::Alternate as u32)) == 0 {
try!(write!(f, "]")); try!(write!(f, "]"));
} }
Ok(()) Ok(())

2
src/libcore/fmt/num.rs
View file

@ -214,7 +214,7 @@ macro_rules! integer {
show! { $Uint with $SU } show! { $Uint with $SU }
} }
} }
integer! { int, uint, "i", "u" } integer! { isize, usize, "i", "u" }
integer! { i8, u8 } integer! { i8, u8 }
integer! { i16, u16 } integer! { i16, u16 }
integer! { i32, u32 } integer! { i32, u32 }

6
src/libcore/fmt/rt/v1.rs
View file

@ -32,8 +32,12 @@ pub struct FormatSpec {
pub fill: char, pub fill: char,
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub align: Alignment, pub align: Alignment,
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub flags: uint, pub flags: usize,
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
pub flags: u32,
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub precision: Count, pub precision: Count,
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]

25
src/libfmt_macros/lib.rs
View file

@ -24,7 +24,6 @@
html_root_url = "http://doc.rust-lang.org/nightly/", html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")] html_playground_url = "http://play.rust-lang.org/")]
#![feature(int_uint)]
#![feature(staged_api)] #![feature(staged_api)]
#![feature(unicode)] #![feature(unicode)]
@ -65,7 +64,7 @@ pub struct FormatSpec<'a> {
/// Optionally specified alignment /// Optionally specified alignment
pub align: Alignment, pub align: Alignment,
/// Packed version of various flags provided /// Packed version of various flags provided
pub flags: uint, pub flags: u32,
/// The integer precision to use /// The integer precision to use
pub precision: Count<'a>, pub precision: Count<'a>,
/// The string width requested for the resulting format /// The string width requested for the resulting format
@ -82,7 +81,7 @@ pub enum Position<'a> {
/// The argument will be in the next position. This is the default. /// The argument will be in the next position. This is the default.
ArgumentNext, ArgumentNext,
/// The argument is located at a specific index. /// The argument is located at a specific index.
ArgumentIs(uint), ArgumentIs(usize),
/// The argument has a name. /// The argument has a name.
ArgumentNamed(&'a str), ArgumentNamed(&'a str),
} }
@ -121,11 +120,11 @@ pub enum Flag {
#[derive(Copy, PartialEq)] #[derive(Copy, PartialEq)]
pub enum Count<'a> { pub enum Count<'a> {
/// The count is specified explicitly. /// The count is specified explicitly.
CountIs(uint), CountIs(usize),
/// The count is specified by the argument with the given name. /// The count is specified by the argument with the given name.
CountIsName(&'a str), CountIsName(&'a str),
/// The count is specified by the argument at the given index. /// The count is specified by the argument at the given index.
CountIsParam(uint), CountIsParam(usize),
/// The count is specified by the next parameter. /// The count is specified by the next parameter.
CountIsNextParam, CountIsNextParam,
/// The count is implied and cannot be explicitly specified. /// The count is implied and cannot be explicitly specified.
@ -237,7 +236,7 @@ impl<'a> Parser<'a> {
/// Parses all of a string which is to be considered a "raw literal" in a /// Parses all of a string which is to be considered a "raw literal" in a
/// format string. This is everything outside of the braces. /// format string. This is everything outside of the braces.
fn string(&mut self, start: uint) -> &'a str { fn string(&mut self, start: usize) -> &'a str {
loop { loop {
// we may not consume the character, so clone the iterator // we may not consume the character, so clone the iterator
match self.cur.clone().next() { match self.cur.clone().next() {
@ -314,13 +313,13 @@ impl<'a> Parser<'a> {
} }
// Sign flags // Sign flags
if self.consume('+') { if self.consume('+') {
spec.flags |= 1 << (FlagSignPlus as uint); spec.flags |= 1 << (FlagSignPlus as u32);
} else if self.consume('-') { } else if self.consume('-') {
spec.flags |= 1 << (FlagSignMinus as uint); spec.flags |= 1 << (FlagSignMinus as u32);
} }
// Alternate marker // Alternate marker
if self.consume('#') { if self.consume('#') {
spec.flags |= 1 << (FlagAlternate as uint); spec.flags |= 1 << (FlagAlternate as u32);
} }
// Width and precision // Width and precision
let mut havewidth = false; let mut havewidth = false;
@ -333,7 +332,7 @@ impl<'a> Parser<'a> {
spec.width = CountIsParam(0); spec.width = CountIsParam(0);
havewidth = true; havewidth = true;
} else { } else {
spec.flags |= 1 << (FlagSignAwareZeroPad as uint); spec.flags |= 1 << (FlagSignAwareZeroPad as u32);
} }
} }
if !havewidth { if !havewidth {
@ -413,7 +412,7 @@ impl<'a> Parser<'a> {
/// Optionally parses an integer at the current position. This doesn't deal /// Optionally parses an integer at the current position. This doesn't deal
/// with overflow at all, it's just accumulating digits. /// with overflow at all, it's just accumulating digits.
fn integer(&mut self) -> Option<uint> { fn integer(&mut self) -> Option<usize> {
let mut cur = 0; let mut cur = 0;
let mut found = false; let mut found = false;
loop { loop {
@ -617,7 +616,7 @@ mod tests {
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
align: AlignUnknown, align: AlignUnknown,
flags: (1 << FlagSignMinus as uint), flags: (1 << FlagSignMinus as u32),
precision: CountImplied, precision: CountImplied,
width: CountImplied, width: CountImplied,
ty: "", ty: "",
@ -628,7 +627,7 @@ mod tests {
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
align: AlignUnknown, align: AlignUnknown,
flags: (1 << FlagSignPlus as uint) | (1 << FlagAlternate as uint), flags: (1 << FlagSignPlus as u32) | (1 << FlagAlternate as u32),
precision: CountImplied, precision: CountImplied,
width: CountImplied, width: CountImplied,
ty: "", ty: "",

4
src/libsyntax/ext/build.rs
View file

@ -148,6 +148,7 @@ pub trait AstBuilder {
fn expr_usize(&self, span: Span, i: usize) -> P<ast::Expr>; fn expr_usize(&self, span: Span, i: usize) -> P<ast::Expr>;
fn expr_int(&self, sp: Span, i: isize) -> P<ast::Expr>; fn expr_int(&self, sp: Span, i: isize) -> P<ast::Expr>;
fn expr_u8(&self, sp: Span, u: u8) -> P<ast::Expr>; fn expr_u8(&self, sp: Span, u: u8) -> P<ast::Expr>;
fn expr_u32(&self, sp: Span, u: u32) -> P<ast::Expr>;
fn expr_bool(&self, sp: Span, value: bool) -> P<ast::Expr>; fn expr_bool(&self, sp: Span, value: bool) -> P<ast::Expr>;
fn expr_vec(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr>; fn expr_vec(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr>;
@ -701,6 +702,9 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs(false), self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs(false),
ast::Sign::new(i)))) ast::Sign::new(i))))
} }
fn expr_u32(&self, sp: Span, u: u32) -> P<ast::Expr> {
self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU32)))
}
fn expr_u8(&self, sp: Span, u: u8) -> P<ast::Expr> { fn expr_u8(&self, sp: Span, u: u8) -> P<ast::Expr> {
self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU8))) self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU8)))
} }

4
src/libsyntax/ext/format.rs
View file

@ -417,7 +417,7 @@ impl<'a, 'b> Context<'a, 'b> {
parse::AlignUnknown => align("Unknown"), parse::AlignUnknown => align("Unknown"),
}; };
let align = self.ecx.expr_path(align); let align = self.ecx.expr_path(align);
let flags = self.ecx.expr_usize(sp, arg.format.flags); let flags = self.ecx.expr_u32(sp, arg.format.flags);
let prec = self.trans_count(arg.format.precision); let prec = self.trans_count(arg.format.precision);
let width = self.trans_count(arg.format.width); let width = self.trans_count(arg.format.width);
let path = self.ecx.path_global(sp, Context::rtpath(self.ecx, "FormatSpec")); let path = self.ecx.path_global(sp, Context::rtpath(self.ecx, "FormatSpec"));
@ -610,7 +610,7 @@ impl<'a, 'b> Context<'a, 'b> {
ecx.ident_of_std("core"), ecx.ident_of_std("core"),
ecx.ident_of("fmt"), ecx.ident_of("fmt"),
ecx.ident_of("ArgumentV1"), ecx.ident_of("ArgumentV1"),
ecx.ident_of("from_uint")], vec![arg]) ecx.ident_of("from_usize")], vec![arg])
} }
}; };