Smaller integer for depth

Author: kornelski

rmp/src/marker.rs

@@ -7,12 +7,11 @@ const FIXMAP_SIZE   : u8 = 0x0f;
 #[repr(u8)]
 pub enum Marker {
     FixPos(u8) = 0x00,
-    FixNeg(i8) = 0xe0,
     FixMap(u8) = 0x80,
     FixArray(u8) = 0x90,
     FixStr(u8) = 0xa0,
     Null = 0xc0,
-    // Marked in MessagePack spec as never used.
+    /// Marked in MessagePack spec as never used.
     Reserved,
     False,
     True,
@@ -44,6 +43,7 @@ pub enum Marker {
     Array32,
     Map16,
     Map32,
+    FixNeg(i8) = 0xe0,
 }
 
 impl Marker {
@@ -53,7 +53,6 @@ impl Marker {
     pub fn from_u8(n: u8) -> Marker {
         match n {
             0x00 ..= 0x7f => Marker::FixPos(n),
-            0xe0 ..= 0xff => Marker::FixNeg(n as i8),
             0x80 ..= 0x8f => Marker::FixMap(n & FIXMAP_SIZE),
             0x90 ..= 0x9f => Marker::FixArray(n & FIXARRAY_SIZE),
             0xa0 ..= 0xbf => Marker::FixStr(n & FIXSTR_SIZE),
@@ -90,6 +89,7 @@ impl Marker {
             0xdd => Marker::Array32,
             0xde => Marker::Map16,
             0xdf => Marker::Map32,
+            0xe0 ..= 0xff => Marker::FixNeg(n as i8),
         }
     }
 

rmpv/src/decode/mod.rs

@@ -24,12 +24,9 @@ pub enum Error {
     DepthLimitExceeded,
 }
 
-fn decrement_depth(depth: usize) -> Result<usize, Error> {
-    if depth == 0 {
-        Err(Error::DepthLimitExceeded)
-    } else {
-        Ok(depth - 1)
-    }
+#[inline]
+fn decrement_depth(depth: u16) -> Result<u16, Error> {
+    depth.checked_sub(1).ok_or(Error::DepthLimitExceeded)
 }
 
 impl Error {

rmpv/src/decode/value.rs

@@ -10,7 +10,7 @@ use crate::{Utf8String, Value};
 // See https://github.com/3Hren/msgpack-rust/issues/151
 const PREALLOC_MAX: usize = 64 * 1024; // 64 KiB
 
-fn read_array_data<R: Read>(rd: &mut R, mut len: usize, depth: usize) -> Result<Vec<Value>, Error> {
+fn read_array_data<R: Read>(rd: &mut R, mut len: usize, depth: u16) -> Result<Vec<Value>, Error> {
     let depth = super::decrement_depth(depth)?;
 
     // Note: Do not preallocate a Vec of size `len`.
@@ -25,7 +25,7 @@ fn read_array_data<R: Read>(rd: &mut R, mut len: usize, depth: usize) -> Result<
     Ok(vec)
 }
 
-fn read_map_data<R: Read>(rd: &mut R, mut len: usize, depth: usize) -> Result<Vec<(Value, Value)>, Error> {
+fn read_map_data<R: Read>(rd: &mut R, mut len: usize, depth: u16) -> Result<Vec<(Value, Value)>, Error> {
     let depth = super::decrement_depth(depth)?;
 
     // Note: Do not preallocate a Vec of size `len`.
@@ -40,7 +40,7 @@ fn read_map_data<R: Read>(rd: &mut R, mut len: usize, depth: usize) -> Result<Ve
     Ok(vec)
 }
 
-fn read_str_data<R: Read>(rd: &mut R, len: usize, depth: usize) -> Result<Utf8String, Error> {
+fn read_str_data<R: Read>(rd: &mut R, len: usize, depth: u16) -> Result<Utf8String, Error> {
     let depth = super::decrement_depth(depth)?;
 
     match String::from_utf8(read_bin_data(rd, len, depth)?) {
@@ -55,7 +55,7 @@ fn read_str_data<R: Read>(rd: &mut R, len: usize, depth: usize) -> Result<Utf8St
     }
 }
 
-fn read_bin_data<R: Read>(rd: &mut R, len: usize, depth: usize) -> Result<Vec<u8>, Error> {
+fn read_bin_data<R: Read>(rd: &mut R, len: usize, depth: u16) -> Result<Vec<u8>, Error> {
     let _depth = super::decrement_depth(depth)?;
 
     let mut buf = Vec::with_capacity(min(len, PREALLOC_MAX));
@@ -70,7 +70,7 @@ fn read_bin_data<R: Read>(rd: &mut R, len: usize, depth: usize) -> Result<Vec<u8
     Ok(buf)
 }
 
-fn read_ext_body<R: Read>(rd: &mut R, len: usize, depth: usize) -> Result<(i8, Vec<u8>), Error> {
+fn read_ext_body<R: Read>(rd: &mut R, len: usize, depth: u16) -> Result<(i8, Vec<u8>), Error> {
     let depth = super::decrement_depth(depth)?;
 
     let ty = rd.read_data_i8()?;
@@ -79,7 +79,8 @@ fn read_ext_body<R: Read>(rd: &mut R, len: usize, depth: usize) -> Result<(i8, V
     Ok((ty, vec))
 }
 
-fn read_value_inner<R>(rd: &mut R, depth: usize) -> Result<Value, Error> where R: Read {
+#[inline(never)]
+fn read_value_inner<R>(rd: &mut R, depth: u16) -> Result<Value, Error> where R: Read {
     let depth = super::decrement_depth(depth)?;
     let val = match read_marker(rd)? {
         Marker::Null => Value::Nil,
@@ -216,11 +217,11 @@ fn read_value_inner<R>(rd: &mut R, depth: usize) -> Result<Value, Error> where R
 /// [`Error::DepthLimitExceeded`] is returned if this function recurses
 /// [`MAX_DEPTH`](super::MAX_DEPTH) times. To configure the maximum recursion depth, use
 /// [`read_value_with_max_depth`] instead.
-#[inline(never)]
+#[inline]
 pub fn read_value<R>(rd: &mut R) -> Result<Value, Error>
     where R: Read
 {
-    read_value_inner(rd, super::MAX_DEPTH)
+    read_value_inner(rd, super::MAX_DEPTH as _)
 }
 
 /// Attempts to read bytes from the given reader and interpret them as a [`Value`].
@@ -234,9 +235,9 @@ pub fn read_value<R>(rd: &mut R) -> Result<Value, Error>
 /// [`Error::DepthLimitExceeded`] is returned if this function recurses
 /// `max_depth` times. If the default [`MAX_DEPTH`](super::MAX_DEPTH) is sufficient or you do not
 /// need recursion depth checking for your data, consider using [`read_value`] instead.
-#[inline(never)]
+#[inline]
 pub fn read_value_with_max_depth<R>(rd: &mut R, max_depth: usize) -> Result<Value, Error>
     where R: Read
 {
-    read_value_inner(rd, max_depth)
+    read_value_inner(rd, max_depth.min(u16::MAX as usize) as u16)
 }

rmpv/src/decode/value_ref.rs

@@ -8,7 +8,7 @@ use rmp::Marker;
 use super::Error;
 use crate::{Utf8StringRef, ValueRef};
 
-fn read_str_data<'a, R>(rd: &mut R, len: usize, depth: usize) -> Result<Utf8StringRef<'a>, Error>
+fn read_str_data<'a, R>(rd: &mut R, len: usize, depth: u16) -> Result<Utf8StringRef<'a>, Error>
     where R: BorrowRead<'a>
 {
     let depth = super::decrement_depth(depth)?;
@@ -24,7 +24,7 @@ fn read_str_data<'a, R>(rd: &mut R, len: usize, depth: usize) -> Result<Utf8Stri
     }
 }
 
-fn read_bin_data<'a, R>(rd: &mut R, len: usize, depth: usize) -> Result<&'a [u8], Error>
+fn read_bin_data<'a, R>(rd: &mut R, len: usize, depth: u16) -> Result<&'a [u8], Error>
     where R: BorrowRead<'a>
 {
     let _depth = super::decrement_depth(depth)?;
@@ -41,7 +41,7 @@ fn read_bin_data<'a, R>(rd: &mut R, len: usize, depth: usize) -> Result<&'a [u8]
     Ok(buf)
 }
 
-fn read_ext_body<'a, R>(rd: &mut R, len: usize, depth: usize) -> Result<(i8, &'a [u8]), Error>
+fn read_ext_body<'a, R>(rd: &mut R, len: usize, depth: u16) -> Result<(i8, &'a [u8]), Error>
     where R: BorrowRead<'a>
 {
     let depth = super::decrement_depth(depth)?;
@@ -51,7 +51,7 @@ fn read_ext_body<'a, R>(rd: &mut R, len: usize, depth: usize) -> Result<(i8, &'a
     Ok((ty, buf))
 }
 
-fn read_array_data<'a, R>(rd: &mut R, mut len: usize, depth: usize) -> Result<Vec<ValueRef<'a>>, Error>
+fn read_array_data<'a, R>(rd: &mut R, mut len: usize, depth: u16) -> Result<Vec<ValueRef<'a>>, Error>
     where R: BorrowRead<'a>
 {
     let depth = super::decrement_depth(depth)?;
@@ -67,7 +67,7 @@ fn read_array_data<'a, R>(rd: &mut R, mut len: usize, depth: usize) -> Result<Ve
     Ok(vec)
 }
 
-fn read_map_data<'a, R>(rd: &mut R, mut len: usize, depth: usize) -> Result<Vec<(ValueRef<'a>, ValueRef<'a>)>, Error>
+fn read_map_data<'a, R>(rd: &mut R, mut len: usize, depth: u16) -> Result<Vec<(ValueRef<'a>, ValueRef<'a>)>, Error>
     where R: BorrowRead<'a>
 {
     let depth = super::decrement_depth(depth)?;
@@ -127,7 +127,7 @@ impl<'a> BorrowRead<'a> for Cursor<&'a [u8]> {
     }
 }
 
-fn read_value_ref_inner<'a, R>(rd: &mut R, depth: usize) -> Result<ValueRef<'a>, Error>
+fn read_value_ref_inner<'a, R>(rd: &mut R, depth: u16) -> Result<ValueRef<'a>, Error>
     where R: BorrowRead<'a>
 {
     let depth = super::decrement_depth(depth)?;
@@ -296,7 +296,7 @@ fn read_value_ref_inner<'a, R>(rd: &mut R, depth: usize) -> Result<ValueRef<'a>,
 pub fn read_value_ref<'a, R>(rd: &mut R) -> Result<ValueRef<'a>, Error>
     where R: BorrowRead<'a>
 {
-    read_value_ref_inner(rd, super::MAX_DEPTH)
+    read_value_ref_inner(rd, super::MAX_DEPTH as _)
 }
 
 /// Attempts to read the data from the given reader until either a complete MessagePack value
@@ -316,5 +316,5 @@ pub fn read_value_ref<'a, R>(rd: &mut R) -> Result<ValueRef<'a>, Error>
 pub fn read_value_ref_with_max_depth<'a, R>(rd: &mut R, max_depth: usize) -> Result<ValueRef<'a>, Error>
     where R: BorrowRead<'a>
 {
-    read_value_ref_inner(rd, max_depth)
+    read_value_ref_inner(rd, max_depth.min(u16::MAX as _) as u16)
 }