raw_nbt/
decode.rs

1use std::convert::From;
2use std::fmt;
3use std::io;
4use std::io::Read;
5use std::string::FromUtf8Error;
6
7use crate::*;
8
9/// Parse NBT binary into Value.
10/// 
11/// Input stream should be plain NBT binary.
12/// If you need decompress, use other crate (ex: flate2).
13pub fn parse<R: Read>(r: R) -> Result<Value> {
14    let mut parser = Parser::new(r);
15    parser.parse()
16}
17
18#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
19enum Type {
20    End,
21    Byte,
22    Short,
23    Int,
24    Long,
25    Float,
26    Double,
27    ByteArray,
28    Str,
29    List,
30    Compound,
31    IntArray,
32    LongArray,
33}
34
35impl Type {
36    fn try_from(byte: u8) -> Result<Type> {
37        match byte {
38            0 => Ok(Type::End),
39            1 => Ok(Type::Byte),
40            2 => Ok(Type::Short),
41            3 => Ok(Type::Int),
42            4 => Ok(Type::Long),
43            5 => Ok(Type::Float),
44            6 => Ok(Type::Double),
45            7 => Ok(Type::ByteArray),
46            8 => Ok(Type::Str),
47            9 => Ok(Type::List),
48            10 => Ok(Type::Compound),
49            11 => Ok(Type::IntArray),
50            12 => Ok(Type::LongArray),
51            b => Err(ParseError::UnknownTag(b)),
52        }
53    }
54}
55
56/// NBT Parse error.
57#[derive(Debug)]
58pub enum ParseError {
59    InvalidUTF8(FromUtf8Error),
60    ReadError(io::Error),
61    UnexpectedEndOfInput,
62    UnexpectedTag,
63    UnknownTag(u8),
64}
65
66impl fmt::Display for ParseError {
67    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
68        match self {
69            ParseError::InvalidUTF8(ref cause) => cause.fmt(f),
70            ParseError::ReadError(ref cause) => cause.fmt(f),
71            ParseError::UnexpectedEndOfInput => write!(f, "unexpected input end"),
72            ParseError::UnexpectedTag => write!(f, "unexpected tag"),
73            ParseError::UnknownTag(b) => write!(f, "found unknown tag {}", b),
74        }
75    }
76}
77
78impl std::error::Error for ParseError {
79    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
80        match self {
81            ParseError::ReadError(ref cause) => Some(cause),
82            ParseError::InvalidUTF8(ref cause) => Some(cause),
83            _ => None,
84        }
85    }
86}
87
88impl From<io::Error> for ParseError {
89    fn from(e: io::Error) -> ParseError {
90        match e.kind() {
91            io::ErrorKind::UnexpectedEof => ParseError::UnexpectedEndOfInput,
92            _ => ParseError::ReadError(e),
93        }
94    }
95}
96
97impl From<FromUtf8Error> for ParseError {
98    fn from(e: FromUtf8Error) -> ParseError {
99        ParseError::InvalidUTF8(e)
100    }
101}
102
103pub type Result<T> = std::result::Result<T, ParseError>;
104
105#[derive(Debug)]
106struct Parser<R> {
107    r: R,
108}
109
110impl<R: Read> Parser<R> {
111    pub fn new(r: R) -> Parser<R> {
112        Parser { r }
113    }
114
115    pub fn parse(&mut self) -> Result<Value> {
116        let mut root = Compound::new();
117
118        while let Some(tag) = self.read_tag()? {
119            let name = self.read_str()?;
120            let payload = self.parse_value_with_tag(tag)?;
121            root.insert(name, payload);
122        }
123
124        Ok(Value::Compound(root))
125    }
126
127    //// parse ////
128
129    fn parse_value_with_tag(&mut self, tag: Type) -> Result<Value> {
130        match tag {
131            Type::End => Err(ParseError::UnexpectedTag),
132            Type::Byte => self.parse_byte(),
133            Type::Short => self.parse_short(),
134            Type::Int => self.parse_int(),
135            Type::Long => self.parse_long(),
136            Type::Float => self.parse_float(),
137            Type::Double => self.parse_double(),
138            Type::ByteArray => self.parse_byte_array(),
139            Type::Str => self.parse_str(),
140            Type::List => self.parse_list(),
141            Type::Compound => self.parse_compound(),
142            Type::IntArray => self.parse_int_array(),
143            Type::LongArray => self.parse_long_array(),
144        }
145    }
146
147    /// parse subtypes
148
149    fn parse_byte(&mut self) -> Result<Value> {
150        Ok(Value::Byte(self.read_byte()?))
151    }
152
153    fn parse_short(&mut self) -> Result<Value> {
154        Ok(Value::Short(self.read_short()?))
155    }
156
157    fn parse_int(&mut self) -> Result<Value> {
158        Ok(Value::Int(self.read_int()?))
159    }
160
161    fn parse_long(&mut self) -> Result<Value> {
162        Ok(Value::Long(self.read_long()?))
163    }
164
165    fn parse_float(&mut self) -> Result<Value> {
166        Ok(Value::Float(self.read_float()?))
167    }
168
169    fn parse_double(&mut self) -> Result<Value> {
170        Ok(Value::Double(self.read_double()?))
171    }
172
173    fn parse_byte_array(&mut self) -> Result<Value> {
174        Ok(Value::ByteArray(self.read_byte_array()?))
175    }
176
177    fn parse_str(&mut self) -> Result<Value> {
178        Ok(Value::Str(self.read_str()?))
179    }
180
181    fn parse_compound(&mut self) -> Result<Value> {
182        Ok(Value::Compound(self.read_compound()?))
183    }
184
185    fn parse_int_array(&mut self) -> Result<Value> {
186        Ok(Value::IntArray(self.read_int_array()?))
187    }
188
189    fn parse_long_array(&mut self) -> Result<Value> {
190        Ok(Value::LongArray(self.read_long_array()?))
191    }
192
193    //// list ////
194
195    fn parse_list(&mut self) -> Result<Value> {
196        if let Some(tag) = self.read_tag()? {
197            let size = self.read_int()? as usize;
198
199            match tag {
200                Type::End => Ok(Value::EndList),
201                Type::Byte => {
202                    if size == 0 {
203                        Ok(Value::EmptyByteList)
204                    } else {
205                        self.parse_byte_list(size)
206                    }
207                }
208                Type::Short => self.parse_short_list(size),
209                Type::Int => self.parse_int_list(size),
210                Type::Long => self.parse_long_list(size),
211                Type::Float => self.parse_float_list(size),
212                Type::Double => self.parse_double_list(size),
213                Type::ByteArray => self.parse_byte_array_list(size),
214                Type::Str => self.parse_str_list(size),
215                Type::List => self.parse_list_list(size),
216                Type::Compound => self.parse_compound_list(size),
217                Type::IntArray => self.parse_int_array_list(size),
218                Type::LongArray => self.parse_long_array_list(size),
219            }
220        } else {
221            Err(ParseError::UnexpectedEndOfInput)
222        }
223    }
224
225    fn parse_byte_list(&mut self, size: usize) -> Result<Value> {
226        let mut list: Vec<i8> = Vec::with_capacity(size);
227        for _ in 0..size {
228            list.push(self.read_byte()?);
229        }
230        Ok(Value::ByteList(list))
231    }
232
233    fn parse_short_list(&mut self, size: usize) -> Result<Value> {
234        let mut list: Vec<i16> = Vec::with_capacity(size);
235        for _ in 0..size {
236            list.push(self.read_short()?);
237        }
238        Ok(Value::ShortList(list))
239    }
240
241    fn parse_int_list(&mut self, size: usize) -> Result<Value> {
242        let mut list: Vec<i32> = Vec::with_capacity(size);
243        for _ in 0..size {
244            list.push(self.read_int()?);
245        }
246        Ok(Value::IntList(list))
247    }
248
249    fn parse_long_list(&mut self, size: usize) -> Result<Value> {
250        let mut list: Vec<i64> = Vec::with_capacity(size);
251        for _ in 0..size {
252            list.push(self.read_long()?);
253        }
254        Ok(Value::LongList(list))
255    }
256
257    fn parse_float_list(&mut self, size: usize) -> Result<Value> {
258        let mut list: Vec<f32> = Vec::with_capacity(size);
259        for _ in 0..size {
260            list.push(self.read_float()?);
261        }
262        Ok(Value::FloatList(list))
263    }
264
265    fn parse_double_list(&mut self, size: usize) -> Result<Value> {
266        let mut list: Vec<f64> = Vec::with_capacity(size);
267        for _ in 0..size {
268            list.push(self.read_double()?);
269        }
270        Ok(Value::DoubleList(list))
271    }
272
273    fn parse_byte_array_list(&mut self, size: usize) -> Result<Value> {
274        let mut list: Vec<Vec<i8>> = Vec::with_capacity(size);
275        for _ in 0..size {
276            list.push(self.read_byte_array()?);
277        }
278        Ok(Value::ByteArrayList(list))
279    }
280
281    fn parse_str_list(&mut self, size: usize) -> Result<Value> {
282        let mut list: Vec<String> = Vec::with_capacity(size);
283        for _ in 0..size {
284            list.push(self.read_str()?);
285        }
286        Ok(Value::StrList(list))
287    }
288
289    fn parse_list_list(&mut self, size: usize) -> Result<Value> {
290        let mut list: Vec<Value> = Vec::with_capacity(size);
291        for _ in 0..size {
292            list.push(self.parse_list()?);
293        }
294        Ok(Value::ListList(list))
295    }
296
297    fn parse_compound_list(&mut self, size: usize) -> Result<Value> {
298        let mut list: Vec<Compound> = Vec::with_capacity(size);
299        for _ in 0..size {
300            list.push(self.read_compound()?);
301        }
302        Ok(Value::CompoundList(list))
303    }
304
305    fn parse_int_array_list(&mut self, size: usize) -> Result<Value> {
306        let mut list: Vec<Vec<i32>> = Vec::with_capacity(size);
307        for _ in 0..size {
308            list.push(self.read_int_array()?);
309        }
310        Ok(Value::IntArrayList(list))
311    }
312
313    fn parse_long_array_list(&mut self, size: usize) -> Result<Value> {
314        let mut list: Vec<Vec<i64>> = Vec::with_capacity(size);
315        for _ in 0..size {
316            list.push(self.read_long_array()?);
317        }
318        Ok(Value::LongArrayList(list))
319    }
320
321    //// read ////
322
323    fn read_tag(&mut self) -> Result<Option<Type>> {
324        let mut bs: [u8; 1] = [0; 1];
325
326        match self.r.read_exact(&mut bs) {
327            Ok(()) => Ok(Some(Type::try_from(bs[0])?)),
328            Err(e) => {
329                if e.kind() == io::ErrorKind::UnexpectedEof {
330                    Ok(None)
331                } else {
332                    Err(ParseError::from(e))
333                }
334            }
335        }
336    }
337
338    fn read_byte(&mut self) -> Result<i8> {
339        let mut bs = [0u8; 1];
340        self.r.read_exact(&mut bs)?;
341        Ok(i8::from_be_bytes(bs))
342    }
343
344    fn read_short(&mut self) -> Result<i16> {
345        let mut bs = [0u8; 2];
346        self.r.read_exact(&mut bs)?;
347        Ok(i16::from_be_bytes(bs))
348    }
349
350    fn read_int(&mut self) -> Result<i32> {
351        let mut bs = [0u8; 4];
352        self.r.read_exact(&mut bs)?;
353        Ok(i32::from_be_bytes(bs))
354    }
355
356    fn read_long(&mut self) -> Result<i64> {
357        let mut bs = [0u8; 8];
358        self.r.read_exact(&mut bs)?;
359        Ok(i64::from_be_bytes(bs))
360    }
361
362    fn read_float(&mut self) -> Result<f32> {
363        let mut bs = [0u8; 4];
364        self.r.read_exact(&mut bs)?;
365        let x = u32::from_be_bytes(bs);
366        Ok(f32::from_bits(x))
367    }
368
369    fn read_double(&mut self) -> Result<f64> {
370        let mut bs = [0u8; 8];
371        self.r.read_exact(&mut bs)?;
372        let x = u64::from_be_bytes(bs);
373        Ok(f64::from_bits(x))
374    }
375
376    fn read_byte_array(&mut self) -> Result<Vec<i8>> {
377        let size = self.read_int()? as usize;
378        let mut arr: Vec<i8> = Vec::with_capacity(size);
379
380        for _ in 0..size {
381            arr.push(self.read_byte()?);
382        }
383
384        Ok(arr)
385    }
386
387    fn read_str(&mut self) -> Result<String> {
388        let size = self.read_short()? as usize;
389
390        let mut bs = vec![0u8; size];
391        self.r.read_exact(bs.as_mut_slice())?;
392
393        Ok(String::from_utf8(bs)?)
394    }
395
396    fn read_compound(&mut self) -> Result<Compound> {
397        let mut root = Compound::new();
398
399        loop {
400            if let Some(tag) = self.read_tag()? {
401                if tag == Type::End {
402                    return Ok(root);
403                }
404
405                let name = self.read_str()?;
406                let payload = self.parse_value_with_tag(tag)?;
407                root.insert(name, payload);
408            } else {
409                return Err(ParseError::UnexpectedEndOfInput);
410            }
411        }
412    }
413
414    fn read_int_array(&mut self) -> Result<Vec<i32>> {
415        let size = self.read_int()? as usize;
416        let mut arr: Vec<i32> = Vec::with_capacity(size);
417
418        for _ in 0..size {
419            arr.push(self.read_int()?);
420        }
421
422        Ok(arr)
423    }
424
425    fn read_long_array(&mut self) -> Result<Vec<i64>> {
426        let size = self.read_int()? as usize;
427        let mut arr: Vec<i64> = Vec::with_capacity(size);
428
429        for _ in 0..size {
430            arr.push(self.read_long()?);
431        }
432
433        Ok(arr)
434    }
435}
raw_nbt/decode.rs

raw_nbt/
decode.rs
