diff options
Diffstat (limited to 'src/libserialize/ebml.rs')
| -rw-r--r-- | src/libserialize/ebml.rs | 655 |
1 files changed, 357 insertions, 298 deletions
diff --git a/src/libserialize/ebml.rs b/src/libserialize/ebml.rs index 2b416f263c2..a6356e34af3 100644 --- a/src/libserialize/ebml.rs +++ b/src/libserialize/ebml.rs @@ -8,14 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[allow(missing_doc)]; +#![allow(missing_doc)] +use std::io; use std::str; -macro_rules! try( ($e:expr) => ( - match $e { Ok(e) => e, Err(e) => { self.last_error = Err(e); return } } -) ) - // Simple Extensible Binary Markup Language (ebml) reader and writer on a // cursor model. See the specification here: // http://www.matroska.org/technical/specs/rfc/index.html @@ -23,9 +20,9 @@ macro_rules! try( ($e:expr) => ( // Common data structures #[deriving(Clone)] pub struct Doc<'a> { - data: &'a [u8], - start: uint, - end: uint, + pub data: &'a [u8], + pub start: uint, + pub end: uint, } impl<'doc> Doc<'doc> { @@ -43,8 +40,8 @@ impl<'doc> Doc<'doc> { } pub struct TaggedDoc<'a> { - priv tag: uint, - doc: Doc<'a>, + tag: uint, + pub doc: Doc<'a>, } pub enum EbmlEncoderTag { @@ -79,6 +76,13 @@ pub enum EbmlEncoderTag { EsLabel, // Used only when debugging } + +#[deriving(Show)] +pub enum Error { + IntTooBig(uint), + Expected(~str), + IoError(io::IoError) +} // -------------------------------------- pub mod reader { @@ -94,43 +98,57 @@ pub mod reader { use super::{ EsVec, EsMap, EsEnum, EsVecLen, EsVecElt, EsMapLen, EsMapKey, EsEnumVid, EsU64, EsU32, EsU16, EsU8, EsInt, EsI64, EsI32, EsI16, EsI8, EsBool, EsF64, EsF32, EsChar, EsStr, EsMapVal, EsEnumBody, EsUint, - EsOpaque, EsLabel, EbmlEncoderTag, Doc, TaggedDoc }; + EsOpaque, EsLabel, EbmlEncoderTag, Doc, TaggedDoc, Error, IntTooBig, + Expected }; + pub type DecodeResult<T> = Result<T, Error>; // ebml reading + macro_rules! try_or( + ($e:expr, $r:expr) => ( + match $e { + Ok(e) => e, + Err(e) => { + debug!("ignored error: {}", e); + return $r + } + } + ) + ) + pub struct Res { - val: uint, - next: uint + pub val: uint, + pub next: uint } #[inline(never)] - fn vuint_at_slow(data: &[u8], start: uint) -> Res { + fn vuint_at_slow(data: &[u8], start: uint) -> DecodeResult<Res> { let a = data[start]; if a & 0x80u8 != 0u8 { - return Res {val: (a & 0x7fu8) as uint, next: start + 1u}; + return Ok(Res {val: (a & 0x7fu8) as uint, next: start + 1u}); } if a & 0x40u8 != 0u8 { - return Res {val: ((a & 0x3fu8) as uint) << 8u | + return Ok(Res {val: ((a & 0x3fu8) as uint) << 8u | (data[start + 1u] as uint), - next: start + 2u}; + next: start + 2u}); } if a & 0x20u8 != 0u8 { - return Res {val: ((a & 0x1fu8) as uint) << 16u | + return Ok(Res {val: ((a & 0x1fu8) as uint) << 16u | (data[start + 1u] as uint) << 8u | (data[start + 2u] as uint), - next: start + 3u}; + next: start + 3u}); } if a & 0x10u8 != 0u8 { - return Res {val: ((a & 0x0fu8) as uint) << 24u | + return Ok(Res {val: ((a & 0x0fu8) as uint) << 24u | (data[start + 1u] as uint) << 16u | (data[start + 2u] as uint) << 8u | (data[start + 3u] as uint), - next: start + 4u}; + next: start + 4u}); } - fail!("vint too big"); + Err(IntTooBig(a as uint)) } - pub fn vuint_at(data: &[u8], start: uint) -> Res { + pub fn vuint_at(data: &[u8], start: uint) -> DecodeResult<Res> { use std::mem::from_be32; if data.len() - start < 4 { @@ -166,10 +184,10 @@ pub mod reader { let i = (val >> 28u) as uint; let (shift, mask) = SHIFT_MASK_TABLE[i]; - Res { + Ok(Res { val: ((val >> shift) & mask) as uint, next: start + (((32 - shift) >> 3) as uint) - } + }) } } @@ -177,21 +195,21 @@ pub mod reader { Doc { data: data, start: 0u, end: data.len() } } - pub fn doc_at<'a>(data: &'a [u8], start: uint) -> TaggedDoc<'a> { - let elt_tag = vuint_at(data, start); - let elt_size = vuint_at(data, elt_tag.next); + pub fn doc_at<'a>(data: &'a [u8], start: uint) -> DecodeResult<TaggedDoc<'a>> { + let elt_tag = try!(vuint_at(data, start)); + let elt_size = try!(vuint_at(data, elt_tag.next)); let end = elt_size.next + elt_size.val; - TaggedDoc { + Ok(TaggedDoc { tag: elt_tag.val, doc: Doc { data: data, start: elt_size.next, end: end } - } + }) } pub fn maybe_get_doc<'a>(d: Doc<'a>, tg: uint) -> Option<Doc<'a>> { let mut pos = d.start; while pos < d.end { - let elt_tag = vuint_at(d.data, pos); - let elt_size = vuint_at(d.data, elt_tag.next); + let elt_tag = try_or!(vuint_at(d.data, pos), None); + let elt_size = try_or!(vuint_at(d.data, elt_tag.next), None); pos = elt_size.next + elt_size.val; if elt_tag.val == tg { return Some(Doc { data: d.data, start: elt_size.next, @@ -214,8 +232,8 @@ pub mod reader { pub fn docs<'a>(d: Doc<'a>, it: |uint, Doc<'a>| -> bool) -> bool { let mut pos = d.start; while pos < d.end { - let elt_tag = vuint_at(d.data, pos); - let elt_size = vuint_at(d.data, elt_tag.next); + let elt_tag = try_or!(vuint_at(d.data, pos), false); + let elt_size = try_or!(vuint_at(d.data, elt_tag.next), false); pos = elt_size.next + elt_size.val; let doc = Doc { data: d.data, start: elt_size.next, end: pos }; if !it(elt_tag.val, doc) { @@ -228,8 +246,8 @@ pub mod reader { pub fn tagged_docs<'a>(d: Doc<'a>, tg: uint, it: |Doc<'a>| -> bool) -> bool { let mut pos = d.start; while pos < d.end { - let elt_tag = vuint_at(d.data, pos); - let elt_size = vuint_at(d.data, elt_tag.next); + let elt_tag = try_or!(vuint_at(d.data, pos), false); + let elt_size = try_or!(vuint_at(d.data, elt_tag.next), false); pos = elt_size.next + elt_size.val; if elt_tag.val == tg { let doc = Doc { data: d.data, start: elt_size.next, @@ -273,8 +291,8 @@ pub mod reader { pub fn doc_as_i64(d: Doc) -> i64 { doc_as_u64(d) as i64 } pub struct Decoder<'a> { - priv parent: Doc<'a>, - priv pos: uint, + parent: Doc<'a>, + pos: uint, } pub fn Decoder<'a>(d: Doc<'a>) -> Decoder<'a> { @@ -285,28 +303,29 @@ pub mod reader { } impl<'doc> Decoder<'doc> { - fn _check_label(&mut self, lbl: &str) { + fn _check_label(&mut self, lbl: &str) -> DecodeResult<()> { if self.pos < self.parent.end { let TaggedDoc { tag: r_tag, doc: r_doc } = - doc_at(self.parent.data, self.pos); + try!(doc_at(self.parent.data, self.pos)); if r_tag == (EsLabel as uint) { self.pos = r_doc.end; let str = r_doc.as_str_slice(); if lbl != str { - fail!("Expected label {} but found {}", lbl, str); + return Err(Expected(format!("Expected label {} but found {}", lbl, str))); } } } + Ok(()) } - fn next_doc(&mut self, exp_tag: EbmlEncoderTag) -> Doc<'doc> { + fn next_doc(&mut self, exp_tag: EbmlEncoderTag) -> DecodeResult<Doc<'doc>> { debug!(". next_doc(exp_tag={:?})", exp_tag); if self.pos >= self.parent.end { - fail!("no more documents in current node!"); + return Err(Expected(format!("no more documents in current node!"))); } let TaggedDoc { tag: r_tag, doc: r_doc } = - doc_at(self.parent.data, self.pos); + try!(doc_at(self.parent.data, self.pos)); debug!("self.parent={}-{} self.pos={} r_tag={} r_doc={}-{}", self.parent.start, self.parent.end, @@ -315,178 +334,183 @@ pub mod reader { r_doc.start, r_doc.end); if r_tag != (exp_tag as uint) { - fail!("expected EBML doc with tag {:?} but found tag {:?}", - exp_tag, r_tag); + return Err(Expected(format!("expected EBML doc with tag {:?} but found tag {:?}", + exp_tag, r_tag))); } if r_doc.end > self.parent.end { - fail!("invalid EBML, child extends to {:#x}, parent to {:#x}", - r_doc.end, self.parent.end); + return Err(Expected(format!("invalid EBML, child extends to {:#x}, parent to {:#x}", + r_doc.end, self.parent.end))); } self.pos = r_doc.end; - r_doc + Ok(r_doc) } fn push_doc<T>(&mut self, exp_tag: EbmlEncoderTag, - f: |&mut Decoder<'doc>| -> T) -> T { - let d = self.next_doc(exp_tag); + f: |&mut Decoder<'doc>| -> DecodeResult<T>) -> DecodeResult<T> { + let d = try!(self.next_doc(exp_tag)); let old_parent = self.parent; let old_pos = self.pos; self.parent = d; self.pos = d.start; - let r = f(self); + let r = try!(f(self)); self.parent = old_parent; self.pos = old_pos; - r + Ok(r) } - fn _next_uint(&mut self, exp_tag: EbmlEncoderTag) -> uint { - let r = doc_as_u32(self.next_doc(exp_tag)); + fn _next_uint(&mut self, exp_tag: EbmlEncoderTag) -> DecodeResult<uint> { + let r = doc_as_u32(try!(self.next_doc(exp_tag))); debug!("_next_uint exp_tag={:?} result={}", exp_tag, r); - r as uint + Ok(r as uint) } - pub fn read_opaque<R>(&mut self, op: |&mut Decoder<'doc>, Doc| -> R) -> R { - let doc = self.next_doc(EsOpaque); + pub fn read_opaque<R>(&mut self, + op: |&mut Decoder<'doc>, Doc| -> DecodeResult<R>) -> DecodeResult<R> { + let doc = try!(self.next_doc(EsOpaque)); let (old_parent, old_pos) = (self.parent, self.pos); self.parent = doc; self.pos = doc.start; - let result = op(self, doc); + let result = try!(op(self, doc)); self.parent = old_parent; self.pos = old_pos; - result + Ok(result) } } - impl<'doc> serialize::Decoder for Decoder<'doc> { - fn read_nil(&mut self) -> () { () } + impl<'doc> serialize::Decoder<Error> for Decoder<'doc> { + fn read_nil(&mut self) -> DecodeResult<()> { Ok(()) } - fn read_u64(&mut self) -> u64 { doc_as_u64(self.next_doc(EsU64)) } - fn read_u32(&mut self) -> u32 { doc_as_u32(self.next_doc(EsU32)) } - fn read_u16(&mut self) -> u16 { doc_as_u16(self.next_doc(EsU16)) } - fn read_u8 (&mut self) -> u8 { doc_as_u8 (self.next_doc(EsU8 )) } - fn read_uint(&mut self) -> uint { - let v = doc_as_u64(self.next_doc(EsUint)); + fn read_u64(&mut self) -> DecodeResult<u64> { Ok(doc_as_u64(try!(self.next_doc(EsU64)))) } + fn read_u32(&mut self) -> DecodeResult<u32> { Ok(doc_as_u32(try!(self.next_doc(EsU32)))) } + fn read_u16(&mut self) -> DecodeResult<u16> { Ok(doc_as_u16(try!(self.next_doc(EsU16)))) } + fn read_u8 (&mut self) -> DecodeResult<u8 > { Ok(doc_as_u8 (try!(self.next_doc(EsU8 )))) } + fn read_uint(&mut self) -> DecodeResult<uint> { + let v = doc_as_u64(try!(self.next_doc(EsUint))); if v > (::std::uint::MAX as u64) { - fail!("uint {} too large for this architecture", v); + Err(IntTooBig(v as uint)) + } else { + Ok(v as uint) } - v as uint } - fn read_i64(&mut self) -> i64 { - doc_as_u64(self.next_doc(EsI64)) as i64 + fn read_i64(&mut self) -> DecodeResult<i64> { + Ok(doc_as_u64(try!(self.next_doc(EsI64))) as i64) } - fn read_i32(&mut self) -> i32 { - doc_as_u32(self.next_doc(EsI32)) as i32 + fn read_i32(&mut self) -> DecodeResult<i32> { + Ok(doc_as_u32(try!(self.next_doc(EsI32))) as i32) } - fn read_i16(&mut self) -> i16 { - doc_as_u16(self.next_doc(EsI16)) as i16 + fn read_i16(&mut self) -> DecodeResult<i16> { + Ok(doc_as_u16(try!(self.next_doc(EsI16))) as i16) } - fn read_i8 (&mut self) -> i8 { - doc_as_u8(self.next_doc(EsI8 )) as i8 + fn read_i8 (&mut self) -> DecodeResult<i8> { + Ok(doc_as_u8(try!(self.next_doc(EsI8 ))) as i8) } - fn read_int(&mut self) -> int { - let v = doc_as_u64(self.next_doc(EsInt)) as i64; + fn read_int(&mut self) -> DecodeResult<int> { + let v = doc_as_u64(try!(self.next_doc(EsInt))) as i64; if v > (int::MAX as i64) || v < (int::MIN as i64) { debug!("FIXME \\#6122: Removing this makes this function miscompile"); - fail!("int {} out of range for this architecture", v); + Err(IntTooBig(v as uint)) + } else { + Ok(v as int) } - v as int } - fn read_bool(&mut self) -> bool { - doc_as_u8(self.next_doc(EsBool)) != 0 + fn read_bool(&mut self) -> DecodeResult<bool> { + Ok(doc_as_u8(try!(self.next_doc(EsBool))) != 0) } - fn read_f64(&mut self) -> f64 { - let bits = doc_as_u64(self.next_doc(EsF64)); - unsafe { transmute(bits) } + fn read_f64(&mut self) -> DecodeResult<f64> { + let bits = doc_as_u64(try!(self.next_doc(EsF64))); + Ok(unsafe { transmute(bits) }) } - fn read_f32(&mut self) -> f32 { - let bits = doc_as_u32(self.next_doc(EsF32)); - unsafe { transmute(bits) } + fn read_f32(&mut self) -> DecodeResult<f32> { + let bits = doc_as_u32(try!(self.next_doc(EsF32))); + Ok(unsafe { transmute(bits) }) } - fn read_char(&mut self) -> char { - char::from_u32(doc_as_u32(self.next_doc(EsChar))).unwrap() + fn read_char(&mut self) -> DecodeResult<char> { + Ok(char::from_u32(doc_as_u32(try!(self.next_doc(EsChar)))).unwrap()) } - fn read_str(&mut self) -> ~str { - self.next_doc(EsStr).as_str() + fn read_str(&mut self) -> DecodeResult<~str> { + Ok(try!(self.next_doc(EsStr)).as_str()) } // Compound types: - fn read_enum<T>(&mut self, name: &str, f: |&mut Decoder<'doc>| -> T) -> T { + fn read_enum<T>(&mut self, + name: &str, + f: |&mut Decoder<'doc>| -> DecodeResult<T>) -> DecodeResult<T> { debug!("read_enum({})", name); - self._check_label(name); + try!(self._check_label(name)); - let doc = self.next_doc(EsEnum); + let doc = try!(self.next_doc(EsEnum)); let (old_parent, old_pos) = (self.parent, self.pos); self.parent = doc; self.pos = self.parent.start; - let result = f(self); + let result = try!(f(self)); self.parent = old_parent; self.pos = old_pos; - result + Ok(result) } fn read_enum_variant<T>(&mut self, _: &[&str], - f: |&mut Decoder<'doc>, uint| -> T) - -> T { + f: |&mut Decoder<'doc>, uint| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_enum_variant()"); - let idx = self._next_uint(EsEnumVid); + let idx = try!(self._next_uint(EsEnumVid)); debug!(" idx={}", idx); - let doc = self.next_doc(EsEnumBody); + let doc = try!(self.next_doc(EsEnumBody)); let (old_parent, old_pos) = (self.parent, self.pos); self.parent = doc; self.pos = self.parent.start; - let result = f(self, idx); + let result = try!(f(self, idx)); self.parent = old_parent; self.pos = old_pos; - result + Ok(result) } fn read_enum_variant_arg<T>(&mut self, idx: uint, - f: |&mut Decoder<'doc>| -> T) -> T { + f: |&mut Decoder<'doc>| -> DecodeResult<T>) -> DecodeResult<T> { debug!("read_enum_variant_arg(idx={})", idx); f(self) } fn read_enum_struct_variant<T>(&mut self, _: &[&str], - f: |&mut Decoder<'doc>, uint| -> T) - -> T { + f: |&mut Decoder<'doc>, uint| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_enum_struct_variant()"); - let idx = self._next_uint(EsEnumVid); + let idx = try!(self._next_uint(EsEnumVid)); debug!(" idx={}", idx); - let doc = self.next_doc(EsEnumBody); + let doc = try!(self.next_doc(EsEnumBody)); let (old_parent, old_pos) = (self.parent, self.pos); self.parent = doc; self.pos = self.parent.start; - let result = f(self, idx); + let result = try!(f(self, idx)); self.parent = old_parent; self.pos = old_pos; - result + Ok(result) } fn read_enum_struct_variant_field<T>(&mut self, name: &str, idx: uint, - f: |&mut Decoder<'doc>| -> T) - -> T { + f: |&mut Decoder<'doc>| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_enum_struct_variant_arg(name={}, idx={})", name, idx); f(self) } @@ -494,8 +518,8 @@ pub mod reader { fn read_struct<T>(&mut self, name: &str, _: uint, - f: |&mut Decoder<'doc>| -> T) - -> T { + f: |&mut Decoder<'doc>| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_struct(name={})", name); f(self) } @@ -503,85 +527,89 @@ pub mod reader { fn read_struct_field<T>(&mut self, name: &str, idx: uint, - f: |&mut Decoder<'doc>| -> T) - -> T { + f: |&mut Decoder<'doc>| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_struct_field(name={}, idx={})", name, idx); - self._check_label(name); + try!(self._check_label(name)); f(self) } - fn read_tuple<T>(&mut self, f: |&mut Decoder<'doc>, uint| -> T) -> T { + fn read_tuple<T>(&mut self, + f: |&mut Decoder<'doc>, uint| -> DecodeResult<T>) -> DecodeResult<T> { debug!("read_tuple()"); self.read_seq(f) } - fn read_tuple_arg<T>(&mut self, idx: uint, f: |&mut Decoder<'doc>| -> T) - -> T { + fn read_tuple_arg<T>(&mut self, idx: uint, f: |&mut Decoder<'doc>| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_tuple_arg(idx={})", idx); self.read_seq_elt(idx, f) } fn read_tuple_struct<T>(&mut self, name: &str, - f: |&mut Decoder<'doc>, uint| -> T) - -> T { + f: |&mut Decoder<'doc>, uint| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_tuple_struct(name={})", name); self.read_tuple(f) } fn read_tuple_struct_arg<T>(&mut self, idx: uint, - f: |&mut Decoder<'doc>| -> T) - -> T { + f: |&mut Decoder<'doc>| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_tuple_struct_arg(idx={})", idx); self.read_tuple_arg(idx, f) } - fn read_option<T>(&mut self, f: |&mut Decoder<'doc>, bool| -> T) -> T { + fn read_option<T>(&mut self, + f: |&mut Decoder<'doc>, bool| -> DecodeResult<T>) -> DecodeResult<T> { debug!("read_option()"); self.read_enum("Option", |this| { this.read_enum_variant(["None", "Some"], |this, idx| { match idx { 0 => f(this, false), 1 => f(this, true), - _ => fail!(), + _ => Err(Expected(format!("Expected None or Some"))), } }) }) } - fn read_seq<T>(&mut self, f: |&mut Decoder<'doc>, uint| -> T) -> T { + fn read_seq<T>(&mut self, + f: |&mut Decoder<'doc>, uint| -> DecodeResult<T>) -> DecodeResult<T> { debug!("read_seq()"); self.push_doc(EsVec, |d| { - let len = d._next_uint(EsVecLen); + let len = try!(d._next_uint(EsVecLen)); debug!(" len={}", len); f(d, len) }) } - fn read_seq_elt<T>(&mut self, idx: uint, f: |&mut Decoder<'doc>| -> T) - -> T { + fn read_seq_elt<T>(&mut self, idx: uint, f: |&mut Decoder<'doc>| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_seq_elt(idx={})", idx); self.push_doc(EsVecElt, f) } - fn read_map<T>(&mut self, f: |&mut Decoder<'doc>, uint| -> T) -> T { + fn read_map<T>(&mut self, + f: |&mut Decoder<'doc>, uint| -> DecodeResult<T>) -> DecodeResult<T> { debug!("read_map()"); self.push_doc(EsMap, |d| { - let len = d._next_uint(EsMapLen); + let len = try!(d._next_uint(EsMapLen)); debug!(" len={}", len); f(d, len) }) } - fn read_map_elt_key<T>(&mut self, idx: uint, f: |&mut Decoder<'doc>| -> T) - -> T { + fn read_map_elt_key<T>(&mut self, idx: uint, f: |&mut Decoder<'doc>| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_map_elt_key(idx={})", idx); self.push_doc(EsMapKey, f) } - fn read_map_elt_val<T>(&mut self, idx: uint, f: |&mut Decoder<'doc>| -> T) - -> T { + fn read_map_elt_val<T>(&mut self, idx: uint, f: |&mut Decoder<'doc>| -> DecodeResult<T>) + -> DecodeResult<T> { debug!("read_map_elt_val(idx={})", idx); self.push_doc(EsMapVal, f) } @@ -593,7 +621,6 @@ pub mod writer { use std::clone::Clone; use std::io; use std::io::{Writer, Seek}; - use std::io::MemWriter; use std::io::extensions::u64_to_be_bytes; use super::{ EsVec, EsMap, EsEnum, EsVecLen, EsVecElt, EsMapLen, EsMapKey, @@ -603,20 +630,16 @@ pub mod writer { use serialize; + + pub type EncodeResult = io::IoResult<()>; + // ebml writing - pub struct Encoder<'a> { - // FIXME(#5665): this should take a trait object. Note that if you - // delete this comment you should consider removing the - // unwrap()'s below of the results of the calls to - // write(). We're guaranteed that writing into a MemWriter - // won't fail, but this is not true for all I/O streams in - // general. - writer: &'a mut MemWriter, - priv size_positions: ~[uint], - last_error: io::IoResult<()>, + pub struct Encoder<'a, W> { + pub writer: &'a mut W, + size_positions: ~[uint], } - fn write_sized_vuint(w: &mut MemWriter, n: uint, size: uint) { + fn write_sized_vuint<W: Writer>(w: &mut W, n: uint, size: uint) -> EncodeResult { match size { 1u => w.write(&[0x80u8 | (n as u8)]), 2u => w.write(&[0x40u8 | ((n >> 8_u) as u8), n as u8]), @@ -624,129 +647,136 @@ pub mod writer { n as u8]), 4u => w.write(&[0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8, (n >> 8_u) as u8, n as u8]), - _ => fail!("vint to write too big: {}", n) - }.unwrap() + _ => Err(io::IoError { + kind: io::OtherIoError, + desc: "int too big", + detail: Some(format!("{}", n)) + }) + } } - fn write_vuint(w: &mut MemWriter, n: uint) { - if n < 0x7f_u { write_sized_vuint(w, n, 1u); return; } - if n < 0x4000_u { write_sized_vuint(w, n, 2u); return; } - if n < 0x200000_u { write_sized_vuint(w, n, 3u); return; } - if n < 0x10000000_u { write_sized_vuint(w, n, 4u); return; } - fail!("vint to write too big: {}", n); + fn write_vuint<W: Writer>(w: &mut W, n: uint) -> EncodeResult { + if n < 0x7f_u { return write_sized_vuint(w, n, 1u); } + if n < 0x4000_u { return write_sized_vuint(w, n, 2u); } + if n < 0x200000_u { return write_sized_vuint(w, n, 3u); } + if n < 0x10000000_u { return write_sized_vuint(w, n, 4u); } + Err(io::IoError { + kind: io::OtherIoError, + desc: "int too big", + detail: Some(format!("{}", n)) + }) } - pub fn Encoder<'a>(w: &'a mut MemWriter) -> Encoder<'a> { + pub fn Encoder<'a, W: Writer + Seek>(w: &'a mut W) -> Encoder<'a, W> { let size_positions: ~[uint] = ~[]; Encoder { writer: w, size_positions: size_positions, - last_error: Ok(()), } } // FIXME (#2741): Provide a function to write the standard ebml header. - impl<'a> Encoder<'a> { + impl<'a, W: Writer + Seek> Encoder<'a, W> { /// FIXME(pcwalton): Workaround for badness in trans. DO NOT USE ME. - pub unsafe fn unsafe_clone(&self) -> Encoder<'a> { + pub unsafe fn unsafe_clone(&self) -> Encoder<'a, W> { Encoder { writer: cast::transmute_copy(&self.writer), size_positions: self.size_positions.clone(), - last_error: Ok(()), } } - pub fn start_tag(&mut self, tag_id: uint) { + pub fn start_tag(&mut self, tag_id: uint) -> EncodeResult { debug!("Start tag {}", tag_id); // Write the enum ID: - write_vuint(self.writer, tag_id); + try!(write_vuint(self.writer, tag_id)); // Write a placeholder four-byte size. self.size_positions.push(try!(self.writer.tell()) as uint); let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8]; - try!(self.writer.write(zeroes)); + self.writer.write(zeroes) } - pub fn end_tag(&mut self) { + pub fn end_tag(&mut self) -> EncodeResult { let last_size_pos = self.size_positions.pop().unwrap(); let cur_pos = try!(self.writer.tell()); try!(self.writer.seek(last_size_pos as i64, io::SeekSet)); let size = cur_pos as uint - last_size_pos - 4; - write_sized_vuint(self.writer, size, 4u); - try!(self.writer.seek(cur_pos as i64, io::SeekSet)); + try!(write_sized_vuint(self.writer, size, 4u)); + let r = try!(self.writer.seek(cur_pos as i64, io::SeekSet)); debug!("End tag (size = {})", size); + Ok(r) } - pub fn wr_tag(&mut self, tag_id: uint, blk: ||) { - self.start_tag(tag_id); - blk(); - self.end_tag(); + pub fn wr_tag(&mut self, tag_id: uint, blk: || -> EncodeResult) -> EncodeResult { + try!(self.start_tag(tag_id)); + try!(blk()); + self.end_tag() } - pub fn wr_tagged_bytes(&mut self, tag_id: uint, b: &[u8]) { - write_vuint(self.writer, tag_id); - write_vuint(self.writer, b.len()); - self.writer.write(b).unwrap(); + pub fn wr_tagged_bytes(&mut self, tag_id: uint, b: &[u8]) -> EncodeResult { + try!(write_vuint(self.writer, tag_id)); + try!(write_vuint(self.writer, b.len())); + self.writer.write(b) } - pub fn wr_tagged_u64(&mut self, tag_id: uint, v: u64) { + pub fn wr_tagged_u64(&mut self, tag_id: uint, v: u64) -> EncodeResult { u64_to_be_bytes(v, 8u, |v| { - self.wr_tagged_bytes(tag_id, v); + self.wr_tagged_bytes(tag_id, v) }) } - pub fn wr_tagged_u32(&mut self, tag_id: uint, v: u32) { + pub fn wr_tagged_u32(&mut self, tag_id: uint, v: u32) -> EncodeResult{ u64_to_be_bytes(v as u64, 4u, |v| { - self.wr_tagged_bytes(tag_id, v); + self.wr_tagged_bytes(tag_id, v) }) } - pub fn wr_tagged_u16(&mut self, tag_id: uint, v: u16) { + pub fn wr_tagged_u16(&mut self, tag_id: uint, v: u16) -> EncodeResult { u64_to_be_bytes(v as u64, 2u, |v| { - self.wr_tagged_bytes(tag_id, v); + self.wr_tagged_bytes(tag_id, v) }) } - pub fn wr_tagged_u8(&mut self, tag_id: uint, v: u8) { - self.wr_tagged_bytes(tag_id, &[v]); + pub fn wr_tagged_u8(&mut self, tag_id: uint, v: u8) -> EncodeResult { + self.wr_tagged_bytes(tag_id, &[v]) } - pub fn wr_tagged_i64(&mut self, tag_id: uint, v: i64) { + pub fn wr_tagged_i64(&mut self, tag_id: uint, v: i64) -> EncodeResult { u64_to_be_bytes(v as u64, 8u, |v| { - self.wr_tagged_bytes(tag_id, v); + self.wr_tagged_bytes(tag_id, v) }) } - pub fn wr_tagged_i32(&mut self, tag_id: uint, v: i32) { + pub fn wr_tagged_i32(&mut self, tag_id: uint, v: i32) -> EncodeResult { u64_to_be_bytes(v as u64, 4u, |v| { - self.wr_tagged_bytes(tag_id, v); + self.wr_tagged_bytes(tag_id, v) }) } - pub fn wr_tagged_i16(&mut self, tag_id: uint, v: i16) { + pub fn wr_tagged_i16(&mut self, tag_id: uint, v: i16) -> EncodeResult { u64_to_be_bytes(v as u64, 2u, |v| { - self.wr_tagged_bytes(tag_id, v); + self.wr_tagged_bytes(tag_id, v) }) } - pub fn wr_tagged_i8(&mut self, tag_id: uint, v: i8) { - self.wr_tagged_bytes(tag_id, &[v as u8]); + pub fn wr_tagged_i8(&mut self, tag_id: uint, v: i8) -> EncodeResult { + self.wr_tagged_bytes(tag_id, &[v as u8]) } - pub fn wr_tagged_str(&mut self, tag_id: uint, v: &str) { - self.wr_tagged_bytes(tag_id, v.as_bytes()); + pub fn wr_tagged_str(&mut self, tag_id: uint, v: &str) -> EncodeResult { + self.wr_tagged_bytes(tag_id, v.as_bytes()) } - pub fn wr_bytes(&mut self, b: &[u8]) { + pub fn wr_bytes(&mut self, b: &[u8]) -> EncodeResult { debug!("Write {} bytes", b.len()); - self.writer.write(b).unwrap(); + self.writer.write(b) } - pub fn wr_str(&mut self, s: &str) { + pub fn wr_str(&mut self, s: &str) -> EncodeResult { debug!("Write str: {}", s); - self.writer.write(s.as_bytes()).unwrap(); + self.writer.write(s.as_bytes()) } } @@ -757,14 +787,14 @@ pub mod writer { // Totally lame approach. static DEBUG: bool = true; - impl<'a> Encoder<'a> { + impl<'a, W: Writer + Seek> Encoder<'a, W> { // used internally to emit things like the vector length and so on - fn _emit_tagged_uint(&mut self, t: EbmlEncoderTag, v: uint) { + fn _emit_tagged_uint(&mut self, t: EbmlEncoderTag, v: uint) -> EncodeResult { assert!(v <= 0xFFFF_FFFF_u); - self.wr_tagged_u32(t as uint, v as u32); + self.wr_tagged_u32(t as uint, v as u32) } - fn _emit_label(&mut self, label: &str) { + fn _emit_label(&mut self, label: &str) -> EncodeResult { // There are various strings that we have access to, such as // the name of a record field, which do not actually appear in // the encoded EBML (normally). This is just for @@ -772,89 +802,96 @@ pub mod writer { // labels and then they will be checked by decoder to // try and check failures more quickly. if DEBUG { self.wr_tagged_str(EsLabel as uint, label) } + else { Ok(()) } } - pub fn emit_opaque(&mut self, f: |&mut Encoder|) { - self.start_tag(EsOpaque as uint); - f(self); - self.end_tag(); + pub fn emit_opaque(&mut self, f: |&mut Encoder<W>| -> EncodeResult) -> EncodeResult { + try!(self.start_tag(EsOpaque as uint)); + try!(f(self)); + self.end_tag() } } - impl<'a> serialize::Encoder for Encoder<'a> { - fn emit_nil(&mut self) {} + impl<'a, W: Writer + Seek> serialize::Encoder<io::IoError> for Encoder<'a, W> { + fn emit_nil(&mut self) -> EncodeResult { + Ok(()) + } - fn emit_uint(&mut self, v: uint) { - self.wr_tagged_u64(EsUint as uint, v as u64); + fn emit_uint(&mut self, v: uint) -> EncodeResult { + self.wr_tagged_u64(EsUint as uint, v as u64) } - fn emit_u64(&mut self, v: u64) { - self.wr_tagged_u64(EsU64 as uint, v); + fn emit_u64(&mut self, v: u64) -> EncodeResult { + self.wr_tagged_u64(EsU64 as uint, v) } - fn emit_u32(&mut self, v: u32) { - self.wr_tagged_u32(EsU32 as uint, v); + fn emit_u32(&mut self, v: u32) -> EncodeResult { + self.wr_tagged_u32(EsU32 as uint, v) } - fn emit_u16(&mut self, v: u16) { - self.wr_tagged_u16(EsU16 as uint, v); + fn emit_u16(&mut self, v: u16) -> EncodeResult { + self.wr_tagged_u16(EsU16 as uint, v) } - fn emit_u8(&mut self, v: u8) { - self.wr_tagged_u8(EsU8 as uint, v); + fn emit_u8(&mut self, v: u8) -> EncodeResult { + self.wr_tagged_u8(EsU8 as uint, v) } - fn emit_int(&mut self, v: int) { - self.wr_tagged_i64(EsInt as uint, v as i64); + fn emit_int(&mut self, v: int) -> EncodeResult { + self.wr_tagged_i64(EsInt as uint, v as i64) } - fn emit_i64(&mut self, v: i64) { - self.wr_tagged_i64(EsI64 as uint, v); + fn emit_i64(&mut self, v: i64) -> EncodeResult { + self.wr_tagged_i64(EsI64 as uint, v) } - fn emit_i32(&mut self, v: i32) { - self.wr_tagged_i32(EsI32 as uint, v); + fn emit_i32(&mut self, v: i32) -> EncodeResult { + self.wr_tagged_i32(EsI32 as uint, v) } - fn emit_i16(&mut self, v: i16) { - self.wr_tagged_i16(EsI16 as uint, v); + fn emit_i16(&mut self, v: i16) -> EncodeResult { + self.wr_tagged_i16(EsI16 as uint, v) } - fn emit_i8(&mut self, v: i8) { - self.wr_tagged_i8(EsI8 as uint, v); + fn emit_i8(&mut self, v: i8) -> EncodeResult { + self.wr_tagged_i8(EsI8 as uint, v) } - fn emit_bool(&mut self, v: bool) { + fn emit_bool(&mut self, v: bool) -> EncodeResult { self.wr_tagged_u8(EsBool as uint, v as u8) } - fn emit_f64(&mut self, v: f64) { + fn emit_f64(&mut self, v: f64) -> EncodeResult { let bits = unsafe { cast::transmute(v) }; - self.wr_tagged_u64(EsF64 as uint, bits); + self.wr_tagged_u64(EsF64 as uint, bits) } - fn emit_f32(&mut self, v: f32) { + fn emit_f32(&mut self, v: f32) -> EncodeResult { let bits = unsafe { cast::transmute(v) }; - self.wr_tagged_u32(EsF32 as uint, bits); + self.wr_tagged_u32(EsF32 as uint, bits) } - fn emit_char(&mut self, v: char) { - self.wr_tagged_u32(EsChar as uint, v as u32); + fn emit_char(&mut self, v: char) -> EncodeResult { + self.wr_tagged_u32(EsChar as uint, v as u32) } - fn emit_str(&mut self, v: &str) { + fn emit_str(&mut self, v: &str) -> EncodeResult { self.wr_tagged_str(EsStr as uint, v) } - fn emit_enum(&mut self, name: &str, f: |&mut Encoder<'a>|) { - self._emit_label(name); - self.start_tag(EsEnum as uint); - f(self); - self.end_tag(); + fn emit_enum(&mut self, + name: &str, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { + try!(self._emit_label(name)); + try!(self.start_tag(EsEnum as uint)); + try!(f(self)); + self.end_tag() } fn emit_enum_variant(&mut self, _: &str, v_id: uint, _: uint, - f: |&mut Encoder<'a>|) { - self._emit_tagged_uint(EsEnumVid, v_id); - self.start_tag(EsEnumBody as uint); - f(self); - self.end_tag(); + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { + try!(self._emit_tagged_uint(EsEnumVid, v_id)); + try!(self.start_tag(EsEnumBody as uint)); + try!(f(self)); + self.end_tag() } - fn emit_enum_variant_arg(&mut self, _: uint, f: |&mut Encoder<'a>|) { + fn emit_enum_variant_arg(&mut self, + _: uint, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { f(self) } @@ -862,91 +899,113 @@ pub mod writer { v_name: &str, v_id: uint, cnt: uint, - f: |&mut Encoder<'a>|) { + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { self.emit_enum_variant(v_name, v_id, cnt, f) } fn emit_enum_struct_variant_field(&mut self, _: &str, idx: uint, - f: |&mut Encoder<'a>|) { + f: |&mut Encoder<'a, W>| -> EncodeResult) + -> EncodeResult { self.emit_enum_variant_arg(idx, f) } fn emit_struct(&mut self, _: &str, _len: uint, - f: |&mut Encoder<'a>|) { + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { f(self) } fn emit_struct_field(&mut self, name: &str, _: uint, - f: |&mut Encoder<'a>|) { - self._emit_label(name); + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { + try!(self._emit_label(name)); f(self) } - fn emit_tuple(&mut self, len: uint, f: |&mut Encoder<'a>|) { + fn emit_tuple(&mut self, + len: uint, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { self.emit_seq(len, f) } - fn emit_tuple_arg(&mut self, idx: uint, f: |&mut Encoder<'a>|) { + fn emit_tuple_arg(&mut self, + idx: uint, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { self.emit_seq_elt(idx, f) } fn emit_tuple_struct(&mut self, _: &str, len: uint, - f: |&mut Encoder<'a>|) { + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { self.emit_seq(len, f) } fn emit_tuple_struct_arg(&mut self, idx: uint, - f: |&mut Encoder<'a>|) { + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { self.emit_seq_elt(idx, f) } - fn emit_option(&mut self, f: |&mut Encoder<'a>|) { - self.emit_enum("Option", f); + fn emit_option(&mut self, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { + self.emit_enum("Option", f) } - fn emit_option_none(&mut self) { - self.emit_enum_variant("None", 0, 0, |_| ()) + fn emit_option_none(&mut self) -> EncodeResult { + self.emit_enum_variant("None", 0, 0, |_| Ok(())) } - fn emit_option_some(&mut self, f: |&mut Encoder<'a>|) { + fn emit_option_some(&mut self, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { + self.emit_enum_variant("Some", 1, 1, f) } - fn emit_seq(&mut self, len: uint, f: |&mut Encoder<'a>|) { - self.start_tag(EsVec as uint); - self._emit_tagged_uint(EsVecLen, len); - f(self); - self.end_tag(); + fn emit_seq(&mut self, + len: uint, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { + + try!(self.start_tag(EsVec as uint)); + try!(self._emit_tagged_uint(EsVecLen, len)); + try!(f(self)); + self.end_tag() } - fn emit_seq_elt(&mut self, _idx: uint, f: |&mut Encoder<'a>|) { - self.start_tag(EsVecElt as uint); - f(self); - self.end_tag(); + fn emit_seq_elt(&mut self, + _idx: uint, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { + + try!(self.start_tag(EsVecElt as uint)); + try!(f(self)); + self.end_tag() } - fn emit_map(&mut self, len: uint, f: |&mut Encoder<'a>|) { - self.start_tag(EsMap as uint); - self._emit_tagged_uint(EsMapLen, len); - f(self); - self.end_tag(); + fn emit_map(&mut self, + len: uint, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { + + try!(self.start_tag(EsMap as uint)); + try!(self._emit_tagged_uint(EsMapLen, len)); + try!(f(self)); + self.end_tag() } - fn emit_map_elt_key(&mut self, _idx: uint, f: |&mut Encoder<'a>|) { - self.start_tag(EsMapKey as uint); - f(self); - self.end_tag(); + fn emit_map_elt_key(&mut self, + _idx: uint, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { + + try!(self.start_tag(EsMapKey as uint)); + try!(f(self)); + self.end_tag() } - fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut Encoder<'a>|) { - self.start_tag(EsMapVal as uint); - f(self); - self.end_tag(); + fn emit_map_elt_val(&mut self, + _idx: uint, + f: |&mut Encoder<'a, W>| -> EncodeResult) -> EncodeResult { + try!(self.start_tag(EsMapVal as uint)); + try!(f(self)); + self.end_tag() } } } @@ -979,34 +1038,34 @@ mod tests { let mut res: reader::Res; // Class A - res = reader::vuint_at(data, 0); + res = reader::vuint_at(data, 0).unwrap(); assert_eq!(res.val, 0); assert_eq!(res.next, 1); - res = reader::vuint_at(data, res.next); + res = reader::vuint_at(data, res.next).unwrap(); assert_eq!(res.val, (1 << 7) - 1); assert_eq!(res.next, 2); // Class B - res = reader::vuint_at(data, res.next); + res = reader::vuint_at(data, res.next).unwrap(); assert_eq!(res.val, 0); assert_eq!(res.next, 4); - res = reader::vuint_at(data, res.next); + res = reader::vuint_at(data, res.next).unwrap(); assert_eq!(res.val, (1 << 14) - 1); assert_eq!(res.next, 6); // Class C - res = reader::vuint_at(data, res.next); + res = reader::vuint_at(data, res.next).unwrap(); assert_eq!(res.val, 0); assert_eq!(res.next, 9); - res = reader::vuint_at(data, res.next); + res = reader::vuint_at(data, res.next).unwrap(); assert_eq!(res.val, (1 << 21) - 1); assert_eq!(res.next, 12); // Class D - res = reader::vuint_at(data, res.next); + res = reader::vuint_at(data, res.next).unwrap(); assert_eq!(res.val, 0); assert_eq!(res.next, 16); - res = reader::vuint_at(data, res.next); + res = reader::vuint_at(data, res.next).unwrap(); assert_eq!(res.val, (1 << 28) - 1); assert_eq!(res.next, 20); } @@ -1018,11 +1077,11 @@ mod tests { let mut wr = MemWriter::new(); { let mut ebml_w = writer::Encoder(&mut wr); - v.encode(&mut ebml_w); + let _ = v.encode(&mut ebml_w); } let ebml_doc = reader::Doc(wr.get_ref()); let mut deser = reader::Decoder(ebml_doc); - let v1 = Decodable::decode(&mut deser); + let v1 = Decodable::decode(&mut deser).unwrap(); debug!("v1 == {:?}", v1); assert_eq!(v, v1); } @@ -1052,7 +1111,7 @@ mod bench { bh.iter(|| { let mut i = 0; while i < data.len() { - sum += reader::vuint_at(data, i).val; + sum += reader::vuint_at(data, i).unwrap().val; i += 4; } }); @@ -1071,7 +1130,7 @@ mod bench { bh.iter(|| { let mut i = 1; while i < data.len() { - sum += reader::vuint_at(data, i).val; + sum += reader::vuint_at(data, i).unwrap().val; i += 4; } }); @@ -1091,7 +1150,7 @@ mod bench { bh.iter(|| { let mut i = 0; while i < data.len() { - sum += reader::vuint_at(data, i).val; + sum += reader::vuint_at(data, i).unwrap().val; i += 4; } }); @@ -1111,7 +1170,7 @@ mod bench { bh.iter(|| { let mut i = 1; while i < data.len() { - sum += reader::vuint_at(data, i).val; + sum += reader::vuint_at(data, i).unwrap().val; i += 4; } }); |