Replace `0 as *const/mut T` with `ptr::null/null_mut()`

diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs
index b7bc1b4764614ac50e6f9fd32384e812ca1bbc2e..d3041eaa884b4193fea406e5b3231f9bcdd21bd3 100644 (file)
--- a/src/liballoc/heap.rs
+++ b/src/liballoc/heap.rs
@@ -280,7 +280,7 @@ pub unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
         if align <= MIN_ALIGN {
             libc::malloc(size as libc::size_t) as *mut u8
         } else {
-            let mut out = 0 as *mut libc::c_void;
+            let mut out = ptr::null();
             let ret = posix_memalign(&mut out,
                                      align as libc::size_t,
                                      size as libc::size_t);

diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs
index a166dc369cb1bfa5eb8f671a205833896fcab888..433b8aa694106d58bb9e974bb43286e0fd67d32a 100644 (file)
--- a/src/liblog/lib.rs
+++ b/src/liblog/lib.rs
@@ -179,6 +179,7 @@
 use std::io;
 use std::mem;
 use std::os;
+use std::ptr;
 use std::rt;
 use std::slice;
 use std::sync::{Once, ONCE_INIT};
@@ -436,11 +437,11 @@ fn init() {
             assert!(!DIRECTIVES.is_null());
             let _directives: Box<Vec<directive::LogDirective>> =
                 mem::transmute(DIRECTIVES);
-            DIRECTIVES = 0 as *const Vec<directive::LogDirective>;
+            DIRECTIVES = ptr::null();
 
             if !FILTER.is_null() {
                 let _filter: Box<Regex> = mem::transmute(FILTER);
-                FILTER = 0 as *const _;
+                FILTER = ptr::null();
             }
         });
     }

diff --git a/src/librustc_llvm/diagnostic.rs b/src/librustc_llvm/diagnostic.rs
index 464f9f98e7ffccae02061d41c445edf02cdac77c..db2a569cdeffa0edbae0f09bf8914215c00fa1a3 100644 (file)
--- a/src/librustc_llvm/diagnostic.rs
+++ b/src/librustc_llvm/diagnostic.rs
@@ -14,6 +14,7 @@
 pub use self::Diagnostic::*;
 
 use libc::c_char;
+use std::ptr;
 
 use {ValueRef, TwineRef, DebugLocRef, DiagnosticInfoRef};
 
