Rust 1.0pre compat

codegen/branchify.rs

@@ -1,4 +1,4 @@
-#![macro_escape]
+#![macro_use]
 
 use std::str::Chars;
 use std::vec::Vec;
@@ -104,13 +104,13 @@ pub fn generate_branchified_method(
             let next_prefix = format!("{}{}", prefix, c as char);
             w!(format!("Ok(b'{}') => match {} {{", c as char, read_call));
             for b in branch.children.iter() {
-                try!(r(writer, b, next_prefix[], indent + 1, read_call, end, max_len, valid, unknown));
+                try!(r(writer, b, next_prefix.as_slice(), indent + 1, read_call, end, max_len, valid, unknown));
             }
             match branch.result {
                 Some(ref result) =>
                     w!(format!("    Ok(b' ') => return Ok({}),", *result)),
                 None => w!(format!("    Ok(b' ') => return Ok({}),",
-                                  unknown.replace("{}", format!("String::from_str(\"{}\")", next_prefix)[]))),
+                                  unknown.replace("{}", format!("String::from_str(\"{}\")", next_prefix).as_slice()))),
             }
             w!(format!("    Ok(b) if {} => (\"{}\", b),", valid, next_prefix));
             w!("    Ok(_) => return Err(::std::io::IoError { kind: ::std::io::OtherIoError, desc: \"bad value\", detail: None }),");

codegen/main.rs

@@ -1,4 +1,4 @@
-#![feature(macro_rules, slicing_syntax)]
+#![feature(slicing_syntax, box_syntax, int_uint)]
 
 use std::io::{File, Truncate, Write};
 use std::os;
@@ -12,7 +12,7 @@ fn main() {
     Thread::spawn(move || {
         let output_dir = Path::new(os::getenv("OUT_DIR").unwrap());
         read_method::generate(output_dir).unwrap();
-    }).detach();
+    });
 
     let output_dir = Path::new(os::getenv("OUT_DIR").unwrap());
     status::generate(output_dir).unwrap();

codegen/status.rs

@@ -45,7 +45,7 @@ impl HttpStatus {
 
     fn padded_ident(&self) -> String {
         let mut s = self.ident();
-        s.push_str(self.reason_padding_spaces()[]);
+        s.push_str(self.reason_padding_spaces().as_slice());
         s
     }
 

src/http/buffer.rs

@@ -53,7 +53,7 @@ impl<T: Reader> BufferedStream<T> {
             (0, _) => panic!("poke called when buffer is full"),
             (_, _) => self.read_pos -= 1,
         }
-        self.read_buffer[mut][self.read_pos] = byte;
+        self.read_buffer[self.read_pos] = byte;
     }
 
     #[inline]

src/http/common.rs

@@ -43,8 +43,8 @@ const ASCII_UPPER_F: u8 = b'F';
  *
  * Should everything work as designed (i.e. none of these conditions occur) a `Some` is returned.
  */
-pub fn read_decimal<R: Reader, N: UnsignedInt + NumCast + Int>
-                   (reader: &mut R, expected_end: |u8| -> bool)
+pub fn read_decimal<R: Reader, N: UnsignedInt + NumCast + Int, F: FnMut(u8) -> bool>
+                   (reader: &mut R, mut expected_end: F)
                    -> IoResult<N> {
     // Here and in `read_hexadecimal` there is the possibility of infinite sequence of zeroes. The
     // spec allows this, but it may not be a good thing to allow. It's not a particularly good
@@ -89,8 +89,8 @@ pub fn read_decimal<R: Reader, N: UnsignedInt + NumCast + Int>
  *
  * Should everything work as designed (i.e. none of these conditions occur) a `Some` is returned.
  */
-pub fn read_hexadecimal<R: Reader, N: UnsignedInt + NumCast + Int>
-                       (reader: &mut R, expected_end: |u8| -> bool)
+pub fn read_hexadecimal<R: Reader, N: UnsignedInt + NumCast + Int, F: FnMut(u8) -> bool>
+                       (reader: &mut R, mut expected_end: F)
                        -> IoResult<N> {
     let mut n: N = Int::zero();
     let mut got_content = false;
@@ -142,8 +142,8 @@ pub fn read_hexadecimal<R: Reader, N: UnsignedInt + NumCast + Int>
  * - A `Some`, if all goes well.
  */
 #[inline]
-pub fn read_http_version<R: Reader>
-                        (reader: &mut R, expected_end: |u8| -> bool)
+pub fn read_http_version<R: Reader, F: FnMut(u8) -> bool>
+                        (reader: &mut R, mut expected_end: F)
                         -> IoResult<(uint, uint)> {
     // I'd read into a [0u8, ..5], but that buffer is not guaranteed to be
     // filled, so I must read it byte by byte to guarantee correctness.
@@ -169,7 +169,7 @@ pub fn read_http_version<R: Reader>
 
 // I couldn't think what to call it. Ah well. It's just trivial syntax sugar, anyway.
 macro_rules! test_reads {
-    ($func:ident $($value:expr => $expected:expr),*) => {{
+    ($func:ident, $($value:expr => $expected:expr),*) => {{
         $(
             assert_eq!(
                 concat_idents!(read_, $func)(&mut MemReader::new($value.bytes().collect::<Vec<_>>()),
@@ -181,7 +181,7 @@ macro_rules! test_reads {
 
 #[test]
 fn test_read_http_version() {
-    test_reads!(http_version
+    test_reads!(http_version,
                 "HTTP/25.17\0" => Some((25, 17)),
                 "http/1.0\0" => Some((1, 0)),
                 "http 1.0\0" => None,
@@ -192,7 +192,7 @@ fn test_read_http_version() {
 
 #[test]
 fn test_read_decimal() {
-    test_reads!(decimal
+    test_reads!(decimal,
                 "0\0" => Some(0u),
                 "0\0" => Some(0u8),
                 "0\0" => Some(0u64),
@@ -219,7 +219,7 @@ fn test_read_decimal() {
 
 #[test]
 fn test_read_hexadecimal() {
-    test_reads!(hexadecimal
+    test_reads!(hexadecimal,
                 "0\0" => Some(0u),
                 "0\0" => Some(0u8),
                 "0\0" => Some(0u64),

src/http/lib.rs

@@ -7,14 +7,9 @@
 
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
-#![feature(default_type_params)]
-#![feature(macro_rules)]
-#![feature(phase)]
-#![feature(globs)]
-#![feature(associated_types)]
-#![feature(old_orphan_check)]
+//#![feature(old_orphan_check)]
 
-#[phase(plugin, link)] extern crate log;
+#[macro_use] extern crate log;
 extern crate url;
 extern crate time;
 extern crate collections;