diff --git a/examples/dumpexif.rs b/examples/dumpexif.rs index 4e64e2a..312c3eb 100644 --- a/examples/dumpexif.rs +++ b/examples/dumpexif.rs @@ -41,8 +41,8 @@ fn main() { } fn dump_file(path: &Path) -> Result<(), exif::Error> { - let file = try!(File::open(path)); - let reader = try!(exif::Reader::new(&mut BufReader::new(&file))); + let file = File::open(path)?; + let reader = exif::Reader::new(&mut BufReader::new(&file))?; println!("{}", path.display()); for f in reader.fields() { diff --git a/src/jpeg.rs b/src/jpeg.rs index 910c8e3..44cef6b 100644 --- a/src/jpeg.rs +++ b/src/jpeg.rs @@ -64,18 +64,18 @@ pub fn get_exif_attr(reader: &mut R) fn get_exif_attr_sub(reader: &mut R) -> Result, Error> where R: io::BufRead { let mut soi = [0u8; 2]; - try!(reader.read_exact(&mut soi)); + reader.read_exact(&mut soi)?; if soi != [marker::P, marker::SOI] { return Err(Error::InvalidFormat("Not a JPEG file")); } loop { // Find a marker prefix. Discard non-ff bytes, which appear if // we are in the scan data after SOS or we are out of sync. - try!(reader.read_until(marker::P, &mut Vec::new())); + reader.read_until(marker::P, &mut Vec::new())?; // Get a marker code. let mut code; loop { - code = try!(read8(reader)); + code = read8(reader)?; if code != marker::P { break; } } // Continue or return early on stand-alone markers. @@ -86,12 +86,12 @@ fn get_exif_attr_sub(reader: &mut R) _ => {}, } // Read marker segments. - let seglen = try!(read16(reader)); + let seglen = read16(reader)?; if seglen < 2 { return Err(Error::InvalidFormat("Invalid segment length")); } let mut seg = Vec::new(); - try!(reader.by_ref().take(seglen as u64 - 2).read_to_end(&mut seg)); + reader.by_ref().take(seglen as u64 - 2).read_to_end(&mut seg)?; if code == marker::APP1 && seg.starts_with(&EXIF_ID) { return Ok(seg.split_off(EXIF_ID.len())); } diff --git a/src/reader.rs b/src/reader.rs index 004584e..d04613c 100644 --- a/src/reader.rs +++ b/src/reader.rs @@ -68,13 +68,13 @@ impl Reader { -> Result where R: io::BufRead { // Parse the data. let mut buf = Vec::new(); - try!(reader.by_ref().take(4).read_to_end(&mut buf)); + reader.by_ref().take(4).read_to_end(&mut buf)?; if jpeg::is_jpeg(&buf) { - let exif_buf = try!(jpeg::get_exif_attr( - &mut buf.as_mut_slice().chain(reader))); + let exif_buf = jpeg::get_exif_attr( + &mut buf.as_mut_slice().chain(reader))?; buf = exif_buf; } else if tiff::is_tiff(&buf) { - try!(reader.read_to_end(&mut buf)); + reader.read_to_end(&mut buf)?; } else { return Err(Error::InvalidFormat("Unknown image format")); } @@ -82,7 +82,7 @@ impl Reader { // Cheat on the type system and erase the lifetime by transmute(). // The scope releases the inner `v` to unborrow `buf`. let (fields, le) = { - let (v, le) = try!(tiff::parse_exif(&buf)); + let (v, le) = tiff::parse_exif(&buf)?; (unsafe { mem::transmute::, Vec>(v) }, le) }; // Initialize the HashMap of all fields. diff --git a/src/tag.rs b/src/tag.rs index f0cd127..cb5bfe6 100644 --- a/src/tag.rs +++ b/src/tag.rs @@ -652,7 +652,7 @@ fn d_exptime(w: &mut fmt::Write, value: &Value) -> fmt::Result { // FNumber (Exif 0x829d) fn d_fnumber(w: &mut fmt::Write, value: &Value) -> fmt::Result { - try!(w.write_str("f/")); + w.write_str("f/")?; d_decimal(w, value) } @@ -709,7 +709,7 @@ fn d_exifver(w: &mut fmt::Write, value: &Value) -> fmt::Result { fn d_cpntcfg(w: &mut fmt::Write, value: &Value) -> fmt::Result { if let Value::Undefined(u, _) = *value { for &x in u { - try!(match x { + match x { 0 => w.write_char('_'), 1 => w.write_char('Y'), 2 => w.write_str("Cb"), @@ -718,7 +718,7 @@ fn d_cpntcfg(w: &mut fmt::Write, value: &Value) -> fmt::Result { 5 => w.write_char('G'), 6 => w.write_char('B'), _ => w.write_char('?'), - }); + }?; } return Ok(()); } @@ -1202,7 +1202,7 @@ fn d_decimal(w: &mut fmt::Write, value: &Value) -> fmt::Result { #[inline(never)] fn d_unknown(w: &mut fmt::Write, value: &Value, prefix: &str) -> fmt::Result { - try!(w.write_str(prefix)); + w.write_str(prefix)?; d_default(w, value) } @@ -1213,10 +1213,10 @@ fn d_default(w: &mut fmt::Write, value: &Value) -> fmt::Result { let mut first = true; for x in v { if !first { - try!(w.write_str(", ")); + w.write_str(", ")?; } first = false; - try!(d_sub_ascii(w, x)); + d_sub_ascii(w, x)?; } Ok(()) }, @@ -1240,10 +1240,10 @@ fn d_sub_comma(w: &mut fmt::Write, slice: &[T]) -> fmt::Result where T: fmt::Display { let mut first = true; for x in slice { - try!(match first { + match first { true => write!(w, "{}", x), false => write!(w, ", {}", x), - }); + }?; first = false; } Ok(()) @@ -1254,33 +1254,33 @@ fn d_sub_comma_f64(w: &mut fmt::Write, slice: &[T]) let mut first = true; for &x in slice { let x: f64 = x.into(); - try!(match first { + match first { true => write!(w, "{}", x), false => write!(w, ", {}", x), - }); + }?; first = false; } Ok(()) } fn d_sub_hex(w: &mut fmt::Write, bytes: &[u8]) -> fmt::Result { - try!(w.write_str("0x")); + w.write_str("0x")?; for x in bytes { - try!(write!(w, "{:02x}", x)); + write!(w, "{:02x}", x)?; } Ok(()) } fn d_sub_ascii(w: &mut fmt::Write, bytes: &[u8]) -> fmt::Result { - try!(w.write_char('"')); + w.write_char('"')?; for &c in bytes { match c { b'\\' | b'"' => { - try!(w.write_char('\\')); - try!(w.write_char(c as char)); + w.write_char('\\')?; + w.write_char(c as char)?; }, - 0x20...0x7e => try!(w.write_char(c as char)), - _ => try!(write!(w, "\\x{:02x}", c)), + 0x20...0x7e => w.write_char(c as char)?, + _ => write!(w, "\\x{:02x}", c)?, } } w.write_char('"') diff --git a/src/tiff.rs b/src/tiff.rs index cd66553..7e9855e 100644 --- a/src/tiff.rs +++ b/src/tiff.rs @@ -76,7 +76,7 @@ fn parse_exif_sub(data: &[u8]) } let ifd_offset = E::loadu32(data, 4) as usize; let mut fields = Vec::new(); - try!(parse_ifd::(&mut fields, data, ifd_offset, Context::Tiff, false)); + parse_ifd::(&mut fields, data, ifd_offset, Context::Tiff, false)?; Ok(fields) } @@ -100,8 +100,8 @@ fn parse_ifd<'a, E>(fields: &mut Vec>, data: &'a [u8], let cnt = E::loadu32(data, offset + 2 + i * 12 + 4) as usize; let valofs_at = offset + 2 + i * 12 + 8; let (unitlen, parser) = get_type_info::(typ); - let vallen = try!(unitlen.checked_mul(cnt).ok_or( - Error::InvalidFormat("Invalid entry count"))); + let vallen = unitlen.checked_mul(cnt).ok_or( + Error::InvalidFormat("Invalid entry count"))?; let val; if unitlen == 0 { val = Value::Unknown(typ, cnt as u32, valofs_at as u32); @@ -119,12 +119,12 @@ fn parse_ifd<'a, E>(fields: &mut Vec>, data: &'a [u8], // recursively defined. let tag = Tag(ctx, tag); match tag { - Tag::ExifIFDPointer => try!(parse_child_ifd::( - fields, data, &val, Context::Exif, thumbnail)), - Tag::GPSInfoIFDPointer => try!(parse_child_ifd::( - fields, data, &val, Context::Gps, thumbnail)), - Tag::InteropIFDPointer => try!(parse_child_ifd::( - fields, data, &val, Context::Interop, thumbnail)), + Tag::ExifIFDPointer => parse_child_ifd::( + fields, data, &val, Context::Exif, thumbnail)?, + Tag::GPSInfoIFDPointer => parse_child_ifd::( + fields, data, &val, Context::Gps, thumbnail)?, + Tag::InteropIFDPointer => parse_child_ifd::( + fields, data, &val, Context::Interop, thumbnail)?, _ => fields.push(Field { tag: tag, thumbnail: thumbnail, value: val }), } @@ -150,8 +150,8 @@ fn parse_child_ifd<'a, E>(fields: &mut Vec>, data: &'a [u8], // A pointer field has type == LONG and count == 1, so the // value (IFD offset) must be embedded in the "value offset" // element of the field. - let ofs = try!(pointer.get_uint(0).ok_or( - Error::InvalidFormat("Invalid pointer"))) as usize; + let ofs = pointer.get_uint(0).ok_or( + Error::InvalidFormat("Invalid pointer"))? as usize; parse_ifd::(fields, data, ofs, ctx, thumbnail) } @@ -198,12 +198,12 @@ impl DateTime { return Err(Error::InvalidFormat("Invalid DateTime delimiter")); } Ok(DateTime { - year: try!(atou16(&data[0..4])), - month: try!(atou16(&data[5..7])) as u8, - day: try!(atou16(&data[8..10])) as u8, - hour: try!(atou16(&data[11..13])) as u8, - minute: try!(atou16(&data[14..16])) as u8, - second: try!(atou16(&data[17..19])) as u8, + year: atou16(&data[0..4])?, + month: atou16(&data[5..7])? as u8, + day: atou16(&data[8..10])? as u8, + hour: atou16(&data[11..13])? as u8, + minute: atou16(&data[14..16])? as u8, + second: atou16(&data[17..19])? as u8, nanosecond: None, offset: None, }) @@ -217,7 +217,7 @@ impl DateTime { if c == b' ' { break; } - subsec = subsec * 10 + try!(ctou32(c)); + subsec = subsec * 10 + ctou32(c)?; ndigits += 1; if ndigits >= 9 { break; @@ -243,8 +243,8 @@ impl DateTime { } else if data[3] != b':' { return Err(Error::InvalidFormat("Invalid OffsetTime delimiter")); } - let hour = try!(atou16(&data[1..3])); - let min = try!(atou16(&data[4..6])); + let hour = atou16(&data[1..3])?; + let min = atou16(&data[4..6])?; let offset = (hour * 60 + min) as i16; self.offset = Some(match data[0] { b'+' => offset, diff --git a/src/util.rs b/src/util.rs index f4b9650..1226503 100644 --- a/src/util.rs +++ b/src/util.rs @@ -40,7 +40,7 @@ pub fn read8(reader: &mut R) -> Result where R: io::Read { pub fn read16(reader: &mut R) -> Result where R: io::Read { let mut buf: [u8; 2] = unsafe { ::std::mem::uninitialized() }; - try!(reader.read_exact(&mut buf)); + reader.read_exact(&mut buf)?; Ok(((buf[0] as u16) << 8) + buf[1] as u16) } diff --git a/src/writer.rs b/src/writer.rs index 9468ab3..4676e51 100644 --- a/src/writer.rs +++ b/src/writer.rs @@ -182,11 +182,11 @@ impl<'a> Writer<'a> { -> Result<(), Error> where W: Write + Seek { // TIFF signature and the offset of the 0th IFD. if little_endian { - try!(w.write_all(&TIFF_LE_SIG)); - try!(LittleEndian::writeu32(w, 8)); + w.write_all(&TIFF_LE_SIG)?; + LittleEndian::writeu32(w, 8)?; } else { - try!(w.write_all(&TIFF_BE_SIG)); - try!(BigEndian::writeu32(w, 8)); + w.write_all(&TIFF_BE_SIG)?; + BigEndian::writeu32(w, 8)?; } // Write the primary image. @@ -204,7 +204,7 @@ impl<'a> Writer<'a> { jpeg: None, }; let next_ifd_offset_offset = - try!(synthesize_fields(w, ws, false, little_endian)); + synthesize_fields(w, ws, false, little_endian)?; // Do not output the thumbnail IFD if there are no data in it. let thumbnail_absent = @@ -215,18 +215,18 @@ impl<'a> Writer<'a> { self.tn_strips == None && self.tn_jpeg == None; if thumbnail_absent { - try!(w.flush()); + w.flush()?; return Ok(()); } - let next_ifd_offset = try!(pad_and_get_offset(w)); - let origpos = try!(w.seek(SeekFrom::Current(0))); - try!(w.seek(SeekFrom::Start(next_ifd_offset_offset as u64))); + let next_ifd_offset = pad_and_get_offset(w)?; + let origpos = w.seek(SeekFrom::Current(0))?; + w.seek(SeekFrom::Start(next_ifd_offset_offset as u64))?; match little_endian { - false => try!(BigEndian::writeu32(w, next_ifd_offset)), - true => try!(LittleEndian::writeu32(w, next_ifd_offset)), + false => BigEndian::writeu32(w, next_ifd_offset)?, + true => LittleEndian::writeu32(w, next_ifd_offset)?, } - try!(w.seek(SeekFrom::Start(origpos))); + w.seek(SeekFrom::Start(origpos))?; // Write the thumbnail image. let ws = WriterState { @@ -242,9 +242,9 @@ impl<'a> Writer<'a> { tiles: None, jpeg: self.tn_jpeg, }; - try!(synthesize_fields(w, ws, true, little_endian)); + synthesize_fields(w, ws, true, little_endian)?; - try!(w.flush()); + w.flush()?; Ok(()) } } @@ -319,9 +319,9 @@ fn synthesize_fields(w: &mut W, ws: WriterState, thumbnail: bool, match gps_fields_len { 0 => 0, _ => 1 } + match exif_fields_len { 0 => 0, _ => 1 }; - ws.tiff_ifd_offset = try!(reserve_ifd(w, tiff_fields_len)); + ws.tiff_ifd_offset = reserve_ifd(w, tiff_fields_len)?; if exif_fields_len > 0 { - ws.exif_ifd_offset = try!(reserve_ifd(w, exif_fields_len)); + ws.exif_ifd_offset = reserve_ifd(w, exif_fields_len)?; exif_in_tiff = Field { tag: Tag::ExifIFDPointer, thumbnail: thumbnail, @@ -330,7 +330,7 @@ fn synthesize_fields(w: &mut W, ws: WriterState, thumbnail: bool, ws.tiff_fields.push(&exif_in_tiff); } if gps_fields_len > 0 { - ws.gps_ifd_offset = try!(reserve_ifd(w, gps_fields_len)); + ws.gps_ifd_offset = reserve_ifd(w, gps_fields_len)?; gps_in_tiff = Field { tag: Tag::GPSInfoIFDPointer, thumbnail: thumbnail, @@ -339,7 +339,7 @@ fn synthesize_fields(w: &mut W, ws: WriterState, thumbnail: bool, ws.tiff_fields.push(&gps_in_tiff); } if interop_fields_len > 0 { - ws.interop_ifd_offset = try!(reserve_ifd(w, interop_fields_len)); + ws.interop_ifd_offset = reserve_ifd(w, interop_fields_len)?; interop_in_exif = Field { tag: Tag::InteropIFDPointer, thumbnail: thumbnail, @@ -364,54 +364,54 @@ fn write_image(w: &mut W, ws: WriterState) -> Result where W: Write + Seek, E: Endian { let (next_ifd_offset_offset, strip_offsets_offset, tile_offsets_offset, jpeg_offset) = - try!(write_ifd_and_fields::<_, E>( - w, &ws.tiff_fields, ws.tiff_ifd_offset)); + write_ifd_and_fields::<_, E>( + w, &ws.tiff_fields, ws.tiff_ifd_offset)?; if ws.exif_fields.len() > 0 { - try!(write_ifd_and_fields::<_, E>( - w, &ws.exif_fields, ws.exif_ifd_offset)); + write_ifd_and_fields::<_, E>( + w, &ws.exif_fields, ws.exif_ifd_offset)?; } if ws.gps_fields.len() > 0 { - try!(write_ifd_and_fields::<_, E>( - w, &ws.gps_fields, ws.gps_ifd_offset)); + write_ifd_and_fields::<_, E>( + w, &ws.gps_fields, ws.gps_ifd_offset)?; } if ws.interop_fields.len() > 0 { - try!(write_ifd_and_fields::<_, E>( - w, &ws.interop_fields, ws.interop_ifd_offset)); + write_ifd_and_fields::<_, E>( + w, &ws.interop_fields, ws.interop_ifd_offset)?; } if let Some(strips) = ws.strips { let mut strip_offsets = Vec::new(); for strip in strips { - strip_offsets.push(try!(get_offset(w))); - try!(w.write_all(strip)); + strip_offsets.push(get_offset(w)?); + w.write_all(strip)?; } - let origpos = try!(w.seek(SeekFrom::Current(0))); - try!(w.seek(SeekFrom::Start(strip_offsets_offset as u64))); + let origpos = w.seek(SeekFrom::Current(0))?; + w.seek(SeekFrom::Start(strip_offsets_offset as u64))?; for ofs in strip_offsets { - try!(E::writeu32(w, ofs)); + E::writeu32(w, ofs)?; } - try!(w.seek(SeekFrom::Start(origpos))); + w.seek(SeekFrom::Start(origpos))?; } if let Some(tiles) = ws.tiles { let mut tile_offsets = Vec::new(); for tile in tiles { - tile_offsets.push(try!(get_offset(w))); - try!(w.write_all(tile)); + tile_offsets.push(get_offset(w)?); + w.write_all(tile)?; } - let origpos = try!(w.seek(SeekFrom::Current(0))); - try!(w.seek(SeekFrom::Start(tile_offsets_offset as u64))); + let origpos = w.seek(SeekFrom::Current(0))?; + w.seek(SeekFrom::Start(tile_offsets_offset as u64))?; for ofs in tile_offsets { - try!(E::writeu32(w, ofs)); + E::writeu32(w, ofs)?; } - try!(w.seek(SeekFrom::Start(origpos))); + w.seek(SeekFrom::Start(origpos))?; } if let Some(jpeg) = ws.jpeg { - let offset = try!(get_offset(w)); - try!(w.write_all(jpeg)); - let origpos = try!(w.seek(SeekFrom::Current(0))); - try!(w.seek(SeekFrom::Start(jpeg_offset as u64))); - try!(E::writeu32(w, offset)); - try!(w.seek(SeekFrom::Start(origpos))); + let offset = get_offset(w)?; + w.write_all(jpeg)?; + let origpos = w.seek(SeekFrom::Current(0))?; + w.seek(SeekFrom::Start(jpeg_offset as u64))?; + E::writeu32(w, offset)?; + w.seek(SeekFrom::Start(origpos))?; } Ok(next_ifd_offset_offset) @@ -421,11 +421,11 @@ fn write_image(w: &mut W, ws: WriterState) // returns the offset of the IFD. fn reserve_ifd(w: &mut W, count: usize) -> Result where W: Write + Seek { - let ifdpos = try!(get_offset(w)); + let ifdpos = get_offset(w)?; assert!(ifdpos % 2 == 0); // The number of entries (2) + array of entries (12 * n) + // the next IFD pointer (4). - try!(w.seek(SeekFrom::Current(2 + count as i64 * 12 + 4))); + w.seek(SeekFrom::Current(2 + count as i64 * 12 + 4))?; Ok(ifdpos) } @@ -442,38 +442,38 @@ fn write_ifd_and_fields( let mut ifd = Vec::new(); // Write the number of entries. - try!(E::writeu16(&mut ifd, fields.len() as u16)); + E::writeu16(&mut ifd, fields.len() as u16)?; // Write the fields. for f in fields { - let (typ, cnt, mut valbuf) = try!(compose_value::(&f.value)); + let (typ, cnt, mut valbuf) = compose_value::(&f.value)?; if cnt as u32 as usize != cnt { return Err(Error::TooBig("Too long array")); } - try!(E::writeu16(&mut ifd, f.tag.number())); - try!(E::writeu16(&mut ifd, typ)); - try!(E::writeu32(&mut ifd, cnt as u32)); + E::writeu16(&mut ifd, f.tag.number())?; + E::writeu16(&mut ifd, typ)?; + E::writeu32(&mut ifd, cnt as u32)?; // Embed the value itself into the offset, or // encode as an offset and the value. if valbuf.len() <= 4 { valbuf.resize(4, 0); - try!(ifd.write_all(&valbuf)); + ifd.write_all(&valbuf)?; } else { // The value must begin on a word boundary. [TIFF6, Section 2: // TIFF Structure, Image File Directory, IFD Entry, p. 15] - let valofs = try!(pad_and_get_offset(w)); - try!(E::writeu32(&mut ifd, valofs)); - try!(w.write_all(&valbuf)); + let valofs = pad_and_get_offset(w)?; + E::writeu32(&mut ifd, valofs)?; + w.write_all(&valbuf)?; } if f.tag == Tag::StripOffsets { strip_offsets_offset = match valbuf.len() { 0...4 => ifd_offset + ifd.len() as u32 - 4, - _ => try!(get_offset(w)) - valbuf.len() as u32, + _ => get_offset(w)? - valbuf.len() as u32, }; } if f.tag == Tag::TileOffsets { tile_offsets_offset = match valbuf.len() { 0...4 => ifd_offset + ifd.len() as u32 - 4, - _ => try!(get_offset(w)) - valbuf.len() as u32, + _ => get_offset(w)? - valbuf.len() as u32, }; } if f.tag == Tag::JPEGInterchangeFormat { @@ -482,10 +482,10 @@ fn write_ifd_and_fields( } // Write the next IFD pointer. let next_ifd_offset_offset = ifd_offset + ifd.len() as u32; - try!(E::writeu32(&mut ifd, 0)); + E::writeu32(&mut ifd, 0)?; // Write the IFD. - try!(write_at(w, &ifd, ifd_offset)); + write_at(w, &ifd, ifd_offset)?; Ok((next_ifd_offset_offset, strip_offsets_offset, tile_offsets_offset, jpeg_offset)) @@ -508,22 +508,22 @@ fn compose_value(value: &Value) Value::Short(ref vec) => { let mut buf = Vec::new(); for &v in vec { - try!(E::writeu16(&mut buf, v)); + E::writeu16(&mut buf, v)?; } Ok((3, vec.len(), buf)) }, Value::Long(ref vec) => { let mut buf = Vec::new(); for &v in vec { - try!(E::writeu32(&mut buf, v)); + E::writeu32(&mut buf, v)?; } Ok((4, vec.len(), buf)) }, Value::Rational(ref vec) => { let mut buf = Vec::new(); for v in vec { - try!(E::writeu32(&mut buf, v.num)); - try!(E::writeu32(&mut buf, v.denom)); + E::writeu32(&mut buf, v.num)?; + E::writeu32(&mut buf, v.denom)?; } Ok((5, vec.len(), buf)) }, @@ -537,36 +537,36 @@ fn compose_value(value: &Value) Value::SShort(ref vec) => { let mut buf = Vec::new(); for &v in vec { - try!(E::writeu16(&mut buf, v as u16)); + E::writeu16(&mut buf, v as u16)?; } Ok((8, vec.len(), buf)) }, Value::SLong(ref vec) => { let mut buf = Vec::new(); for &v in vec { - try!(E::writeu32(&mut buf, v as u32)); + E::writeu32(&mut buf, v as u32)?; } Ok((9, vec.len(), buf)) }, Value::SRational(ref vec) => { let mut buf = Vec::new(); for v in vec { - try!(E::writeu32(&mut buf, v.num as u32)); - try!(E::writeu32(&mut buf, v.denom as u32)); + E::writeu32(&mut buf, v.num as u32)?; + E::writeu32(&mut buf, v.denom as u32)?; } Ok((10, vec.len(), buf)) }, Value::Float(ref vec) => { let mut buf = Vec::new(); for &v in vec { - try!(E::writeu32(&mut buf, unsafe { mem::transmute(v) })); + E::writeu32(&mut buf, unsafe { mem::transmute(v) })?; } Ok((11, vec.len(), buf)) }, Value::Double(ref vec) => { let mut buf = Vec::new(); for &v in vec { - try!(E::writeu64(&mut buf, unsafe { mem::transmute(v) })); + E::writeu64(&mut buf, unsafe { mem::transmute(v) })?; } Ok((12, vec.len(), buf)) }, @@ -577,22 +577,22 @@ fn compose_value(value: &Value) fn write_at(w: &mut W, buf: &[u8], offset: u32) -> io::Result<()> where W: Write + Seek { - let orig = try!(w.seek(SeekFrom::Current(0))); - try!(w.seek(SeekFrom::Start(offset as u64))); - try!(w.write_all(buf)); - try!(w.seek(SeekFrom::Start(orig))); + let orig = w.seek(SeekFrom::Current(0))?; + w.seek(SeekFrom::Start(offset as u64))?; + w.write_all(buf)?; + w.seek(SeekFrom::Start(orig))?; Ok(()) } // Aligns `w` to the two-byte (word) boundary and returns the new offset. fn pad_and_get_offset(w: &mut W) -> Result where W: Write + Seek { - let mut pos = try!(w.seek(SeekFrom::Current(0))); + let mut pos = w.seek(SeekFrom::Current(0))?; if pos >= (1 << 32) - 1 { return Err(Error::TooBig("Offset too large")); } if pos % 2 != 0 { - try!(w.write_all(&[0])); + w.write_all(&[0])?; pos += 1; } Ok(pos as u32) @@ -600,7 +600,7 @@ fn pad_and_get_offset(w: &mut W) fn get_offset(w: &mut W) -> Result where W: Write + Seek { - let pos = try!(w.seek(SeekFrom::Current(0))); + let pos = w.seek(SeekFrom::Current(0))?; if pos as u32 as u64 != pos { return Err(Error::TooBig("Offset too large")); }