core: Remove old template files

src/libcore/core.rc

@@ -46,52 +46,52 @@ Implicitly, all crates behave as if they included the following prologue:
 
 /// Operations and constants for `int`
 #[path = "int-template.rs"]
-#[merge = "int-template/intb.rs"]
+#[merge = "int-template/int.rs"]
 pub mod int;
 
 /// Operations and constants for `i8`
 #[path = "int-template.rs"]
-#[merge = "int-template/i8b.rs"]
+#[merge = "int-template/i8.rs"]
 pub mod i8;
 
 /// Operations and constants for `i16`
 #[path = "int-template.rs"]
-#[merge = "int-template/i16b.rs"]
+#[merge = "int-template/i16.rs"]
 pub mod i16;
 
 /// Operations and constants for `i32`
 #[path = "int-template.rs"]
-#[merge = "int-template/i32b.rs"]
+#[merge = "int-template/i32.rs"]
 pub mod i32;
 
 /// Operations and constants for `i64`
 #[path = "int-template.rs"]
-#[merge = "int-template/i64b.rs"]
+#[merge = "int-template/i64.rs"]
 pub mod i64;
 
 /// Operations and constants for `uint`
 #[path = "uint-template.rs"]
-#[merge = "uint-template/uintb.rs"]
+#[merge = "uint-template/uint.rs"]
 pub mod uint;
 
 /// Operations and constants for `u8`
 #[path = "uint-template.rs"]
-#[merge = "uint-template/u8b.rs"]
+#[merge = "uint-template/u8.rs"]
 pub mod u8;
 
 /// Operations and constants for `u16`
 #[path = "uint-template.rs"]
-#[merge = "uint-template/u16b.rs"]
+#[merge = "uint-template/u16.rs"]
 pub mod u16;
 
 /// Operations and constants for `u32`
 #[path = "uint-template.rs"]
-#[merge = "uint-template/u32b.rs"]
+#[merge = "uint-template/u32.rs"]
 pub mod u32;
 
 /// Operations and constants for `u64`
 #[path = "uint-template.rs"]
-#[merge = "uint-template/u64b.rs"]
+#[merge = "uint-template/u64.rs"]
 pub mod u64;
 
 
@@ -121,7 +121,7 @@ pub mod iter;
 pub mod logging;
 pub mod option;
 #[path="iter-trait.rs"]
-#[merge = "iter-trait/optionb.rs"]
+#[merge = "iter-trait/option.rs"]
 pub mod option_iter;
 pub mod result;
 pub mod to_str;
@@ -134,11 +134,11 @@ pub mod clone;
 
 pub mod dvec;
 #[path="iter-trait.rs"]
-#[merge = "iter-trait/dvecb.rs"]
+#[merge = "iter-trait/dvec.rs"]
 pub mod dvec_iter;
 pub mod dlist;
 #[path="iter-trait.rs"]
-#[merge = "iter-trait/dlistb.rs"]
+#[merge = "iter-trait/dlist.rs"]
 pub mod dlist_iter;
 pub mod send_map;
 

src/libcore/int-template/i16.rs

@@ -1,2 +1,4 @@
+mod inst {
     pub type T = i16;
     pub const bits: uint = u16::bits;
+}

src/libcore/int-template/i16b.rs

@@ -1,4 +0,0 @@
-mod inst {
-    pub type T = i16;
-    pub const bits: uint = u16::bits;
-}

src/libcore/int-template/i32.rs

@@ -1,2 +1,4 @@
+mod inst {
     pub type T = i32;
     pub const bits: uint = u32::bits;
+}

src/libcore/int-template/i32b.rs

@@ -1,4 +0,0 @@
-mod inst {
-    pub type T = i32;
-    pub const bits: uint = u32::bits;
-}

src/libcore/int-template/i64.rs

@@ -1,2 +1,4 @@
+mod inst {
     pub type T = i64;
     pub const bits: uint = u64::bits;
+}

