Convert int to isize, uint to usize

See rust-lang/rust#20708

Author: alkor

codegen/branchify.rs

@@ -85,14 +85,14 @@ macro_rules! branchify(
 pub fn generate_branchified_method(
         writer: &mut Writer,
         branches: Vec<ParseBranch>,
-        indent: uint,
+        indent: usize,
         read_call: &str,
         end: &str,
         max_len: &str,
         valid: &str,
         unknown: &str) -> IoResult<()> {
 
-    fn r(writer: &mut Writer, branch: &ParseBranch, prefix: &str, indent: uint, read_call: &str,
+    fn r(writer: &mut Writer, branch: &ParseBranch, prefix: &str, indent: usize, read_call: &str,
             end: &str, max_len: &str, valid: &str, unknown: &str) -> IoResult<()> {
         let indentstr = repeat(' ').take(indent * 4).collect::<String>();
         macro_rules! w (

codegen/status.rs

@@ -23,18 +23,18 @@ enum HeadingOrStatus {
 
 #[derive(Copy)]
 struct HttpStatus {
-    code: uint,
+    code: usize,
     reason: &'static str,
     comment: Option<&'static str>,
 }
 
 /// Status with comment
-fn status_c(code: uint, reason: &'static str, comment: &'static str) -> HeadingOrStatus {
+fn status_c(code: usize, reason: &'static str, comment: &'static str) -> HeadingOrStatus {
     Status(HttpStatus { code: code, reason: reason, comment: Some(comment) })
 }
 
 /// Status without comment
-fn status_n(code: uint, reason: &'static str) -> HeadingOrStatus {
+fn status_n(code: usize, reason: &'static str) -> HeadingOrStatus {
     Status(HttpStatus { code: code, reason: reason, comment: None })
 }
 
@@ -74,8 +74,8 @@ fn camel_case(msg: &str) -> String {
     result
 }
 
-static mut longest_ident: uint = 0;
-static mut longest_reason: uint = 0;
+static mut longest_ident: usize = 0;
+static mut longest_reason: usize = 0;
 
 pub fn generate(output_dir: Path) -> IoResult<()> {
     let mut out = get_writer(output_dir, "status.rs");

src/http/buffer.rs

@@ -7,19 +7,19 @@ use std::fmt::radix;
 use std::ptr;
 
 // 64KB chunks (moderately arbitrary)
-const READ_BUF_SIZE: uint = 0x10000;
-const WRITE_BUF_SIZE: uint = 0x10000;
+const READ_BUF_SIZE: usize = 0x10000;
+const WRITE_BUF_SIZE: usize = 0x10000;
 // TODO: consider removing constants and giving a buffer size in the constructor
 
 pub struct BufferedStream<T> {
     pub wrapped: T,
     pub read_buffer: Vec<u8>,
     // The current position in the buffer
-    pub read_pos: uint,
+    pub read_pos: usize,
     // The last valid position in the reader
-    pub read_max: uint,
+    pub read_max: usize,
     pub write_buffer: Vec<u8>,
-    pub write_len: uint,
+    pub write_len: usize,
 
     pub writing_chunked_body: bool,
 }
@@ -33,10 +33,10 @@ impl<T: Stream> BufferedStream<T> {
         BufferedStream {
             wrapped: stream,
             read_buffer: read_buffer,
-            read_pos: 0u,
-            read_max: 0u,
+            read_pos: 0us,
+            read_max: 0us,
             write_buffer: write_buffer,
-            write_len: 0u,
+            write_len: 0us,
             writing_chunked_body: false,
         }
     }
@@ -105,7 +105,7 @@ impl<T: Reader> Reader for BufferedStream<T> {
     ///
     /// At present, this makes no attempt to fill its buffer proactively, instead waiting until you
     /// ask.
-    fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
         if self.read_pos == self.read_max {
             // Fill the buffer, giving up if we've run out of buffered content
             try!(self.fill_buffer());
@@ -137,7 +137,7 @@ impl<T: Writer> Writer for BufferedStream<T> {
             }
         } else {
             unsafe {
-                ptr::copy_memory(self.write_buffer.as_mut_ptr().offset(self.write_len as int),
+                ptr::copy_memory(self.write_buffer.as_mut_ptr().offset(self.write_len as isize),
                     buf.as_ptr(), buf.len());
             }
 

src/http/client/response.rs

@@ -17,7 +17,7 @@ pub struct ResponseReader<S> {
     pub request: RequestWriter<S>,
 
     /// The HTTP version number; typically `(1, 1)` or, less commonly, `(1, 0)`.
-    pub version: (uint, uint),
+    pub version: (usize, usize),
 
     /// The HTTP status indicated in the response.
     pub status: Status,
@@ -129,7 +129,7 @@ impl<S: Stream> ResponseReader<S> {
 }
 
 impl<S: Stream> Reader for ResponseReader<S> {
-    fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
         self.stream.read(buf)
     }
 }

src/http/client/sslclients/none.rs

@@ -32,7 +32,7 @@ impl Connecter for NetworkStream {
 }
 
 impl Reader for NetworkStream {
-    fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
         match *self {
             NormalStream(ref mut ns) => ns.read(buf),
         }

src/http/client/sslclients/openssl.rs

@@ -35,7 +35,7 @@ impl Connecter for NetworkStream {
 }
 
 impl Reader for NetworkStream {
-    fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
         match *self {
             NormalStream(ref mut ns) => ns.read(buf),
             SslProtectedStream(ref mut ns) => ns.read(buf),

src/http/common.rs

@@ -191,7 +191,7 @@ fn test_read_http_version() {
 #[test]
 fn test_read_decimal() {
     test_reads!(decimal,
-                "0\0" => Some(0u),
+                "0\0" => Some(0us),
                 "0\0" => Some(0u8),
                 "0\0" => Some(0u64),
                 "9\0" => Some(9u8),
@@ -218,7 +218,7 @@ fn test_read_decimal() {
 #[test]
 fn test_read_hexadecimal() {
     test_reads!(hexadecimal,
-                "0\0" => Some(0u),
+                "0\0" => Some(0us),
                 "0\0" => Some(0u8),
                 "0\0" => Some(0u64),
                 "f\0" => Some(0xfu8),

src/http/headers/mod.rs

@@ -635,8 +635,8 @@ impl HeaderConvertible for String {
     }
 }
 
-impl HeaderConvertible for uint {
-    fn from_stream<R: Reader>(reader: &mut HeaderValueByteIterator<R>) -> Option<uint> {
+impl HeaderConvertible for usize {
+    fn from_stream<R: Reader>(reader: &mut HeaderValueByteIterator<R>) -> Option<usize> {
         reader.collect_to_string().parse()
     }
 
@@ -782,23 +782,23 @@ mod test {
     }
 
     #[test]
-    fn test_from_stream_uint() {
-        assert_eq!(from_stream_with_str::<uint>("foo bar"), None);
-        assert_eq!(from_stream_with_str::<uint>("-1"), None);
-        assert_eq!(from_stream_with_str("0"), Some(0u));
-        assert_eq!(from_stream_with_str("123456789"), Some(123456789u));
+    fn test_from_stream_usize() {
+        assert_eq!(from_stream_with_str::<usize>("foo bar"), None);
+        assert_eq!(from_stream_with_str::<usize>("-1"), None);
+        assert_eq!(from_stream_with_str("0"), Some(0us));
+        assert_eq!(from_stream_with_str("123456789"), Some(123456789us));
     }
 
     #[test]
-    fn test_http_value_uint() {
-        assert_eq!(0u.http_value(), String::from_str("0"));
-        assert_eq!(123456789u.http_value(), String::from_str("123456789"));
+    fn test_http_value_usize() {
+        assert_eq!(0us.http_value(), String::from_str("0"));
+        assert_eq!(123456789us.http_value(), String::from_str("123456789"));
     }
 
     #[test]
-    fn test_to_stream_uint() {
-        assert_eq!(to_stream_into_str(&0u), String::from_str("0"));
-        assert_eq!(to_stream_into_str(&123456789u), String::from_str("123456789"));
+    fn test_to_stream_usize() {
+        assert_eq!(to_stream_into_str(&0us), String::from_str("0"));
+        assert_eq!(to_stream_into_str(&123456789us), String::from_str("123456789"));
     }
 
     fn sample_tm() -> Tm {
@@ -965,7 +965,7 @@ macro_rules! headers_mod {
             }
 
             pub struct HeaderCollectionIterator<'a> {
-                pos: uint,
+                pos: usize,
                 coll: &'a HeaderCollection,
                 ext_iter: Option<Iter<'a, String, String>>
             }
@@ -1078,7 +1078,7 @@ headers_mod! {
     19, "If-None-Match",       "if-none-match",       IfNoneMatch,        if_none_match,       String,
     20, "If-Range",            "if-range",            IfRange,            if_range,            String,
     21, "If-Unmodified-Since", "if-unmodified-since", IfUnmodifiedSince,  if_unmodified_since, time::Tm,
-    22, "Max-Forwards",        "max-forwards",        MaxForwards,        max_forwards,        uint,
+    22, "Max-Forwards",        "max-forwards",        MaxForwards,        max_forwards,        usize,
     23, "Proxy-Authorization", "proxy-authorization", ProxyAuthorization, proxy_authorization, String,
     24, "Range",               "range",               Range,              range,               String,
     25, "Referer",             "referer",             Referer,            referer,             String,
@@ -1089,7 +1089,7 @@ headers_mod! {
     28, "Allow",            "allow",            Allow,           allow,            Vec<::method::Method>,
     29, "Content-Encoding", "content-encoding", ContentEncoding, content_encoding, String,
     30, "Content-Language", "content-language", ContentLanguage, content_language, String,
-    31, "Content-Length",   "content-length",   ContentLength,   content_length,   uint,
+    31, "Content-Length",   "content-length",   ContentLength,   content_length,   usize,
     32, "Content-Location", "content-location", ContentLocation, content_location, String,
     33, "Content-MD5",      "content-md5",      ContentMd5,      content_md5,      String,
     34, "Content-Range",    "content-range",    ContentRange,    content_range,    String,
@@ -1131,7 +1131,7 @@ headers_mod! {
     19, "Allow",            "allow",            Allow,           allow,            Vec<::method::Method>,
     20, "Content-Encoding", "content-encoding", ContentEncoding, content_encoding, String,
     21, "Content-Language", "content-language", ContentLanguage, content_language, String,
-    22, "Content-Length",   "content-length",   ContentLength,   content_length,   uint,
+    22, "Content-Length",   "content-length",   ContentLength,   content_length,   usize,
     23, "Content-Location", "content-location", ContentLocation, content_location, String,
     24, "Content-MD5",      "content-md5",      ContentMd5,      content_md5,      String,
     25, "Content-Range",    "content-range",    ContentRange,    content_range,    String,

src/http/memstream.rs

@@ -28,7 +28,7 @@ impl Writer for MemWriterFakeStream {
 }
 
 impl Reader for MemWriterFakeStream {
-    fn read(&mut self, _buf: &mut [u8]) -> IoResult<uint> {
+    fn read(&mut self, _buf: &mut [u8]) -> IoResult<usize> {
         panic!("Uh oh, you didn't aught to call MemWriterFakeStream.read()!")
     }
 }
@@ -41,7 +41,7 @@ impl MemReaderFakeStream {
 }
 
 impl Reader for MemReaderFakeStream {
-    fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
         let &MemReaderFakeStream(ref mut s) = self;
         s.read(buf)
     }

src/http/server/request.rs

@@ -20,10 +20,10 @@ use self::RequestUri::{Star, AbsoluteUri, AbsolutePath, Authority};
 
 // /// Line/header can't be more than 4KB long (note that with the compacting of LWS the actual source
 // /// data could be longer than 4KB)
-// const MAX_LINE_LEN: uint = 0x1000;
+// const MAX_LINE_LEN: usize = 0x1000;
 
-const MAX_REQUEST_URI_LEN: uint = 1024;
-pub const MAX_METHOD_LEN: uint = 64;
+const MAX_REQUEST_URI_LEN: usize = 1024;
+pub const MAX_METHOD_LEN: usize = 64;
 
 pub struct RequestBuffer<'a, S: 'a> {
     /// The socket connection to read from
@@ -37,7 +37,7 @@ impl<'a, S: Stream> RequestBuffer<'a, S> {
         }
     }
 
-    pub fn read_request_line(&mut self) -> Result<(Method, RequestUri, (uint, uint)),
+    pub fn read_request_line(&mut self) -> Result<(Method, RequestUri, (usize, usize)),
                                                   status::Status> {
         let method = match self.read_method() {
             Ok(m) => m,
@@ -163,7 +163,7 @@ impl<'a, S: Stream> RequestBuffer<'a, S> {
 }
 
 impl<'a, S: Stream> Reader for RequestBuffer<'a, S> {
-    fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
         self.stream.read(buf)
     }
 }
@@ -239,7 +239,7 @@ pub struct Request {
     pub close_connection: bool,
 
     /// The HTTP version number; typically `(1, 1)` or, less commonly, `(1, 0)`.
-    pub version: (uint, uint)
+    pub version: (usize, usize)
 }
 
 /// The URI (Request-URI in RFC 2616) as specified in the Status-Line of an HTTP request
@@ -408,7 +408,7 @@ pub struct Request {
     url: ~Url,
 
     // The HTTP protocol version used; typically (1, 1)
-    protocol: (uint, uint),
+    protocol: (usize, usize),
 
     // Request headers, all nicely and correctly parsed.
     headers: ~Headers,