compiler/rustc_serialize/src/leb128.rs

   1 #![macro_use]
   2
   3 macro_rules! max_leb128_len {
   4     ($int_ty:ty) => {
   5         // The longest LEB128 encoding for an integer uses 7 bits per byte.
   6         (std::mem::size_of::<$int_ty>() * 8 + 6) / 7
   7     };
   8 }
   9
  10 // Returns the longest LEB128 encoding of all supported integer types.
  11 pub const fn max_leb128_len() -> usize {
  12     max_leb128_len!(u128)
  13 }
  14
  15 macro_rules! impl_write_unsigned_leb128 {
  16     ($fn_name:ident, $int_ty:ty) => {
  17         #[inline]
  18         pub fn $fn_name(
  19             out: &mut [::std::mem::MaybeUninit<u8>; max_leb128_len!($int_ty)],
  20             mut value: $int_ty,
  21         ) -> &[u8] {
  22             let mut i = 0;
  23
  24             loop {
  25                 if value < 0x80 {
  26                     unsafe {
  27                         *out.get_unchecked_mut(i).as_mut_ptr() = value as u8;
  28                     }
  29
  30                     i += 1;
  31                     break;
  32                 } else {
  33                     unsafe {
  34                         *out.get_unchecked_mut(i).as_mut_ptr() = ((value & 0x7f) | 0x80) as u8;
  35                     }
  36
  37                     value >>= 7;
  38                     i += 1;
  39                 }
  40             }
  41
  42             unsafe { ::std::mem::MaybeUninit::slice_assume_init_ref(&out.get_unchecked(..i)) }
  43         }
  44     };
  45 }
  46
  47 impl_write_unsigned_leb128!(write_u16_leb128, u16);
  48 impl_write_unsigned_leb128!(write_u32_leb128, u32);
  49 impl_write_unsigned_leb128!(write_u64_leb128, u64);
  50 impl_write_unsigned_leb128!(write_u128_leb128, u128);
  51 impl_write_unsigned_leb128!(write_usize_leb128, usize);
  52
  53 macro_rules! impl_read_unsigned_leb128 {
  54     ($fn_name:ident, $int_ty:ty) => {
  55         #[inline]
  56         pub fn $fn_name(slice: &[u8]) -> ($int_ty, usize) {
  57             let mut result = 0;
  58             let mut shift = 0;
  59             let mut position = 0;
  60             loop {
  61                 let byte = slice[position];
  62                 position += 1;
  63                 if (byte & 0x80) == 0 {
  64                     result |= (byte as $int_ty) << shift;
  65                     return (result, position);
  66                 } else {
  67                     result |= ((byte & 0x7F) as $int_ty) << shift;
  68                 }
  69                 shift += 7;
  70             }
  71         }
  72     };
  73 }
  74
  75 impl_read_unsigned_leb128!(read_u16_leb128, u16);
  76 impl_read_unsigned_leb128!(read_u32_leb128, u32);
  77 impl_read_unsigned_leb128!(read_u64_leb128, u64);
  78 impl_read_unsigned_leb128!(read_u128_leb128, u128);
  79 impl_read_unsigned_leb128!(read_usize_leb128, usize);
  80
  81 macro_rules! impl_write_signed_leb128 {
  82     ($fn_name:ident, $int_ty:ty) => {
  83         #[inline]
  84         pub fn $fn_name(
  85             out: &mut [::std::mem::MaybeUninit<u8>; max_leb128_len!($int_ty)],
  86             mut value: $int_ty,
  87         ) -> &[u8] {
  88             let mut i = 0;
  89
  90             loop {
  91                 let mut byte = (value as u8) & 0x7f;
  92                 value >>= 7;
  93                 let more = !(((value == 0) && ((byte & 0x40) == 0))
  94                     || ((value == -1) && ((byte & 0x40) != 0)));
  95
  96                 if more {
  97                     byte |= 0x80; // Mark this byte to show that more bytes will follow.
  98                 }
  99
 100                 unsafe {
 101                     *out.get_unchecked_mut(i).as_mut_ptr() = byte;
 102                 }
 103
 104                 i += 1;
 105
 106                 if !more {
 107                     break;
 108                 }
 109             }
 110
 111             unsafe { ::std::mem::MaybeUninit::slice_assume_init_ref(&out.get_unchecked(..i)) }
 112         }
 113     };
 114 }
 115
 116 impl_write_signed_leb128!(write_i16_leb128, i16);
 117 impl_write_signed_leb128!(write_i32_leb128, i32);
 118 impl_write_signed_leb128!(write_i64_leb128, i64);
 119 impl_write_signed_leb128!(write_i128_leb128, i128);
 120 impl_write_signed_leb128!(write_isize_leb128, isize);
 121
 122 macro_rules! impl_read_signed_leb128 {
 123     ($fn_name:ident, $int_ty:ty) => {
 124         #[inline]
 125         pub fn $fn_name(slice: &[u8]) -> ($int_ty, usize) {
 126             let mut result = 0;
 127             let mut shift = 0;
 128             let mut position = 0;
 129             let mut byte;
 130
 131             loop {
 132                 byte = slice[position];
 133                 position += 1;
 134                 result |= <$int_ty>::from(byte & 0x7F) << shift;
 135                 shift += 7;
 136
 137                 if (byte & 0x80) == 0 {
 138                     break;
 139                 }
 140             }
 141
 142             if (shift < <$int_ty>::BITS) && ((byte & 0x40) != 0) {
 143                 // sign extend
 144                 result |= (!0 << shift);
 145             }
 146
 147             (result, position)
 148         }
 149     };
 150 }
 151
 152 impl_read_signed_leb128!(read_i16_leb128, i16);
 153 impl_read_signed_leb128!(read_i32_leb128, i32);
 154 impl_read_signed_leb128!(read_i64_leb128, i64);
 155 impl_read_signed_leb128!(read_i128_leb128, i128);
 156 impl_read_signed_leb128!(read_isize_leb128, isize);