@@ -52,10 +53,10 @@ unsafe fn unpack(kind: OptimizationDiagnosticKind, di: DiagnosticInfoRef)
 
         let mut opt = OptimizationDiagnostic {
             kind: kind,
-            pass_name: 0 as *const c_char,
-            function: 0 as ValueRef,
-            debug_loc: 0 as DebugLocRef,
-            message: 0 as TwineRef,
+            pass_name: ptr::null(),
+            function: ptr::null_mut(),
+            debug_loc: ptr::null_mut(),
+            message: ptr::null_mut(),
         };
 
         super::LLVMUnpackOptimizationDiagnostic(di,

diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs
index 3edb1ec48a023f00117ff00615ae6efc23a19bea..03021b7700c22b2bfc3bd354b3247514b8b0f298 100644 (file)
--- a/src/librustc_llvm/lib.rs
+++ b/src/librustc_llvm/lib.rs
@@ -51,7 +51,7 @@
 
 use std::ffi::CString;
 use std::cell::RefCell;
-use std::{raw, mem};
+use std::{raw, mem, ptr};
 use libc::{c_uint, c_ushort, uint64_t, c_int, size_t, c_char};
 use libc::{c_longlong, c_ulonglong, c_void};
 use debuginfo::{DIBuilderRef, DIDescriptor,
@@ -2260,19 +2260,18 @@ pub unsafe fn static_link_hack_this_sucks() {
     LLVMInitializePowerPCAsmPrinter();
     LLVMInitializePowerPCAsmParser();
 
-    LLVMRustSetLLVMOptions(0 as c_int,
-                                       0 as *const _);
+    LLVMRustSetLLVMOptions(0 as c_int, ptr::null());
 
-    LLVMPassManagerBuilderPopulateModulePassManager(0 as *mut _, 0 as *mut _);
-    LLVMPassManagerBuilderPopulateLTOPassManager(0 as *mut _, 0 as *mut _, False, False);
-    LLVMPassManagerBuilderPopulateFunctionPassManager(0 as *mut _, 0 as *mut _);
-    LLVMPassManagerBuilderSetOptLevel(0 as *mut _, 0 as c_uint);
-    LLVMPassManagerBuilderUseInlinerWithThreshold(0 as *mut _, 0 as c_uint);
-    LLVMWriteBitcodeToFile(0 as *mut _, 0 as *const _);
+    LLVMPassManagerBuilderPopulateModulePassManager(ptr::null_mut(), ptr::null_mut());
+    LLVMPassManagerBuilderPopulateLTOPassManager(ptr::null_mut(), ptr::null_mut(), False, False);
+    LLVMPassManagerBuilderPopulateFunctionPassManager(ptr::null_mut(), ptr::null_mut());
+    LLVMPassManagerBuilderSetOptLevel(ptr::null_mut(), 0 as c_uint);
+    LLVMPassManagerBuilderUseInlinerWithThreshold(ptr::null_mut(), 0 as c_uint);
+    LLVMWriteBitcodeToFile(ptr::null_mut(), ptr::null());
     LLVMPassManagerBuilderCreate();
-    LLVMPassManagerBuilderDispose(0 as *mut _);
+    LLVMPassManagerBuilderDispose(ptr::null_mut());
 
-    LLVMRustLinkInExternalBitcode(0 as *mut _, 0 as *const _, 0 as size_t);
+    LLVMRustLinkInExternalBitcode(ptr::null_mut(), ptr::null(), 0 as size_t);
 
     LLVMLinkInMCJIT();
     LLVMLinkInInterpreter();

diff --git a/src/librustc_trans/trans/type_.rs b/src/librustc_trans/trans/type_.rs
index 9cae142c03ac14ae6f402f6991ae43100a69e256..469d351f61a3e544b684b6f063302b6d1a90c9c1 100644 (file)
--- a/src/librustc_trans/trans/type_.rs
+++ b/src/librustc_trans/trans/type_.rs
@@ -21,6 +21,7 @@
 
 use std::ffi::CString;
 use std::mem;
+use std::ptr;
 use std::cell::RefCell;
 use std::iter::repeat;
 
@@ -296,7 +297,7 @@ pub fn field_types(&self) -> Vec<Type> {
             if n_elts == 0 {
                 return Vec::new();
             }
-            let mut elts: Vec<_> = repeat(Type { rf: 0 as TypeRef }).take(n_elts).collect();
+            let mut elts: Vec<_> = repeat(Type { rf: ptr::null_mut() }).take(n_elts).collect();
             llvm::LLVMGetStructElementTypes(self.to_ref(),
                                             elts.as_mut_ptr() as *mut TypeRef);
             elts
@@ -310,7 +311,7 @@ pub fn return_type(&self) -> Type {
     pub fn func_params(&self) -> Vec<Type> {
         unsafe {
             let n_args = llvm::LLVMCountParamTypes(self.to_ref()) as uint;
-            let mut args: Vec<_> = repeat(Type { rf: 0 as TypeRef }).take(n_args).collect();
+            let mut args: Vec<_> = repeat(Type { rf: ptr::null_mut() }).take(n_args).collect();
             llvm::LLVMGetParamTypes(self.to_ref(),
                                     args.as_mut_ptr() as *mut TypeRef);
             args

diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index 9ee2f5705b82824ebd2110814539004795037b4d..a5664b9f013776000187bec2d2b5acf7674effe7 100644 (file)
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -40,6 +40,7 @@
 use option::Option;
 use option::Option::{Some, None};
 use ops::{Deref, DerefMut, FnOnce};
+use ptr;
 use result::Result::{Ok, Err};
 use rt;
 use slice::SliceExt;
@@ -238,7 +239,7 @@ pub fn stdin() -> StdinReader {
             // Make sure to free it at exit
             rt::at_exit(|| {
                 mem::transmute::<_, Box<StdinReader>>(STDIN);
-                STDIN = 0 as *const _;
+                STDIN = ptr::null();
             });
         });
 

diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs
index 83de98fdbffee87b396f0d2e12230c1e0ec83734..ea81ed30a9c603b6b72e2ca1473c920444916cf4 100644 (file)
--- a/src/libstd/sync/mpsc/mpsc_queue.rs
+++ b/src/libstd/sync/mpsc/mpsc_queue.rs
@@ -46,6 +46,7 @@
 
 use alloc::boxed::Box;
 use core::mem;
+use core::ptr;
 use core::cell::UnsafeCell;
 
 use sync::atomic::{AtomicPtr, Ordering};
@@ -82,7 +83,7 @@ unsafe impl<T:Send> Sync for Queue<T> { }
 impl<T> Node<T> {
     unsafe fn new(v: Option<T>) -> *mut Node<T> {
         mem::transmute(box Node {
-            next: AtomicPtr::new(0 as *mut Node<T>),
+            next: AtomicPtr::new(ptr::null_mut()),
             value: v,
         })
     }

diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs
index 62a7b823ec8acd5e9df8af58cd441a084c1699ac..3331411eee7d775cc29ef57a54eeaf0c3dcb12b1 100644 (file)
--- a/src/libstd/sync/mpsc/select.rs
+++ b/src/libstd/sync/mpsc/select.rs
@@ -59,6 +59,7 @@
 use core::cell::Cell;
 use core::marker;
 use core::mem;
+use core::ptr;
 use core::uint;
 
 use sync::mpsc::{Receiver, RecvError};
@@ -130,8 +131,8 @@ impl Select {
     pub fn new() -> Select {
         Select {
             marker1: marker::NoSend,
-            head: 0 as *mut Handle<'static, ()>,
-            tail: 0 as *mut Handle<'static, ()>,
+            head: ptr::null_mut(),
+            tail: ptr::null_mut(),
             next_id: Cell::new(1),
         }
     }
@@ -144,8 +145,8 @@ pub fn new() -> Select {
     #[cfg(not(stage0))] // NOTE remove cfg after next snapshot
     pub fn new() -> Select {
         Select {
-            head: 0 as *mut Handle<'static, ()>,
-            tail: 0 as *mut Handle<'static, ()>,
+            head: ptr::null_mut(),
+            tail: ptr::null_mut(),
             next_id: Cell::new(1),
         }
     }
@@ -159,8 +160,8 @@ pub fn handle<'a, T: Send>(&'a self, rx: &'a Receiver<T>) -> Handle<'a, T> {
         Handle {
             id: id,
             selector: self,
-            next: 0 as *mut Handle<'static, ()>,
-            prev: 0 as *mut Handle<'static, ()>,
+            next: ptr::null_mut(),
+            prev: ptr::null_mut(),
             added: false,
             rx: rx,
             packet: rx,
@@ -325,8 +326,8 @@ pub unsafe fn remove(&mut self) {
             (*self.next).prev = self.prev;
         }
 
-        self.next = 0 as *mut Handle<'static, ()>;
-        self.prev = 0 as *mut Handle<'static, ()>;
+        self.next = ptr::null_mut();
+        self.prev = ptr::null_mut();
 
         self.added = false;
     }

diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs
index 34fd6bb70dc9a94fb840a5aa6e1de187fcac757c..8cd88cedf6b7dccfc03a8e23eb861ae823f7f3b5 100644 (file)
--- a/src/libstd/sync/mpsc/spsc_queue.rs
+++ b/src/libstd/sync/mpsc/spsc_queue.rs
@@ -39,6 +39,7 @@
 
 use alloc::boxed::Box;
 use core::mem;
+use core::ptr;
 use core::cell::UnsafeCell;
 
 use sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
@@ -82,7 +83,7 @@ fn new() -> *mut Node<T> {
         unsafe {
             mem::transmute(box Node {
                 value: None,
-                next: AtomicPtr::new(0 as *mut Node<T>),
+                next: AtomicPtr::new(ptr::null_mut::<Node<T>>()),
             })
         }
     }
@@ -131,7 +132,7 @@ pub fn push(&self, t: T) {
             let n = self.alloc();
             assert!((*n).value.is_none());
             (*n).value = Some(t);
-            (*n).next.store(0 as *mut Node<T>, Ordering::Relaxed);
+            (*n).next.store(ptr::null_mut(), Ordering::Relaxed);
             (**self.head.get()).next.store(n, Ordering::Release);
             *self.head.get() = n;
         }

diff --git a/src/libstd/sync/mpsc/sync.rs b/src/libstd/sync/mpsc/sync.rs
index 30304dffb75a52557db36710d0cb95b60db7c0e7..d38f14a91302fa6fde9b19dfcd819025f739dd68 100644 (file)
--- a/src/libstd/sync/mpsc/sync.rs
+++ b/src/libstd/sync/mpsc/sync.rs
@@ -40,6 +40,7 @@
 
 use vec::Vec;
 use core::mem;
+use core::ptr;
 
 use sync::atomic::{Ordering, AtomicUsize};
 use sync::mpsc::blocking::{self, WaitToken, SignalToken};
@@ -145,8 +146,8 @@ pub fn new(cap: uint) -> Packet<T> {
                 cap: cap,
                 canceled: None,
                 queue: Queue {
-                    head: 0 as *mut Node,
-                    tail: 0 as *mut Node,
+                    head: ptr::null_mut(),
+                    tail: ptr::null_mut(),
                 },
                 buf: Buffer {
                     buf: range(0, cap + if cap == 0 {1} else {0}).map(|_| None).collect(),
@@ -160,7 +161,7 @@ pub fn new(cap: uint) -> Packet<T> {
     // wait until a send slot is available, returning locked access to
     // the channel state.
     fn acquire_send_slot(&self) -> MutexGuard<State<T>> {
-        let mut node = Node { token: None, next: 0 as *mut Node };
+        let mut node = Node { token: None, next: ptr::null_mut() };
         loop {
             let mut guard = self.lock.lock().unwrap();
             // are we ready to go?
@@ -343,8 +344,8 @@ pub fn drop_port(&self) {
             Vec::new()
         };
         let mut queue = mem::replace(&mut guard.queue, Queue {
-            head: 0 as *mut Node,
-            tail: 0 as *mut Node,
+            head: ptr::null_mut(),
+            tail: ptr::null_mut(),
         });
 
         let waiter = match mem::replace(&mut guard.blocker, NoneBlocked) {
@@ -453,7 +454,7 @@ impl Queue {
     fn enqueue(&mut self, node: &mut Node) -> WaitToken {
         let (wait_token, signal_token) = blocking::tokens();
         node.token = Some(signal_token);
-        node.next = 0 as *mut Node;
+        node.next = ptr::null_mut();
 
         if self.tail.is_null() {
             self.head = node as *mut Node;
@@ -475,10 +476,10 @@ fn dequeue(&mut self) -> Option<SignalToken> {
         let node = self.head;
         self.head = unsafe { (*node).next };
         if self.head.is_null() {
-            self.tail = 0 as *mut Node;
+            self.tail = ptr::null_mut();
         }
         unsafe {
-            (*node).next = 0 as *mut Node;
+            (*node).next = ptr::null_mut();
             Some((*node).token.take().unwrap())
         }
     }

diff --git a/src/libstd/sys/common/helper_thread.rs b/src/libstd/sys/common/helper_thread.rs
index f940b6ed3682e5253257d5fbd433cfc5e894b4a0..6f6179a436e914c3c77de9384be7e6b41799ea02 100644 (file)
--- a/src/libstd/sys/common/helper_thread.rs
+++ b/src/libstd/sys/common/helper_thread.rs
@@ -24,6 +24,7 @@
 
 use cell::UnsafeCell;
 use mem;
+use ptr;
 use rt;
 use sync::{StaticMutex, StaticCondvar};
 use sync::mpsc::{channel, Sender, Receiver};
@@ -132,7 +133,7 @@ fn shutdown(&'static self) {
 
             // Close the channel by destroying it
             let chan: Box<Sender<M>> = mem::transmute(*self.chan.get());
-            *self.chan.get() = 0 as *mut Sender<M>;
+            *self.chan.get() = ptr::null_mut();
             drop(chan);
             helper_signal::signal(*self.signal.get() as helper_signal::signal);
 

diff --git a/src/libstd/sys/unix/backtrace.rs b/src/libstd/sys/unix/backtrace.rs
index 7164931c55acd0fea51d1ae90705753707282380..3340a018d9437d4123dda1fa9f79c984dc5a8082 100644 (file)
--- a/src/libstd/sys/unix/backtrace.rs
+++ b/src/libstd/sys/unix/backtrace.rs
@@ -353,7 +353,7 @@ unsafe fn init_state() -> *mut backtrace_state {
     if state.is_null() {
         return output(w, idx, addr, None)
     }
-    let mut data = 0 as *const libc::c_char;
+    let mut data = ptr::null();
     let data_addr = &mut data as *mut *const libc::c_char;
     let ret = unsafe {
         backtrace_syminfo(state, addr as libc::uintptr_t,

diff --git a/src/libstd/sys/unix/condvar.rs b/src/libstd/sys/unix/condvar.rs
index 85a65bbef508d541b92ef25d9d01a7a5e586c649..3bc414731526300d15d5fa0d0716b132c7d892f6 100644 (file)
--- a/src/libstd/sys/unix/condvar.rs
+++ b/src/libstd/sys/unix/condvar.rs
@@ -10,6 +10,7 @@
 
 use cell::UnsafeCell;
 use libc;
+use ptr;
 use std::option::Option::{Some, None};
 use sys::mutex::{self, Mutex};
 use sys::time;
@@ -62,7 +63,7 @@ pub unsafe fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool {
         // time.
         let mut sys_now = libc::timeval { tv_sec: 0, tv_usec: 0 };
         let stable_now = time::SteadyTime::now();
-        let r = ffi::gettimeofday(&mut sys_now, 0 as *mut _);
+        let r = ffi::gettimeofday(&mut sys_now, ptr::null_mut());
         debug_assert_eq!(r, 0);
 
         let seconds = NumCast::from(dur.num_seconds());

diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs
index c53f9d22790dd44de154e192b33d872bbd287ec6..dd478347f819b36d1cd0bc5a7f1632916e75675c 100644 (file)
--- a/src/libstd/sys/unix/fs.rs
+++ b/src/libstd/sys/unix/fs.rs
@@ -19,6 +19,7 @@
 use io;
 use libc::{self, c_int, c_void};
 use mem;
+use ptr;
 use sys::retry;
 use sys_common::{keep_going, eof, mkerr_libc};
 
@@ -207,7 +208,7 @@ fn prune(root: &CString, dirs: Vec<Path>) -> Vec<Path> {
 
     if dir_ptr as uint != 0 {
         let mut paths = vec!();
-        let mut entry_ptr = 0 as *mut dirent_t;
+        let mut entry_ptr = ptr::null_mut();
         while unsafe { readdir_r(dir_ptr, ptr, &mut entry_ptr) == 0 } {
             if entry_ptr.is_null() { break }
             paths.push(unsafe {

diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs
index 175c4e2e353f91044fa0453395c27f173671a870..2c25af055ee1c66c0b1cf46d35fbe2dc1b01545a 100644 (file)
--- a/src/libstd/sys/unix/os.rs
+++ b/src/libstd/sys/unix/os.rs
@@ -143,7 +143,7 @@ pub unsafe fn get_env_pairs() -> Vec<Vec<u8>> {
                os::last_os_error());
     }
     let mut result = Vec::new();
-    while *environ != 0 as *const _ {
+    while *environ != ptr::null() {
         let env_pair = ffi::c_str_to_bytes(&*environ).to_vec();
         result.push(env_pair);
         environ = environ.offset(1);

diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs
index 36bf696dba5503da7cb02b613ee782cf941be89d..0eab27de43a9f08e995a56e4ad25d555f670d127 100644 (file)
--- a/src/libstd/sys/unix/process.rs
+++ b/src/libstd/sys/unix/process.rs
@@ -251,7 +251,7 @@ fn fail(output: &mut FileDesc) -> ! {
                             fn setgroups(ngroups: libc::c_int,
                                          ptr: *const libc::c_void) -> libc::c_int;
                         }
-                        let _ = setgroups(0, 0 as *const libc::c_void);
+                        let _ = setgroups(0, ptr::null());
 
                         if libc::setuid(u as libc::uid_t) != 0 {
                             fail(&mut output);

diff --git a/src/libstd/sys/windows/backtrace.rs b/src/libstd/sys/windows/backtrace.rs
index ee2dd14955b6983ae862be709036746ac0e4f047..ce6af9fab8b3eb9245590c6e0722a81447e2dc40 100644 (file)
--- a/src/libstd/sys/windows/backtrace.rs
+++ b/src/libstd/sys/windows/backtrace.rs
@@ -327,7 +327,7 @@ macro_rules! sym{ ($e:expr, $t:ident) => (unsafe {
     let image = arch::init_frame(&mut frame, &context);
 
     // Initialize this process's symbols
-    let ret = SymInitialize(process, 0 as *mut libc::c_void, libc::TRUE);
+    let ret = SymInitialize(process, ptr::null_mut(), libc::TRUE);
     if ret != libc::TRUE { return Ok(()) }
     let _c = Cleanup { handle: process, SymCleanup: SymCleanup };
 
@@ -335,10 +335,10 @@ macro_rules! sym{ ($e:expr, $t:ident) => (unsafe {
     let mut i = 0i;
     try!(write!(w, "stack backtrace:\n"));
     while StackWalk64(image, process, thread, &mut frame, &mut context,
-                      0 as *mut libc::c_void,
-                      0 as *mut libc::c_void,
-                      0 as *mut libc::c_void,
-                      0 as *mut libc::c_void) == libc::TRUE{
+                      ptr::null_mut(),
+                      ptr::null_mut(),
+                      ptr::null_mut(),
+                      ptr::null_mut()) == libc::TRUE{
         let addr = frame.AddrPC.Offset;
         if addr == frame.AddrReturn.Offset || addr == 0 ||
            frame.AddrReturn.Offset == 0 { break }

diff --git a/src/libstd/sys/windows/thread_local.rs b/src/libstd/sys/windows/thread_local.rs
index d371023f21880ae87d1b438676d94cc9c03854ce..83c116e9b05b7c6fb43acae9bf0f71bccc6f45b0 100644 (file)
--- a/src/libstd/sys/windows/thread_local.rs
+++ b/src/libstd/sys/windows/thread_local.rs
@@ -137,7 +137,7 @@ unsafe fn init_dtors() {
     rt::at_exit(move|| {
         DTOR_LOCK.lock();
         let dtors = DTORS;
-        DTORS = 0 as *mut _;
+        DTORS = ptr::null_mut();
         mem::transmute::<_, Box<Vec<(Key, Dtor)>>>(dtors);
         assert!(DTORS.is_null()); // can't re-init after destructing
         DTOR_LOCK.unlock();
@@ -250,7 +250,7 @@ unsafe fn run_dtors() {
         for &(key, dtor) in dtors.iter() {
             let ptr = TlsGetValue(key);
             if !ptr.is_null() {
-                TlsSetValue(key, 0 as *mut _);
+                TlsSetValue(key, ptr::null_mut());
                 dtor(ptr as *mut _);
                 any_run = true;
             }

diff --git a/src/libstd/thread_local/mod.rs b/src/libstd/thread_local/mod.rs
index e7c4e4ccdfb88d0abd6e19daec1a0eff9d7dea9c..cd2a5134e3c8274da321d7e001e18d965ff6fd12 100644 (file)
--- a/src/libstd/thread_local/mod.rs
+++ b/src/libstd/thread_local/mod.rs
@@ -425,7 +425,7 @@ unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern fn(*mut u8)) {
                     dtor(ptr);
                 }
                 ptr = DTORS.get();
-                DTORS.set(0 as *mut _);
+                DTORS.set(ptr::null_mut());
             }
         }
     }
@@ -522,7 +522,7 @@ unsafe fn ptr(&'static self) -> Option<*mut T> {
         let key = ptr.key;
         key.os.set(1 as *mut u8);
         drop(ptr);
-        key.os.set(0 as *mut u8);
+        key.os.set(ptr::null_mut());
     }
 }