diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index 7f7264a04684b61426996c16ea82fd1683e3b913..f92e631c1f25c4becc028f0056484346b26fa603 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -40,10 +40,10 @@ pub enum ExponentFormat { pub enum SignificantDigits { /// At most the given number of digits will be printed, truncating any /// trailing zeroes. - DigMax(uint), + DigMax(usize), /// Precisely the given number of digits will be printed. - DigExact(uint) + DigExact(usize) } /// How to emit the sign of a number. @@ -240,27 +240,27 @@ pub fn float_to_str_bytes_common( // If reached left end of number, have to // insert additional digit: if i < 0 - || buf[i as uint] == b'-' - || buf[i as uint] == b'+' { - for j in (i as uint + 1..end).rev() { + || buf[i as usize] == b'-' + || buf[i as usize] == b'+' { + for j in (i as usize + 1..end).rev() { buf[j + 1] = buf[j]; } - buf[(i + 1) as uint] = value2ascii(1); + buf[(i + 1) as usize] = value2ascii(1); end += 1; break; } // Skip the '.' - if buf[i as uint] == b'.' { i -= 1; continue; } + if buf[i as usize] == b'.' { i -= 1; continue; } // Either increment the digit, // 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) { - buf[i as uint] = value2ascii(current_digit+1); + buf[i as usize] = value2ascii(current_digit+1); break; } else { - buf[i as uint] = value2ascii(0); + buf[i as usize] = value2ascii(0); i -= 1; } } @@ -311,7 +311,7 @@ pub fn float_to_str_bytes_common( struct Filler<'a> { buf: &'a mut [u8], - end: &'a mut uint, + end: &'a mut usize, } impl<'a> fmt::Write for Filler<'a> { diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index a2c1bbc03317e9da08451e0b2b2d6194d385568b..175a70aeb9f460c98b4662a8d75cfa8392435b8c 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -110,11 +110,14 @@ fn write_fmt(&mut self, args: Arguments) -> Result { /// traits. #[stable(feature = "rust1", since = "1.0.0")] pub struct Formatter<'a> { - flags: uint, + #[cfg(not(stage0))] + flags: u32, + #[cfg(stage0)] + flags: usize, fill: char, align: rt::v1::Alignment, - width: Option, - precision: Option, + width: Option, + precision: Option, buf: &'a mut (Write+'a), curarg: slice::Iter<'a, ArgumentV1<'a>>, @@ -140,7 +143,7 @@ pub struct ArgumentV1<'a> { impl<'a> ArgumentV1<'a> { #[inline(never)] - fn show_uint(x: &uint, f: &mut Formatter) -> Result { + fn show_usize(x: &usize, f: &mut Formatter) -> Result { Display::fmt(x, f) } @@ -156,15 +159,22 @@ pub fn new<'b, T>(x: &'b T, } } + #[cfg(stage0)] #[doc(hidden)] #[stable(feature = "rust1", since = "1.0.0")] 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 { - if self.formatter as uint == ArgumentV1::show_uint as uint { - Some(unsafe { *(self.value as *const _ as *const uint) }) + fn as_usize(&self) -> Option { + if self.formatter as usize == ArgumentV1::show_usize as usize { + Some(unsafe { *(self.value as *const _ as *const usize) }) } else { None } @@ -194,7 +204,7 @@ pub fn new_v1(pieces: &'a [&'a str], /// The `pieces` array must be at least as long as `fmt` to construct /// a valid Arguments structure. Also, any `Count` within `fmt` that is /// `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 . #[doc(hidden)] #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -434,15 +444,15 @@ fn run(&mut self, arg: &rt::v1::Argument) -> Result { (value.formatter)(value.value, self) } - fn getcount(&mut self, cnt: &rt::v1::Count) -> Option { + fn getcount(&mut self, cnt: &rt::v1::Count) -> Option { match *cnt { rt::v1::Count::Is(n) => Some(n), rt::v1::Count::Implied => None, rt::v1::Count::Param(i) => { - self.args[i].as_uint() + self.args[i].as_usize() } 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 @@ pub fn pad_integral(&mut self, let mut sign = None; if !is_positive { 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; } 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(); } @@ -511,7 +521,7 @@ pub fn pad_integral(&mut self, } // The sign and prefix goes before the padding if the fill character // 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'; try!(write_prefix(self)); self.with_padding(min - width, Alignment::Right, |f| { @@ -581,7 +591,7 @@ pub fn pad(&mut self, s: &str) -> Result { /// Runs a callback, emitting the correct padding either before or /// afterwards depending on whether right or left alignment is requested. - fn with_padding(&mut self, padding: uint, default: Alignment, + fn with_padding(&mut self, padding: usize, default: Alignment, f: F) -> Result where F: FnOnce(&mut Formatter) -> Result, { @@ -627,6 +637,11 @@ pub fn write_fmt(&mut self, fmt: Arguments) -> Result { 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) #[stable(feature = "rust1", since = "1.0.0")] pub fn flags(&self) -> usize { self.flags } @@ -641,11 +656,11 @@ pub fn align(&self) -> Alignment { self.align } /// Optionally specified integer width that the output should be #[unstable(feature = "core", reason = "method was just created")] - pub fn width(&self) -> Option { self.width } + pub fn width(&self) -> Option { self.width } /// Optionally specified precision for numeric types #[unstable(feature = "core", reason = "method was just created")] - pub fn precision(&self) -> Option { self.precision } + pub fn precision(&self) -> Option { self.precision } } #[stable(feature = "rust1", since = "1.0.0")] @@ -731,9 +746,9 @@ fn fmt(&self, f: &mut Formatter) -> Result { #[stable(feature = "rust1", since = "1.0.0")] impl Pointer for *const T { fn fmt(&self, f: &mut Formatter) -> Result { - f.flags |= 1 << (FlagV1::Alternate as uint); - let ret = LowerHex::fmt(&(*self as uint), f); - f.flags &= !(1 << (FlagV1::Alternate as uint)); + f.flags |= 1 << (FlagV1::Alternate as u32); + let ret = LowerHex::fmt(&(*self as u32), f); + f.flags &= !(1 << (FlagV1::Alternate as u32)); ret } } @@ -889,7 +904,7 @@ fn fmt(&self, f: &mut Formatter) -> Result { f.pad("&Any") } #[stable(feature = "rust1", since = "1.0.0")] impl Debug for [T] { 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, "[")); } let mut is_first = true; @@ -901,7 +916,7 @@ fn fmt(&self, f: &mut Formatter) -> Result { } 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, "]")); } Ok(()) diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 1222126b5e0cdef73c0a3bccc4ce5dff3630c90f..0175e21c8da6152b47bfbbae924118a19bc3bc64 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -214,7 +214,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { show! { $Uint with $SU } } } -integer! { int, uint, "i", "u" } +integer! { isize, usize, "i", "u" } integer! { i8, u8 } integer! { i16, u16 } integer! { i32, u32 } diff --git a/src/libcore/fmt/rt/v1.rs b/src/libcore/fmt/rt/v1.rs index 0c9bb6316e0d805ecbcc08a05c1c6bb2fa67bc5e..c35611acb81428561ccb4634f72889588e534ec6 100644 --- a/src/libcore/fmt/rt/v1.rs +++ b/src/libcore/fmt/rt/v1.rs @@ -32,8 +32,12 @@ pub struct FormatSpec { pub fill: char, #[stable(feature = "rust1", since = "1.0.0")] pub align: Alignment, + #[cfg(stage0)] #[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")] pub precision: Count, #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index be77622ac1db7c52335525cefd8753423177258f..4e25e51e9a466075c58b49ae0207413b88a8b426 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -24,7 +24,6 @@ html_root_url = "http://doc.rust-lang.org/nightly/", html_playground_url = "http://play.rust-lang.org/")] -#![feature(int_uint)] #![feature(staged_api)] #![feature(unicode)] @@ -65,7 +64,7 @@ pub struct FormatSpec<'a> { /// Optionally specified alignment pub align: Alignment, /// Packed version of various flags provided - pub flags: uint, + pub flags: u32, /// The integer precision to use pub precision: Count<'a>, /// 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. ArgumentNext, /// The argument is located at a specific index. - ArgumentIs(uint), + ArgumentIs(usize), /// The argument has a name. ArgumentNamed(&'a str), } @@ -121,11 +120,11 @@ pub enum Flag { #[derive(Copy, PartialEq)] pub enum Count<'a> { /// The count is specified explicitly. - CountIs(uint), + CountIs(usize), /// The count is specified by the argument with the given name. CountIsName(&'a str), /// The count is specified by the argument at the given index. - CountIsParam(uint), + CountIsParam(usize), /// The count is specified by the next parameter. CountIsNextParam, /// The count is implied and cannot be explicitly specified. @@ -237,7 +236,7 @@ fn ws(&mut self) { /// Parses all of a string which is to be considered a "raw literal" in a /// 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 { // we may not consume the character, so clone the iterator match self.cur.clone().next() { @@ -314,13 +313,13 @@ fn format(&mut self) -> FormatSpec<'a> { } // Sign flags if self.consume('+') { - spec.flags |= 1 << (FlagSignPlus as uint); + spec.flags |= 1 << (FlagSignPlus as u32); } else if self.consume('-') { - spec.flags |= 1 << (FlagSignMinus as uint); + spec.flags |= 1 << (FlagSignMinus as u32); } // Alternate marker if self.consume('#') { - spec.flags |= 1 << (FlagAlternate as uint); + spec.flags |= 1 << (FlagAlternate as u32); } // Width and precision let mut havewidth = false; @@ -333,7 +332,7 @@ fn format(&mut self) -> FormatSpec<'a> { spec.width = CountIsParam(0); havewidth = true; } else { - spec.flags |= 1 << (FlagSignAwareZeroPad as uint); + spec.flags |= 1 << (FlagSignAwareZeroPad as u32); } } if !havewidth { @@ -413,7 +412,7 @@ fn word(&mut self) -> &'a str { /// Optionally parses an integer at the current position. This doesn't deal /// with overflow at all, it's just accumulating digits. - fn integer(&mut self) -> Option { + fn integer(&mut self) -> Option { let mut cur = 0; let mut found = false; loop { @@ -617,7 +616,7 @@ fn format_flags() { format: FormatSpec { fill: None, align: AlignUnknown, - flags: (1 << FlagSignMinus as uint), + flags: (1 << FlagSignMinus as u32), precision: CountImplied, width: CountImplied, ty: "", @@ -628,7 +627,7 @@ fn format_flags() { format: FormatSpec { fill: None, align: AlignUnknown, - flags: (1 << FlagSignPlus as uint) | (1 << FlagAlternate as uint), + flags: (1 << FlagSignPlus as u32) | (1 << FlagAlternate as u32), precision: CountImplied, width: CountImplied, ty: "", diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 8923290d655c81812071a3fb04da62324b3839d5..656d507ed69b826952ecbe61bb354f1c72c69836 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -148,6 +148,7 @@ fn expr_struct_ident(&self, span: Span, id: ast::Ident, fn expr_usize(&self, span: Span, i: usize) -> P; fn expr_int(&self, sp: Span, i: isize) -> P; fn expr_u8(&self, sp: Span, u: u8) -> P; + fn expr_u32(&self, sp: Span, u: u32) -> P; fn expr_bool(&self, sp: Span, value: bool) -> P; fn expr_vec(&self, sp: Span, exprs: Vec>) -> P; @@ -701,6 +702,9 @@ fn expr_int(&self, sp: Span, i: isize) -> P { self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs(false), ast::Sign::new(i)))) } + fn expr_u32(&self, sp: Span, u: u32) -> P { + self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU32))) + } fn expr_u8(&self, sp: Span, u: u8) -> P { self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU8))) } diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index 1c2374e31f13037820596790264e98aeea593981..91262556abd706f72ee4bcc91b90d279d1292221 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -417,7 +417,7 @@ fn trans_piece(&mut self, piece: &parse::Piece) -> Option> { parse::AlignUnknown => align("Unknown"), }; 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 width = self.trans_count(arg.format.width); let path = self.ecx.path_global(sp, Context::rtpath(self.ecx, "FormatSpec")); @@ -610,7 +610,7 @@ fn format_arg(ecx: &ExtCtxt, sp: Span, ecx.ident_of_std("core"), ecx.ident_of("fmt"), ecx.ident_of("ArgumentV1"), - ecx.ident_of("from_uint")], vec![arg]) + ecx.ident_of("from_usize")], vec![arg]) } };