uint -> u32

Author: dwrensha

compiler_tests/test.rs

@@ -205,10 +205,10 @@ mod tests {
 
         let enum_list = test_complex_list.init_enum_list(100);
 
-        for i in range::<uint>(0, 10) {
+        for i in range::<u32>(0, 10) {
             enum_list.set(i, an_enum::Qux);
         }
-        for i in range::<uint>(10, 20) {
+        for i in range::<u32>(10, 20) {
             enum_list.set(i, an_enum::Bar);
         }
 
@@ -261,10 +261,10 @@ mod tests {
 
         let complex_list_reader = test_complex_list.as_reader();
         let enum_list_reader = complex_list_reader.get_enum_list();
-        for i in range::<uint>(0,10) {
+        for i in range::<u32>(0,10) {
             assert!(enum_list_reader.get(i) == Some(an_enum::Qux));
         }
-        for i in range::<uint>(10,20) {
+        for i in range::<u32>(10,20) {
             assert!(enum_list_reader.get(i) == Some(an_enum::Bar));
         }
 

src/capnp/arena.rs

@@ -15,7 +15,7 @@ pub type SegmentId = u32;
 pub struct SegmentReader {
     pub arena : ArenaPtr,
     pub ptr : *const Word,
-    pub size : WordCount
+    pub size : WordCount32
 }
 
 impl SegmentReader {
@@ -45,7 +45,7 @@ impl SegmentBuilder {
     pub fn new(arena : *mut BuilderArena,
                id : SegmentId,
                ptr : *mut Word,
-               size : WordCount) -> SegmentBuilder {
+               size : WordCount32) -> SegmentBuilder {
         SegmentBuilder {
             reader : SegmentReader {
                 arena : BuilderArenaPtr(arena),
@@ -57,21 +57,21 @@ impl SegmentBuilder {
         }
     }
 
-    pub fn get_word_offset_to(&mut self, ptr : *mut Word) -> WordCount {
+    pub fn get_word_offset_to(&mut self, ptr : *mut Word) -> WordCount32 {
         let this_addr : uint = self.reader.ptr.to_uint();
         let ptr_addr : uint = ptr.to_uint();
         assert!(ptr_addr >= this_addr);
         let result = (ptr_addr - this_addr) / BYTES_PER_WORD;
-        return result;
+        return result as u32;
     }
 
     #[inline]
-    pub fn current_size(&self) -> WordCount {
-        ptr_sub(self.pos, self.reader.ptr)
+    pub fn current_size(&self) -> WordCount32 {
+        ptr_sub(self.pos, self.reader.ptr) as u32
     }
 
     #[inline]
-    pub fn allocate(&mut self, amount : WordCount) -> Option<*mut Word> {
+    pub fn allocate(&mut self, amount : WordCount32) -> Option<*mut Word> {
         if amount > self.reader.size - self.current_size() {
             return None;
         } else {
@@ -82,7 +82,7 @@ impl SegmentBuilder {
     }
 
     #[inline]
-    pub fn get_ptr_unchecked(&self, offset : WordCount) -> *mut Word {
+    pub fn get_ptr_unchecked(&self, offset : WordCount32) -> *mut Word {
         unsafe {
             ::std::mem::transmute(self.reader.ptr.offset(offset as int))
         }
@@ -119,7 +119,7 @@ impl ReaderArena {
             segment0 : SegmentReader {
                 arena : Null,
                 ptr : unsafe { segments[0].unsafe_get(0) },
-                size : segments[0].len()
+                size : segments[0].len() as u32
             },
             more_segments : Vec::new(),
             cap_table : Vec::new(),
@@ -137,7 +137,7 @@ impl ReaderArena {
                 let segment_reader = SegmentReader {
                     arena : arena_ptr,
                     ptr : unsafe { segment.unsafe_get(0) },
-                    size : segment.len()
+                    size : segment.len() as u32
                 };
                 more_segment_readers.push(segment_reader);
             }
@@ -167,7 +167,7 @@ pub struct BuilderArena {
     pub more_segments : Vec<Box<SegmentBuilder>>,
     pub allocation_strategy : message::AllocationStrategy,
     pub owned_memory : Vec<*mut Word>,
-    pub next_size : uint,
+    pub next_size : u32,
     pub cap_table : Vec<Option<Box<ClientHook+Send>>>,
     pub fail_fast : bool,
 }
@@ -181,7 +181,7 @@ impl Drop for BuilderArena {
 }
 
 pub enum FirstSegment<'a> {
-    NumWords(uint),
+    NumWords(u32),
     ZeroedWords(&'a mut [Word])
 }
 
@@ -191,15 +191,15 @@ impl BuilderArena {
                first_segment : FirstSegment,
                fail_fast : bool) -> Box<BuilderArena> {
 
-        let (first_segment, num_words, owned_memory) : (*mut Word, uint, Vec<*mut Word>) = unsafe {
+        let (first_segment, num_words, owned_memory) : (*mut Word, u32, Vec<*mut Word>) = unsafe {
             match first_segment {
                 NumWords(n) => {
                     let ptr = ::std::mem::transmute(
                         libc::calloc(n as libc::size_t,
                                           BYTES_PER_WORD as libc::size_t));
                     (ptr, n, vec!(ptr))
                 }
-                ZeroedWords(w) => (w.as_mut_ptr(), w.len(), Vec::new())
+                ZeroedWords(w) => (w.as_mut_ptr(), w.len() as u32, Vec::new())
             }};
 
         let mut result = box BuilderArena {
@@ -225,7 +225,7 @@ impl BuilderArena {
         result
     }
 
-    pub fn allocate_owned_memory(&mut self, minimum_size : WordCount) -> (*mut Word, WordCount) {
+    pub fn allocate_owned_memory(&mut self, minimum_size : WordCount32) -> (*mut Word, WordCount32) {
         let size = ::std::cmp::max(minimum_size, self.next_size);
         let new_words : *mut Word = unsafe {
             ::std::mem::transmute(libc::calloc(size as libc::size_t,
@@ -242,7 +242,7 @@ impl BuilderArena {
 
 
     #[inline]
-    pub fn allocate(&mut self, amount : WordCount) -> (*mut SegmentBuilder, *mut Word) {
+    pub fn allocate(&mut self, amount : WordCount32) -> (*mut SegmentBuilder, *mut Word) {
         unsafe {
             match self.segment0.allocate(amount) {
                 Some(result) => { return ((&mut self.segment0) as *mut SegmentBuilder, result) }
@@ -285,18 +285,18 @@ impl BuilderArena {
             if self.more_segments.len() == 0 {
                 ::std::slice::raw::buf_as_slice::<Word, T>(
                     self.segment0.reader.ptr,
-                    self.segment0.current_size(),
+                    self.segment0.current_size() as uint,
                     |v| cont([v]) )
             } else {
                 let mut result = Vec::new();
                 result.push(::std::mem::transmute(
                     ::std::raw::Slice { data : self.segment0.reader.ptr,
-                                      len : self.segment0.current_size()}));
+                                      len : self.segment0.current_size() as uint}));
 
                 for seg in self.more_segments.iter() {
                     result.push(::std::mem::transmute(
                         ::std::raw::Slice { data : seg.reader.ptr,
-                                          len : seg.current_size()}));
+                                            len : seg.current_size() as uint}));
                 }
                 cont(result.as_slice())
             }

src/capnp/blob.rs

@@ -12,11 +12,11 @@ pub mod text {
     static EMPTY : &'static str = "";
 
     // len does not include the required null terminator at the end
-    pub fn new_reader<'a>(p : *const u8, len : uint) -> Option<Reader<'a>> {
+    pub fn new_reader<'a>(p : *const u8, len : u32) -> Option<Reader<'a>> {
         // XXX The empty case is special and I don't know why.
         if len == 0 { return Some(EMPTY); }
         let v : &'a [u8] =
-            unsafe { std::mem::transmute(std::raw::Slice { data: p, len: len }) };
+            unsafe { std::mem::transmute(std::raw::Slice { data: p, len: len as uint}) };
         std::str::from_utf8(v)
     }
 
@@ -27,8 +27,8 @@ pub mod text {
 
     impl <'a> Builder <'a> {
 
-        pub fn new<'b>(p : *mut u8, len : uint) -> Builder<'b> {
-            Builder { ptr : p, len : len}
+        pub fn new<'b>(p : *mut u8, len : u32) -> Builder<'b> {
+            Builder { ptr : p, len : len as uint}
         }
 
         pub fn as_mut_bytes(&self) -> &'a mut [u8] {
@@ -47,18 +47,18 @@ pub mod data {
 
     pub type Reader<'a> = &'a [u8];
 
-    pub fn new_reader<'a>(p : *const u8, len : uint) -> Reader<'a> {
+    pub fn new_reader<'a>(p : *const u8, len : u32) -> Reader<'a> {
         unsafe {
-            let v = std::raw::Slice { data: p, len: len };
+            let v = std::raw::Slice { data: p, len: len as uint};
             std::mem::transmute(v)
         }
     }
 
     pub type Builder<'a> = &'a mut [u8];
 
-    pub fn new_builder<'a>(p : *mut u8, len : uint) -> Builder<'a> {
+    pub fn new_builder<'a>(p : *mut u8, len : u32) -> Builder<'a> {
         unsafe {
-            let v = std::raw::Slice { data: p as *const u8, len: len };
+            let v = std::raw::Slice { data: p as *const u8, len: len as uint};
             std::mem::transmute(v)
         }
     }

src/capnp/common.rs

@@ -72,7 +72,7 @@ pub fn allocate_zeroed_words(size : WordCount) -> ::std::vec::Vec<Word> {
 pub struct MessageSize {
     //# Size of a message. Every struct type has a method `.total_size()` that returns this.
     pub word_count : u64,
-    pub cap_count : uint
+    pub cap_count : u32
 }
 
 impl MessageSize {