---

yaml
---
r: 32562
b: refs/heads/dist-snap
c: 287114a
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: fa74edf1a00c12c9e37ccf9a43c68b0f1a453678
+refs/heads/dist-snap: 287114a3b9ecc2062482271fabe608d8df0f0aa1
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/libcore/core.rs

@@ -4,10 +4,6 @@
 
 use option::{Some, None};
 use Option = option::Option;
-// XXX: snapshot rustc is generating code that wants lower-case option
-#[cfg(stage0)]
-use option = option::Option;
-
 use result::{Result, Ok, Err};
 
 use Path = path::Path;

branches/dist-snap/src/libcore/extfmt.rs

@@ -268,13 +268,11 @@ mod ct {
     }
 }
 
-
 // Functions used by the fmt extension at runtime. For now there are a lot of
 // decisions made a runtime. If it proves worthwhile then some of these
 // conditions can be evaluated at compile-time. For now though it's cleaner to
 // implement it 0this way, I think.
-// XXX Rename to rt after snapshot
-mod rt2 {
+mod rt {
     const flag_none : u32 = 0u32;
     const flag_left_justify   : u32 = 0b00000000000000000000000000000001u32;
     const flag_left_zero_pad  : u32 = 0b00000000000000000000000000000010u32;
@@ -461,22 +459,21 @@ mod rt2 {
     }
 }
 
-// XXX remove after snappies
-#[allow(non_camel_case_types)]
-mod rt {
+// XXX remove after snapshots
+mod rt2 {
     const flag_none : u32 = 0u32;
     const flag_left_justify   : u32 = 0b00000000000000000000000000000001u32;
     const flag_left_zero_pad  : u32 = 0b00000000000000000000000000000010u32;
     const flag_space_for_sign : u32 = 0b00000000000000000000000000000100u32;
     const flag_sign_always    : u32 = 0b00000000000000000000000000001000u32;
     const flag_alternate      : u32 = 0b00000000000000000000000000010000u32;
 
-    enum count { count_is(int), count_implied, }
-    enum ty { ty_default, ty_bits, ty_hex_upper, ty_hex_lower, ty_octal, }
+    enum Count { CountIs(int), CountImplied, }
+    enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, }
 
-    type conv = {flags: u32, width: count, precision: count, ty: ty};
+    type Conv = {flags: u32, width: Count, precision: Count, ty: Ty};
 
-    pure fn conv_int(cv: conv, i: int) -> ~str {
+    pure fn conv_int(cv: Conv, i: int) -> ~str {
         let radix = 10u;
         let prec = get_int_precision(cv);
         let mut s : ~str = int_to_str_prec(i, radix, prec);
@@ -487,47 +484,47 @@ mod rt {
                 unchecked { str::unshift_char(s, ' ') };
             }
         }
-        return unchecked { pad(cv, s, pad_signed) };
+        return unchecked { pad(cv, s, PadSigned) };
     }
-    pure fn conv_uint(cv: conv, u: uint) -> ~str {
+    pure fn conv_uint(cv: Conv, u: uint) -> ~str {
         let prec = get_int_precision(cv);
         let mut rs =
             match cv.ty {
-              ty_default => uint_to_str_prec(u, 10u, prec),
-              ty_hex_lower => uint_to_str_prec(u, 16u, prec),
-              ty_hex_upper => str::to_upper(uint_to_str_prec(u, 16u, prec)),
-              ty_bits => uint_to_str_prec(u, 2u, prec),
-              ty_octal => uint_to_str_prec(u, 8u, prec)
+              TyDefault => uint_to_str_prec(u, 10u, prec),
+              TyHexLower => uint_to_str_prec(u, 16u, prec),
+              TyHexUpper => str::to_upper(uint_to_str_prec(u, 16u, prec)),
+              TyBits => uint_to_str_prec(u, 2u, prec),
+              TyOctal => uint_to_str_prec(u, 8u, prec)
             };
-        return unchecked { pad(cv, rs, pad_unsigned) };
+        return unchecked { pad(cv, rs, PadUnsigned) };
     }
-    pure fn conv_bool(cv: conv, b: bool) -> ~str {
+    pure fn conv_bool(cv: Conv, b: bool) -> ~str {
         let s = if b { ~"true" } else { ~"false" };
         // run the boolean conversion through the string conversion logic,
         // giving it the same rules for precision, etc.
         return conv_str(cv, s);
     }
-    pure fn conv_char(cv: conv, c: char) -> ~str {
+    pure fn conv_char(cv: Conv, c: char) -> ~str {
         let mut s = str::from_char(c);
-        return unchecked { pad(cv, s, pad_nozero) };
+        return unchecked { pad(cv, s, PadNozero) };
     }
-    pure fn conv_str(cv: conv, s: &str) -> ~str {
+    pure fn conv_str(cv: Conv, s: &str) -> ~str {
         // For strings, precision is the maximum characters
         // displayed
         let mut unpadded = match cv.precision {
-          count_implied => s.to_unique(),
-          count_is(max) => if max as uint < str::char_len(s) {
+          CountImplied => s.to_unique(),
+          CountIs(max) => if max as uint < str::char_len(s) {
             str::substr(s, 0u, max as uint)
           } else {
             s.to_unique()
           }
         };
-        return unchecked { pad(cv, unpadded, pad_nozero) };
+        return unchecked { pad(cv, unpadded, PadNozero) };
     }
-    pure fn conv_float(cv: conv, f: float) -> ~str {
+    pure fn conv_float(cv: Conv, f: float) -> ~str {
         let (to_str, digits) = match cv.precision {
-              count_is(c) => (float::to_str_exact, c as uint),
-              count_implied => (float::to_str, 6u)
+              CountIs(c) => (float::to_str_exact, c as uint),
+              CountImplied => (float::to_str, 6u)
         };
         let mut s = unchecked { to_str(f, digits) };
         if 0.0 <= f {
@@ -537,9 +534,9 @@ mod rt {
                 s = ~" " + s;
             }
         }
-        return unchecked { pad(cv, s, pad_float) };
+        return unchecked { pad(cv, s, PadFloat) };
     }
-    pure fn conv_poly<T>(cv: conv, v: T) -> ~str {
+    pure fn conv_poly<T>(cv: Conv, v: T) -> ~str {
         let s = sys::log_str(v);
         return conv_str(cv, s);
     }
@@ -568,35 +565,35 @@ mod rt {
                 } else { move s }
             };
     }
-    pure fn get_int_precision(cv: conv) -> uint {
+    pure fn get_int_precision(cv: Conv) -> uint {
         return match cv.precision {
-              count_is(c) => c as uint,
-              count_implied => 1u
+              CountIs(c) => c as uint,
+              CountImplied => 1u
             };
     }
 
-    enum pad_mode { pad_signed, pad_unsigned, pad_nozero, pad_float }
+    enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat }
 
-    impl pad_mode: Eq {
-        pure fn eq(&&other: pad_mode) -> bool {
+    impl PadMode: Eq {
+        pure fn eq(&&other: PadMode) -> bool {
             match (self, other) {
-                (pad_signed, pad_signed) => true,
-                (pad_unsigned, pad_unsigned) => true,
-                (pad_nozero, pad_nozero) => true,
-                (pad_float, pad_float) => true,
-                (pad_signed, _) => false,
-                (pad_unsigned, _) => false,
-                (pad_nozero, _) => false,
-                (pad_float, _) => false
+                (PadSigned, PadSigned) => true,
+                (PadUnsigned, PadUnsigned) => true,
+                (PadNozero, PadNozero) => true,
+                (PadFloat, PadFloat) => true,
+                (PadSigned, _) => false,
+                (PadUnsigned, _) => false,
+                (PadNozero, _) => false,
+                (PadFloat, _) => false
             }
         }
-        pure fn ne(&&other: pad_mode) -> bool { !self.eq(other) }
+        pure fn ne(&&other: PadMode) -> bool { !self.eq(other) }
     }
 
-    fn pad(cv: conv, &s: ~str, mode: pad_mode) -> ~str {
+    fn pad(cv: Conv, &s: ~str, mode: PadMode) -> ~str {
         let uwidth : uint = match cv.width {
-          count_implied => return copy s,
-          count_is(width) => {
+          CountImplied => return copy s,
+          CountIs(width) => {
               // FIXME: width should probably be uint (see Issue #1996)
               width as uint
           }
@@ -610,17 +607,17 @@ mod rt {
             return s + padstr;
         }
         let {might_zero_pad, signed} = match mode {
-          pad_nozero => {might_zero_pad:false, signed:false},
-          pad_signed => {might_zero_pad:true,  signed:true },
-          pad_float => {might_zero_pad:true,  signed:true},
-          pad_unsigned => {might_zero_pad:true,  signed:false}
+          PadNozero => {might_zero_pad:false, signed:false},
+          PadSigned => {might_zero_pad:true,  signed:true },
+          PadFloat => {might_zero_pad:true,  signed:true},
+          PadUnsigned => {might_zero_pad:true,  signed:false}
         };
-        pure fn have_precision(cv: conv) -> bool {
-            return match cv.precision { count_implied => false, _ => true };
+        pure fn have_precision(cv: Conv) -> bool {
+            return match cv.precision { CountImplied => false, _ => true };
         }
         let zero_padding = {
             if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&
-                (!have_precision(cv) || mode == pad_float) {
+                (!have_precision(cv) || mode == PadFloat) {
                 padchar = '0';
                 true
             } else {
@@ -650,7 +647,6 @@ mod rt {
     }
 }
 
-
 #[cfg(test)]
 mod test {
     #[test]

branches/dist-snap/src/libcore/pipes.rs

@@ -101,14 +101,6 @@ export recv_one, try_recv_one, send_one, try_send_one;
 // Functions used by the protocol compiler
 export rt;
 
-// XXX remove me
-#[cfg(stage0)]
-export has_buffer, buffer_header, packet;
-#[cfg(stage0)]
-export recv_packet_buffered, send_packet_buffered;
-#[cfg(stage0)]
-export send_packet, recv_packet, buffer_header;
-
 #[doc(hidden)]
 const SPIN_COUNT: uint = 0;
 
@@ -146,10 +138,6 @@ fn BufferHeader() -> BufferHeader{
     }
 }
 
-// XXX remove me
-#[cfg(stage0)]
-fn buffer_header() -> BufferHeader { BufferHeader() }
-
 // This is for protocols to associate extra data to thread around.
 #[doc(hidden)]
 type Buffer<T: Send> = {
@@ -212,11 +200,6 @@ type Packet<T: Send> = {
     mut payload: Option<T>,
 };
 
-// XXX remove me
-#[cfg(stage0)]
-#[allow(non_camel_case_types)]
-type packet<T: Send> = Packet<T>;
-
 #[doc(hidden)]
 trait HasBuffer {
     // XXX This should not have a trailing underscore
@@ -229,20 +212,6 @@ impl<T: Send> Packet<T>: HasBuffer {
     }
 }
 
-#[cfg(stage0)] // XXX remove me
-#[doc(hidden)]
-#[allow(non_camel_case_types)]
-trait has_buffer {
-    fn set_buffer(b: *libc::c_void);
-}
-
-#[cfg(stage0)] // XXX remove me
-impl<T: Send> packet<T>: has_buffer {
-    fn set_buffer(b: *libc::c_void) {
-        self.header.buffer = b;
-    }
-}
-
 #[doc(hidden)]
 fn mk_packet<T: Send>() -> Packet<T> {
     {
@@ -768,17 +737,6 @@ fn SendPacket<T: Send>(p: *Packet<T>) -> SendPacket<T> {
     SendPacketBuffered(p)
 }
 
-// XXX remove me
-#[cfg(stage0)]
-#[allow(non_camel_case_types)]
-type send_packet<T: Send> = SendPacket<T>;
-
-// XXX remove me
-#[cfg(stage0)]
-fn send_packet<T: Send>(p: *packet<T>) -> SendPacket<T> {
-    SendPacket(p)
-}
-
 struct SendPacketBuffered<T: Send, Tbuffer: Send> {
     mut p: Option<*Packet<T>>,
     mut buffer: Option<BufferResource<Tbuffer>>,
@@ -837,12 +795,6 @@ impl<T: Send, Tbuffer: Send> SendPacketBuffered<T, Tbuffer> {
     }
 }
 
-// XXX remove me
-#[cfg(stage0)]
-#[allow(non_camel_case_types)]
-type send_packet_buffered<T: Send, Tbuffer: Send> =
-    SendPacketBuffered<T, Tbuffer>;
-
 /// Represents the receive end of a pipe. It can receive exactly one
 /// message.
 type RecvPacket<T: Send> = RecvPacketBuffered<T, Packet<T>>;
@@ -852,17 +804,6 @@ fn RecvPacket<T: Send>(p: *Packet<T>) -> RecvPacket<T> {
     RecvPacketBuffered(p)
 }
 
-// XXX remove me
-#[cfg(stage0)]
-#[allow(non_camel_case_types)]
-type recv_packet<T: Send> = RecvPacket<T>;
-
-// XXX remove me
-#[cfg(stage0)]
-fn recv_packet<T: Send>(p: *packet<T>) -> RecvPacket<T> {
-    RecvPacket(p)
-}
-
 struct RecvPacketBuffered<T: Send, Tbuffer: Send> {
     mut p: Option<*Packet<T>>,
     mut buffer: Option<BufferResource<Tbuffer>>,
@@ -921,12 +862,6 @@ fn RecvPacketBuffered<T: Send, Tbuffer: Send>(p: *Packet<T>)
     }
 }
 
-// XXX remove me
-#[cfg(stage0)]
-#[allow(non_camel_case_types)]
-type recv_packet_buffered<T: Send, Tbuffer: Send> =
-    RecvPacketBuffered<T, Tbuffer>;
-
 #[doc(hidden)]
 fn entangle<T: Send>() -> (SendPacket<T>, RecvPacket<T>) {
     let p = packet();

branches/dist-snap/src/libsyntax/ext/fmt.rs

@@ -39,7 +39,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
    -> @ast::expr {
     fn make_path_vec(_cx: ext_ctxt, ident: @~str) -> ~[ast::ident] {
         let intr = _cx.parse_sess().interner;
-        return ~[intr.intern(@~"extfmt"), intr.intern(@~"rt2"),
+        return ~[intr.intern(@~"extfmt"), intr.intern(@~"rt"),
                  intr.intern(ident)];
     }
     fn make_rt_path_expr(cx: ext_ctxt, sp: span, nm: @~str) -> @ast::expr {