1 use crate::leb128
::{self, read_signed_leb128, write_signed_leb128}
;
5 // -----------------------------------------------------------------------------
7 // -----------------------------------------------------------------------------
9 pub type EncodeResult
= Result
<(), !>;
16 pub fn new(data
: Vec
<u8>) -> Encoder
{
20 pub fn into_inner(self) -> Vec
<u8> {
25 pub fn emit_raw_bytes(&mut self, s
: &[u8]) {
26 self.data
.extend_from_slice(s
);
30 macro_rules
! write_uleb128
{
31 ($enc
:expr
, $value
:expr
, $fun
:ident
) => {{
32 leb128
::$
fun(&mut $enc
.data
, $value
);
37 macro_rules
! write_sleb128
{
38 ($enc
:expr
, $value
:expr
) => {{
39 write_signed_leb128(&mut $enc
.data
, $value
as i128
);
44 impl serialize
::Encoder
for Encoder
{
48 fn emit_unit(&mut self) -> EncodeResult
{
53 fn emit_usize(&mut self, v
: usize) -> EncodeResult
{
54 write_uleb128
!(self, v
, write_usize_leb128
)
58 fn emit_u128(&mut self, v
: u128
) -> EncodeResult
{
59 write_uleb128
!(self, v
, write_u128_leb128
)
63 fn emit_u64(&mut self, v
: u64) -> EncodeResult
{
64 write_uleb128
!(self, v
, write_u64_leb128
)
68 fn emit_u32(&mut self, v
: u32) -> EncodeResult
{
69 write_uleb128
!(self, v
, write_u32_leb128
)
73 fn emit_u16(&mut self, v
: u16) -> EncodeResult
{
74 write_uleb128
!(self, v
, write_u16_leb128
)
78 fn emit_u8(&mut self, v
: u8) -> EncodeResult
{
84 fn emit_isize(&mut self, v
: isize) -> EncodeResult
{
85 write_sleb128
!(self, v
)
89 fn emit_i128(&mut self, v
: i128
) -> EncodeResult
{
90 write_sleb128
!(self, v
)
94 fn emit_i64(&mut self, v
: i64) -> EncodeResult
{
95 write_sleb128
!(self, v
)
99 fn emit_i32(&mut self, v
: i32) -> EncodeResult
{
100 write_sleb128
!(self, v
)
104 fn emit_i16(&mut self, v
: i16) -> EncodeResult
{
105 write_sleb128
!(self, v
)
109 fn emit_i8(&mut self, v
: i8) -> EncodeResult
{
110 let as_u8
: u8 = unsafe { ::std::mem::transmute(v) }
;
115 fn emit_bool(&mut self, v
: bool
) -> EncodeResult
{
116 self.emit_u8(if v { 1 }
else { 0 }
)
120 fn emit_f64(&mut self, v
: f64) -> EncodeResult
{
121 let as_u64
: u64 = v
.to_bits();
122 self.emit_u64(as_u64
)
126 fn emit_f32(&mut self, v
: f32) -> EncodeResult
{
127 let as_u32
: u32 = v
.to_bits();
128 self.emit_u32(as_u32
)
132 fn emit_char(&mut self, v
: char) -> EncodeResult
{
133 self.emit_u32(v
as u32)
137 fn emit_str(&mut self, v
: &str) -> EncodeResult
{
138 self.emit_usize(v
.len())?
;
139 self.emit_raw_bytes(v
.as_bytes());
146 pub fn position(&self) -> usize {
151 // -----------------------------------------------------------------------------
153 // -----------------------------------------------------------------------------
155 pub struct Decoder
<'a
> {
160 impl<'a
> Decoder
<'a
> {
162 pub fn new(data
: &'a
[u8], position
: usize) -> Decoder
<'a
> {
163 Decoder { data, position }
167 pub fn position(&self) -> usize {
172 pub fn set_position(&mut self, pos
: usize) {
177 pub fn advance(&mut self, bytes
: usize) {
178 self.position
+= bytes
;
182 pub fn read_raw_bytes(&mut self, s
: &mut [u8]) -> Result
<(), String
> {
183 let start
= self.position
;
184 let end
= start
+ s
.len();
186 s
.copy_from_slice(&self.data
[start
..end
]);
194 macro_rules
! read_uleb128
{
195 ($dec
:expr
, $fun
:ident
) => {{
196 let (value
, bytes_read
) = leb128
::$
fun(&$dec
.data
[$dec
.position
..]);
197 $dec
.position
+= bytes_read
;
202 macro_rules
! read_sleb128
{
203 ($dec
:expr
, $t
:ty
) => {{
204 let (value
, bytes_read
) = read_signed_leb128($dec
.data
, $dec
.position
);
205 $dec
.position
+= bytes_read
;
210 impl<'a
> serialize
::Decoder
for Decoder
<'a
> {
214 fn read_nil(&mut self) -> Result
<(), Self::Error
> {
219 fn read_u128(&mut self) -> Result
<u128
, Self::Error
> {
220 read_uleb128
!(self, read_u128_leb128
)
224 fn read_u64(&mut self) -> Result
<u64, Self::Error
> {
225 read_uleb128
!(self, read_u64_leb128
)
229 fn read_u32(&mut self) -> Result
<u32, Self::Error
> {
230 read_uleb128
!(self, read_u32_leb128
)
234 fn read_u16(&mut self) -> Result
<u16, Self::Error
> {
235 read_uleb128
!(self, read_u16_leb128
)
239 fn read_u8(&mut self) -> Result
<u8, Self::Error
> {
240 let value
= self.data
[self.position
];
246 fn read_usize(&mut self) -> Result
<usize, Self::Error
> {
247 read_uleb128
!(self, read_usize_leb128
)
251 fn read_i128(&mut self) -> Result
<i128
, Self::Error
> {
252 read_sleb128
!(self, i128
)
256 fn read_i64(&mut self) -> Result
<i64, Self::Error
> {
257 read_sleb128
!(self, i64)
261 fn read_i32(&mut self) -> Result
<i32, Self::Error
> {
262 read_sleb128
!(self, i32)
266 fn read_i16(&mut self) -> Result
<i16, Self::Error
> {
267 read_sleb128
!(self, i16)
271 fn read_i8(&mut self) -> Result
<i8, Self::Error
> {
272 let as_u8
= self.data
[self.position
];
274 unsafe { Ok(::std::mem::transmute(as_u8)) }
278 fn read_isize(&mut self) -> Result
<isize, Self::Error
> {
279 read_sleb128
!(self, isize)
283 fn read_bool(&mut self) -> Result
<bool
, Self::Error
> {
284 let value
= self.read_u8()?
;
289 fn read_f64(&mut self) -> Result
<f64, Self::Error
> {
290 let bits
= self.read_u64()?
;
291 Ok(f64::from_bits(bits
))
295 fn read_f32(&mut self) -> Result
<f32, Self::Error
> {
296 let bits
= self.read_u32()?
;
297 Ok(f32::from_bits(bits
))
301 fn read_char(&mut self) -> Result
<char, Self::Error
> {
302 let bits
= self.read_u32()?
;
303 Ok(::std
::char::from_u32(bits
).unwrap())
307 fn read_str(&mut self) -> Result
<Cow
<'_
, str>, Self::Error
> {
308 let len
= self.read_usize()?
;
309 let s
= ::std
::str::from_utf8(&self.data
[self.position
..self.position
+ len
]).unwrap();
310 self.position
+= len
;
315 fn error(&mut self, err
: &str) -> Self::Error
{