From 23d8310f0bd41a35d3fc371bc226299eb9405ff8 Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Thu, 8 Jan 2015 11:05:12 -0800
Subject: [PATCH] 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 |  2 --
 src/lib.rs        |  1 -
 src/reader.rs     | 12 +++++++-----
 src/test.rs       |  7 +++++++
 4 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/examples/basic.rs b/examples/basic.rs
index 436e50c..a08d3a2 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -1,5 +1,3 @@
-#![feature(old_orphan_check)]
-
 extern crate bincode;
 extern crate "rustc-serialize" as rustc_serialize;
 
diff --git a/src/lib.rs b/src/lib.rs
index befb969..460d9ff 100644
--- a/src/lib.rs
+++ b/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;
 
diff --git a/src/reader.rs b/src/reader.rs
index 44c8878..cdc5508 100644
--- a/src/reader.rs
+++ b/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());
diff --git a/src/test.rs b/src/test.rs
index 1dcd959..62cca5c 100644
--- a/src/test.rs
+++ b/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'));
+}