src/libcore/int-template/i64b.rs

@@ -1,4 +0,0 @@
-mod inst {
-    pub type T = i64;
-    pub const bits: uint = u64::bits;
-}

src/libcore/int-template/i8.rs

@@ -1,2 +1,4 @@
+mod inst {
     pub type T = i8;
     pub const bits: uint = u8::bits;
+}

src/libcore/int-template/i8b.rs

@@ -1,4 +0,0 @@
-mod inst {
-    pub type T = i8;
-    pub const bits: uint = u8::bits;
-}

src/libcore/int-template/int.rs

@@ -1,9 +1,15 @@
+pub use inst::pow;
+
+mod inst {
     pub type T = int;
     pub const bits: uint = uint::bits;
 
     /// Returns `base` raised to the power of `exponent`
     pub fn pow(base: int, exponent: uint) -> int {
-    if exponent == 0u { return 1; } //Not mathemtically true if ~[base == 0]
+        if exponent == 0u {
+            //Not mathemtically true if ~[base == 0]
+            return 1;
+        }
         if base     == 0  { return 0; }
         let mut my_pow  = exponent;
         let mut acc     = 1;
@@ -36,3 +42,4 @@ fn test_overflows() {
         assert (min_value <= 0);
         assert (min_value + max_value + 1 == 0);
     }
+}

src/libcore/int-template/intb.rs

@@ -1,45 +0,0 @@
-pub use inst::pow;
-
-mod inst {
-    pub type T = int;
-    pub const bits: uint = uint::bits;
-
-    /// Returns `base` raised to the power of `exponent`
-    pub fn pow(base: int, exponent: uint) -> int {
-        if exponent == 0u {
-            //Not mathemtically true if ~[base == 0]
-            return 1;
-        }
-        if base     == 0  { return 0; }
-        let mut my_pow  = exponent;
-        let mut acc     = 1;
-        let mut multiplier = base;
-        while(my_pow > 0u) {
-            if my_pow % 2u == 1u {
-                acc *= multiplier;
-            }
-            my_pow     /= 2u;
-            multiplier *= multiplier;
-        }
-        return acc;
-    }
-
-    #[test]
-    fn test_pow() {
-        assert (pow(0, 0u) == 1);
-        assert (pow(0, 1u) == 0);
-        assert (pow(0, 2u) == 0);
-        assert (pow(-1, 0u) == 1);
-        assert (pow(1, 0u) == 1);
-        assert (pow(-3, 2u) == 9);
-        assert (pow(-3, 3u) == -27);
-        assert (pow(4, 9u) == 262144);
-    }
-
-    #[test]
-    fn test_overflows() {
-        assert (max_value > 0);
-        assert (min_value <= 0);
-        assert (min_value + max_value + 1 == 0);
-    }
-}

src/libcore/iter-trait/dlist.rs

@@ -1,12 +1,13 @@
+mod inst {
     #[allow(non_camel_case_types)]
     pub type IMPL_T<A> = dlist::DList<A>;
 
     /**
     * Iterates through the current contents.
     *
- * Attempts to access this dlist during iteration are allowed (to allow for
- * e.g. breadth-first search with in-place enqueues), but removing the current
- * node is forbidden.
+    * Attempts to access this dlist during iteration are allowed (to
+    * allow for e.g. breadth-first search with in-place enqueues), but
+    * removing the current node is forbidden.
     */
     pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
         let mut link = self.peek_n();
@@ -20,9 +21,11 @@ pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
             }
             if !nobe.linked ||
                 (!((nobe.prev.is_some()
-               || box::ptr_eq(*self.hd.expect(~"headless dlist?"), *nobe)) &&
-              (nobe.next.is_some()
-               || box::ptr_eq(*self.tl.expect(~"tailless dlist?"), *nobe)))) {
+                    || box::ptr_eq(*self.hd.expect(~"headless dlist?"),
+                                   *nobe))
+                   && (nobe.next.is_some()
+                    || box::ptr_eq(*self.tl.expect(~"tailless dlist?"),
+                                   *nobe)))) {
                 fail ~"Removing a dlist node during iteration is forbidden!"
             }
             link = nobe.next_link();
