ctr-std: Migrate to the new liballoc API

3 files changed, 8 insertions, 27 deletions

diff --git a/ctr-std/src/collections/hash/table.rs b/ctr-std/src/collections/hash/table.rs
index eb467bd..bb0fd3c 100644
--- a/ctr-std/src/collections/hash/table.rs
+++ b/ctr-std/src/collections/hash/table.rs
@@ -10,7 +10,8 @@
 
 #![allow(deprecated)]
 
-use alloc::heap::{EMPTY, allocate, deallocate};
+use sys::alloc::Heap;
+use alloc::allocator::{Alloc,Layout};
 
 use cmp;
 use hash::{BuildHasher, Hash, Hasher};
@@ -622,7 +623,7 @@ impl<K, V> RawTable<K, V> {
             return RawTable {
                 size: 0,
                 capacity: 0,
-                hashes: Unique::new(EMPTY as *mut HashUint),
+                hashes: Unique::empty(),
                 marker: marker::PhantomData,
             };
         }
@@ -653,10 +654,8 @@ impl<K, V> RawTable<K, V> {
                     .expect("capacity overflow"),
                 "capacity overflow");
 
-        let buffer = allocate(size, alignment);
-        if buffer.is_null() {
-            ::alloc::oom()
-        }
+        let layout = Layout::from_size_align(size, alignment).expect("invalid alloc layout");
+        let buffer = Heap.alloc(layout).unwrap_or_else(|err| Heap.oom(err));
 
         let hashes = buffer.offset(hash_offset as isize) as *mut HashUint;
 
@@ -1063,7 +1062,8 @@ impl<K, V> Drop for RawTable<K, V> {
         debug_assert!(!oflo, "should be impossible");
 
         unsafe {
-            deallocate(self.hashes.as_ptr() as *mut u8, size, align);
+            let layout = Layout::from_size_align(size, align).expect("invalid alloc layout");
+            Heap.dealloc(self.hashes.as_ptr() as *mut u8, layout);
             // Remember how everything was allocated out of one buffer
             // during initialization? We only need one call to free here.
         }
diff --git a/ctr-std/src/lib.rs b/ctr-std/src/lib.rs
index 5b8c532..af14e12 100644
--- a/ctr-std/src/lib.rs
+++ b/ctr-std/src/lib.rs
@@ -1,4 +1,5 @@
 #![feature(alloc)]
+#![feature(allocator_api)]
 #![feature(alloc_system)]
 #![feature(allow_internal_unstable)]
 #![feature(box_syntax)]
diff --git a/ctr-std/src/sys/unix/mod.rs b/ctr-std/src/sys/unix/mod.rs
index df2be06..9d57045 100644
--- a/ctr-std/src/sys/unix/mod.rs
+++ b/ctr-std/src/sys/unix/mod.rs
@@ -33,8 +33,6 @@ pub mod alloc;
 
 #[cfg(not(test))]
 pub fn init() {
-    use alloc::oom;
-
     // By default, some platforms will send a *signal* when an EPIPE error
     // would otherwise be delivered. This runtime doesn't install a SIGPIPE
     // handler, causing it to kill the program, which isn't exactly what we
@@ -46,24 +44,6 @@ pub fn init() {
         reset_sigpipe();
     }
 
-    oom::set_oom_handler(oom_handler);
-
-    // A nicer handler for out-of-memory situations than the default one. This
-    // one prints a message to stderr before aborting. It is critical that this
-    // code does not allocate any memory since we are in an OOM situation. Any
-    // errors are ignored while printing since there's nothing we can do about
-    // them and we are about to exit anyways.
-    fn oom_handler() -> ! {
-        use intrinsics;
-        let msg = "fatal runtime error: out of memory\n";
-        unsafe {
-            libc::write(libc::STDERR_FILENO,
-                        msg.as_ptr() as *const libc::c_void,
-                        msg.len());
-            intrinsics::abort();
-        }
-    }
-
 	// I don't think we have signal handling on the 3DS, so let's leave this
 	// blank for now
     unsafe fn reset_sigpipe() {}