Fix size estimation of chars.

`char` in rust is 32-bits long, but is encoded using utf-8.  Previously,
bincode would assume the worst and say that chars are 4-bytes long
always, when in reality, they are often only 1 byte long.

This commit fixes that bug, adds a test for it, and does some general
cleanup in the library.

examples/basic.rs

@@ -1,5 +1,3 @@
-#![feature(old_orphan_check)]
-
 extern crate bincode;
 extern crate "rustc-serialize" as rustc_serialize;
 

src/lib.rs

@@ -1,7 +1,6 @@
 #![crate_name = "bincode"]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
-#![feature(old_orphan_check)]
 
 extern crate "rustc-serialize" as rustc_serialize;
 

src/reader.rs

@@ -1,4 +1,4 @@
-use std::io::{Buffer, Reader, IoError, IoResult, OtherIoError};
+use std::io::{Buffer, Reader, IoError};
 use std::num::{cast, NumCast};
 use std::error::{Error, FromError};
 
@@ -77,8 +77,8 @@ impl <'a, A> DecoderReader<'a, A> {
     }
 
     fn read_type<T>(&mut self) -> Result<(), DecodingError> {
-        use std::intrinsics::size_of;
-        unsafe{ self.read_bytes(size_of::<T>()) }
+        use std::mem::size_of;
+        self.read_bytes(size_of::<T>())
     }
 }
 
@@ -146,8 +146,10 @@ impl<'a, R: Reader+Buffer> Decoder for DecoderReader<'a, R> {
         self.reader.read_be_f32().map_err(wrap_io)
     }
     fn read_char(&mut self) -> DecodingResult<char> {
-        try!(self.read_type::<char>());
-        self.reader.read_char().map_err(wrap_io)
+        let c = try!(self.reader.read_char().map_err(wrap_io));
+        try!(self.read_bytes(c.len_utf8()));
+        Ok(c)
+
     }
     fn read_str(&mut self) -> DecodingResult<String> {
         let len = try!(self.read_uint());

src/test.rs

@@ -200,3 +200,10 @@ fn too_big_decode() {
     let decoded: Result<u32, _> = decode(encoded, UpperBound(4));
     assert!(decoded.is_ok());
 }
+
+#[test]
+fn too_big_char() {
+    let encoded = vec![0x41];
+    let decoded: Result<char, _> = decode(encoded, UpperBound(1));
+    assert_eq!(decoded, Ok('A'));
+}