@@ -32,3 +35,4 @@ pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
     pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
         Some(self.len())
     }
+}

src/libcore/iter-trait/dlistb.rs

@@ -1,38 +0,0 @@
-mod inst {
-    #[allow(non_camel_case_types)]
-    pub type IMPL_T<A> = dlist::DList<A>;
-
-    /**
-    * Iterates through the current contents.
-    *
-    * Attempts to access this dlist during iteration are allowed (to
-    * allow for e.g. breadth-first search with in-place enqueues), but
-    * removing the current node is forbidden.
-    */
-    pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
-        let mut link = self.peek_n();
-        while option::is_some(&link) {
-            let nobe = option::get(link);
-            assert nobe.linked;
-            if !f(&nobe.data) { break; }
-            // Check (weakly) that the user didn't do a remove.
-            if self.size == 0 {
-                fail ~"The dlist became empty during iteration??"
-            }
-            if !nobe.linked ||
-                (!((nobe.prev.is_some()
-                    || box::ptr_eq(*self.hd.expect(~"headless dlist?"),
-                                   *nobe))
-                   && (nobe.next.is_some()
-                    || box::ptr_eq(*self.tl.expect(~"tailless dlist?"),
-                                   *nobe)))) {
-                fail ~"Removing a dlist node during iteration is forbidden!"
-            }
-            link = nobe.next_link();
-        }
-    }
-
-    pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
-        Some(self.len())
-    }
-}

src/libcore/iter-trait/dvec.rs

@@ -1,3 +1,4 @@
+mod inst {
     #[allow(non_camel_case_types)]
     pub type IMPL_T<A> = dvec::DVec<A>;
 
@@ -18,3 +19,4 @@ pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
     pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
         Some(self.len())
     }
+}

src/libcore/iter-trait/dvecb.rs

@@ -1,22 +0,0 @@
-mod inst {
-    #[allow(non_camel_case_types)]
-    pub type IMPL_T<A> = dvec::DVec<A>;
-
-    /**
-    * Iterates through the current contents.
-    *
-    * Attempts to access this dvec during iteration will fail.
-    */
-    pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
-        unsafe {
-            do self.swap |v| {
-                v.each(f);
-                move v
-            }
-        }
-    }
-
-    pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
-        Some(self.len())
-    }
-}

src/libcore/iter-trait/option.rs

@@ -1,3 +1,4 @@
+mod inst {
     #[allow(non_camel_case_types)]
     pub type IMPL_T<A> = Option<A>;
 
@@ -14,3 +15,4 @@ pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
             Some(_) => Some(1)
         }
     }
+}

src/libcore/iter-trait/optionb.rs

@@ -1,18 +0,0 @@
-mod inst {
-    #[allow(non_camel_case_types)]
-    pub type IMPL_T<A> = Option<A>;
-
-    pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
-        match *self {
-            None => (),
-            Some(ref a) => { f(a); }
-        }
-    }
-
-    pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
-        match *self {
-            None => Some(0),
-            Some(_) => Some(1)
-        }
-    }
-}

src/libcore/uint-template/u16.rs

@@ -1,2 +1,4 @@
+mod inst {
     pub type T = u16;
     pub const bits: uint = 16;
+}

src/libcore/uint-template/u16b.rs

@@ -1,4 +0,0 @@
-mod inst {
-    pub type T = u16;
-    pub const bits: uint = 16;
-}

src/libcore/uint-template/u32.rs

@@ -1,2 +1,4 @@
+mod inst {
     pub type T = u32;
     pub const bits: uint = 32;
+}

src/libcore/uint-template/u32b.rs

@@ -1,4 +0,0 @@
-mod inst {
-    pub type T = u32;
-    pub const bits: uint = 32;
-}

