---

yaml
---
r: 7071
b: refs/heads/master
c: 295df68
h: refs/heads/master
i:
  7069: 7989957
  7067: 8eec970
  7063: e3e740a
  7055: 38c79d0
  7039: 7f108c0
v: v3

Author: nikomatsakis

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 3e68803891dc384e8c3e5a24bb17700187d86cf7
+refs/heads/master: 295df68faf1e881d7fda09406f47bb99ef7f4d43

trunk/src/libcore/u32.rs

@@ -16,49 +16,6 @@ Return the maximal value for a u32
 */
 const max_value: u32 = 0xffff_ffffu32;
 
-/* Function: add */
-pure fn add(x: u32, y: u32) -> u32 { ret x + y; }
-
-/* Function: sub */
-pure fn sub(x: u32, y: u32) -> u32 { ret x - y; }
-
-/* Function: mul */
-pure fn mul(x: u32, y: u32) -> u32 { ret x * y; }
-
-/* Function: div */
-pure fn div(x: u32, y: u32) -> u32 { ret x / y; }
-
-/* Function: rem */
-pure fn rem(x: u32, y: u32) -> u32 { ret x % y; }
-
-/* Predicate: lt */
-pure fn lt(x: u32, y: u32) -> bool { ret x < y; }
-
-/* Predicate: le */
-pure fn le(x: u32, y: u32) -> bool { ret x <= y; }
-
-/* Predicate: eq */
-pure fn eq(x: u32, y: u32) -> bool { ret x == y; }
-
-/* Predicate: ne */
-pure fn ne(x: u32, y: u32) -> bool { ret x != y; }
-
-/* Predicate: ge */
-pure fn ge(x: u32, y: u32) -> bool { ret x >= y; }
-
-/* Predicate: gt */
-pure fn gt(x: u32, y: u32) -> bool { ret x > y; }
-
-/*
-Function: range
-
-Iterate over the range [`lo`..`hi`)
-*/
-fn range(lo: u32, hi: u32, it: block(u32)) {
-    let i = lo;
-    while i < hi { it(i); i += 1u32; }
-}
-
 //
 // Local Variables:
 // mode: rust

trunk/src/libcore/u64.rs

@@ -16,49 +16,6 @@ Return the maximal value for a u64
 */
 const max_value: u64 = 18446744073709551615u64;
 
-/* Function: add */
-pure fn add(x: u64, y: u64) -> u64 { ret x + y; }
-
-/* Function: sub */
-pure fn sub(x: u64, y: u64) -> u64 { ret x - y; }
-
-/* Function: mul */
-pure fn mul(x: u64, y: u64) -> u64 { ret x * y; }
-
-/* Function: div */
-pure fn div(x: u64, y: u64) -> u64 { ret x / y; }
-
-/* Function: rem */
-pure fn rem(x: u64, y: u64) -> u64 { ret x % y; }
-
-/* Predicate: lt */
-pure fn lt(x: u64, y: u64) -> bool { ret x < y; }
-
-/* Predicate: le */
-pure fn le(x: u64, y: u64) -> bool { ret x <= y; }
-
-/* Predicate: eq */
-pure fn eq(x: u64, y: u64) -> bool { ret x == y; }
-
-/* Predicate: ne */
-pure fn ne(x: u64, y: u64) -> bool { ret x != y; }
-
-/* Predicate: ge */
-pure fn ge(x: u64, y: u64) -> bool { ret x >= y; }
-
-/* Predicate: gt */
-pure fn gt(x: u64, y: u64) -> bool { ret x > y; }
-
-/*
-Function: range
-
-Iterate over the range [`lo`..`hi`)
-*/
-fn range(lo: u64, hi: u64, it: block(u64)) {
-    let i = lo;
-    while i < hi { it(i); i += 1u64; }
-}
-
 /*
 Function: to_str
 

trunk/src/libcore/uint.rs

@@ -103,13 +103,6 @@ pure fn ge(x: uint, y: uint) -> bool { ret x >= y; }
 /* Predicate: gt */
 pure fn gt(x: uint, y: uint) -> bool { ret x > y; }
 
-/*
-Function: hash
-
-Produce a uint suitable for use in a hash table
-*/
-fn hash(x: uint) -> uint { ret x; }
-
 /*
 Function: range
 

trunk/src/libcore/vec.rs

@@ -709,7 +709,7 @@ Function: enum_chars
 
 Returns a vector containing a range of chars
 */