src/libcore/uint-template/u64.rs

@@ -1,2 +1,4 @@
+mod inst {
     pub type T = u64;
     pub const bits: uint = 64;
+}

src/libcore/uint-template/u64b.rs

@@ -1,4 +0,0 @@
-mod inst {
-    pub type T = u64;
-    pub const bits: uint = 64;
-}

src/libcore/uint-template/u8.rs

@@ -1,3 +1,6 @@
+pub use inst::is_ascii;
+
+mod inst {
     pub type T = u8;
     pub const bits: uint = 8;
 
@@ -5,3 +8,4 @@ pub const bits: uint = 8;
     // parent module so that they appear in core::u8 and not core::u8::u8;
 
     pub pure fn is_ascii(x: T) -> bool { return 0 as T == x & 128 as T; }
+}

src/libcore/uint-template/u8b.rs

@@ -1,11 +0,0 @@
-pub use inst::is_ascii;
-
-mod inst {
-    pub type T = u8;
-    pub const bits: uint = 8;
-
-    // Type-specific functions here. These must be reexported by the
-    // parent module so that they appear in core::u8 and not core::u8::u8;
-
-    pub pure fn is_ascii(x: T) -> bool { return 0 as T == x & 128 as T; }
-}

src/libcore/uint-template/uint.rs

@@ -1,3 +1,9 @@
+pub use inst::{
+    div_ceil, div_round, div_floor, iterate,
+    next_power_of_two
+};
+
+mod inst {
     pub type T = uint;
 
     #[cfg(target_arch = "x86")]
@@ -151,3 +157,4 @@ fn test_div() {
         assert(uint::div_ceil(3u, 4u)  == 1u);
         assert(uint::div_round(3u, 4u) == 1u);
     }
+}

src/libcore/uint-template/uintb.rs

@@ -1,160 +0,0 @@
-pub use inst::{
-    div_ceil, div_round, div_floor, iterate,
-    next_power_of_two
-};
-
-mod inst {
-    pub type T = uint;
-
-    #[cfg(target_arch = "x86")]
-    #[cfg(target_arch = "arm")]
-    pub const bits: uint = 32;
-
-    #[cfg(target_arch = "x86_64")]
-    pub const bits: uint = 64;
-
-    /**
-    * Divide two numbers, return the result, rounded up.
-    *
-    * # Arguments
-    *
-    * * x - an integer
-    * * y - an integer distinct from 0u
-    *
-    * # Return value
-    *
-    * The smallest integer `q` such that `x/y <= q`.
-    */
-    pub pure fn div_ceil(x: uint, y: uint) -> uint {
-        let div = x / y;
-        if x % y == 0u { div }
-        else { div + 1u }
-    }
-
-    /**
-    * Divide two numbers, return the result, rounded to the closest integer.
-    *
-    * # Arguments
-    *
-    * * x - an integer
-    * * y - an integer distinct from 0u
-    *
-    * # Return value
-    *
-    * The integer `q` closest to `x/y`.
-    */
-    pub pure fn div_round(x: uint, y: uint) -> uint {
-        let div = x / y;
-        if x % y * 2u  < y { div }
-        else { div + 1u }
-    }
-
-    /**
-    * Divide two numbers, return the result, rounded down.
-    *
-    * Note: This is the same function as `div`.
-    *
-    * # Arguments
-    *
-    * * x - an integer
-    * * y - an integer distinct from 0u
-    *
-    * # Return value
-    *
-    * The smallest integer `q` such that `x/y <= q`. This
-    * is either `x/y` or `x/y + 1`.
-    */
-    pub pure fn div_floor(x: uint, y: uint) -> uint { return x / y; }
-
-    /**
-    * Iterate over the range [`lo`..`hi`), or stop when requested
-    *
-    * # Arguments
-    *
-    * * lo - The integer at which to start the loop (included)
-    * * hi - The integer at which to stop the loop (excluded)
-    * * it - A block to execute with each consecutive integer of the range.
-    *        Return `true` to continue, `false` to stop.
-    *
-    * # Return value
-    *
-    * `true` If execution proceeded correctly, `false` if it was interrupted,
-    * that is if `it` returned `false` at any point.
-    */
-    pub pure fn iterate(lo: uint, hi: uint, it: fn(uint) -> bool) -> bool {
-        let mut i = lo;
-        while i < hi {
-            if (!it(i)) { return false; }
-            i += 1u;
-        }
-        return true;
-    }
-
-    /// Returns the smallest power of 2 greater than or equal to `n`
-    #[inline(always)]
-    pub fn next_power_of_two(n: uint) -> uint {
-        let halfbits: uint = sys::size_of::<uint>() * 4u;
-        let mut tmp: uint = n - 1u;
-        let mut shift: uint = 1u;
-        while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; }
-        return tmp + 1u;
-    }
-
-    #[test]
-    fn test_next_power_of_two() {
-        assert (uint::next_power_of_two(0u) == 0u);
-        assert (uint::next_power_of_two(1u) == 1u);
-        assert (uint::next_power_of_two(2u) == 2u);
-        assert (uint::next_power_of_two(3u) == 4u);
-        assert (uint::next_power_of_two(4u) == 4u);
-        assert (uint::next_power_of_two(5u) == 8u);
-        assert (uint::next_power_of_two(6u) == 8u);
-        assert (uint::next_power_of_two(7u) == 8u);
-        assert (uint::next_power_of_two(8u) == 8u);
-        assert (uint::next_power_of_two(9u) == 16u);
-        assert (uint::next_power_of_two(10u) == 16u);
-        assert (uint::next_power_of_two(11u) == 16u);
-        assert (uint::next_power_of_two(12u) == 16u);
-        assert (uint::next_power_of_two(13u) == 16u);
-        assert (uint::next_power_of_two(14u) == 16u);
-        assert (uint::next_power_of_two(15u) == 16u);
-        assert (uint::next_power_of_two(16u) == 16u);
-        assert (uint::next_power_of_two(17u) == 32u);
-        assert (uint::next_power_of_two(18u) == 32u);
-        assert (uint::next_power_of_two(19u) == 32u);
-        assert (uint::next_power_of_two(20u) == 32u);
-        assert (uint::next_power_of_two(21u) == 32u);
-        assert (uint::next_power_of_two(22u) == 32u);
-        assert (uint::next_power_of_two(23u) == 32u);
-        assert (uint::next_power_of_two(24u) == 32u);
-        assert (uint::next_power_of_two(25u) == 32u);
-        assert (uint::next_power_of_two(26u) == 32u);
-        assert (uint::next_power_of_two(27u) == 32u);
-        assert (uint::next_power_of_two(28u) == 32u);
-        assert (uint::next_power_of_two(29u) == 32u);
-        assert (uint::next_power_of_two(30u) == 32u);
-        assert (uint::next_power_of_two(31u) == 32u);
-        assert (uint::next_power_of_two(32u) == 32u);
-        assert (uint::next_power_of_two(33u) == 64u);
-        assert (uint::next_power_of_two(34u) == 64u);
-        assert (uint::next_power_of_two(35u) == 64u);
-        assert (uint::next_power_of_two(36u) == 64u);
-        assert (uint::next_power_of_two(37u) == 64u);
-        assert (uint::next_power_of_two(38u) == 64u);
-        assert (uint::next_power_of_two(39u) == 64u);
-    }
-
-    #[test]
-    fn test_overflows() {
-        assert (uint::max_value > 0u);
-        assert (uint::min_value <= 0u);
-        assert (uint::min_value + uint::max_value + 1u == 0u);
-    }
-
-    #[test]
-    fn test_div() {
-        assert(uint::div_floor(3u, 4u) == 0u);
-        assert(uint::div_ceil(3u, 4u)  == 1u);
-        assert(uint::div_round(3u, 4u) == 1u);
-    }
-}