-fn enum_chars(start: u8, end: u8) : ::u8::le(start, end) -> [char] {
+fn enum_chars(start: u8, end: u8) : u8::le(start, end) -> [char] {
     let i = start;
     let r = [];
     while i <= end { r += [i as char]; i += 1u as u8; }
@@ -879,99 +879,6 @@ mod unsafe {
     }
 }
 
-/*
-Module: u8
-*/
-mod u8 {
-    export cmp;
-    export lt, le, eq, ne, ge, gt;
-    export hash;
-
-    #[nolink]
-    #[abi = "cdecl"]
-    native mod libc {
-        fn memcmp(s1: *u8, s2: *u8, n: ctypes::size_t) -> ctypes::c_int;
-    }
-
-    /*
-    Function cmp
-
-    Bytewise string comparison
-    */
-    pure fn cmp(&&a: [u8], &&b: [u8]) -> int unsafe {
-        let a_len = len(a);
-        let b_len = len(b);
-        let n = math::min(a_len, b_len) as ctypes::size_t;
-        let r = libc::memcmp(to_ptr(a), to_ptr(b), n) as int;
-
-        if r != 0 { r } else {
-            if a_len == b_len {
-                0
-            } else if a_len < b_len {
-                -1
-            } else {
-                1
-            }
-        }
-    }
-
-    /*
-    Function: lt
-
-    Bytewise less than or equal
-    */
-    pure fn lt(&&a: [u8], &&b: [u8]) -> bool { cmp(a, b) < 0 }
-
-    /*
-    Function: le
-
-    Bytewise less than or equal
-    */
-    pure fn le(&&a: [u8], &&b: [u8]) -> bool { cmp(a, b) <= 0 }
-
-    /*
-    Function: eq
-
-    Bytewise equality
-    */
-    pure fn eq(&&a: [u8], &&b: [u8]) -> bool unsafe { cmp(a, b) == 0 }
-
-    /*
-    Function: ne
-
-    Bytewise inequality
-    */
-    pure fn ne(&&a: [u8], &&b: [u8]) -> bool unsafe { cmp(a, b) != 0 }
-
-    /*
-    Function: ge
-
-    Bytewise greater than or equal
-    */
-    pure fn ge(&&a: [u8], &&b: [u8]) -> bool { cmp(a, b) >= 0 }
-
-    /*
-    Function: gt
-
-    Bytewise greater than
-    */
-    pure fn gt(&&a: [u8], &&b: [u8]) -> bool { cmp(a, b) > 0 }
-
-    /*
-    Function: hash
-
-    String hash function
-    */
-    fn hash(&&s: [u8]) -> uint {
-        // djb hash.
-        // FIXME: replace with murmur.
-
-        let u: uint = 5381u;
-        vec::iter(s, { |c| u *= 33u; u += c as uint; });
-        ret u;
-    }
-}
-
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

trunk/src/libstd/map.rs

@@ -378,22 +378,13 @@ fn new_str_hash<V: copy>() -> hashmap<str, V> {
     ret mk_hashmap(str::hash, str::eq);
 }
 
-/*
-Function: new_bytes_hash
-
-Construct a hashmap for byte string keys
-*/
-fn new_bytes_hash<V: copy>() -> hashmap<[u8], V> {
-    ret mk_hashmap(vec::u8::hash, vec::u8::eq);
-}
-
 /*
 Function: new_int_hash
 
 Construct a hashmap for int keys
 */
 fn new_int_hash<V: copy>() -> hashmap<int, V> {
-    fn hash_int(&&x: int) -> uint { int::hash(x) }
+    fn hash_int(&&x: int) -> uint { ret x as uint; }
     fn eq_int(&&a: int, &&b: int) -> bool { ret a == b; }
     ret mk_hashmap(hash_int, eq_int);
 }
@@ -404,7 +395,7 @@ Function: new_uint_hash
 Construct a hashmap for uint keys
 */
 fn new_uint_hash<V: copy>() -> hashmap<uint, V> {
-    fn hash_uint(&&x: uint) -> uint { uint::hash(x) }
+    fn hash_uint(&&x: uint) -> uint { ret x; }
     fn eq_uint(&&a: uint, &&b: uint) -> bool { ret a == b; }
     ret mk_hashmap(hash_uint, eq_uint);
 }

trunk/src/rt/arch/i386/context.h

@@ -27,7 +27,7 @@ struct registers_t {
   uint32_t eflags;
 
   uint32_t eip;
-};
+} __attribute__((aligned(16)));
 
 extern "C" void __morestack(void *args, void *fn_ptr, uintptr_t stack_ptr);