wasper 0.1.3

A Webassembly interpreter written in Rust without standard library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use super::{error::Error, parser::Parser};
use crate::binary::*;
#[cfg(not(feature = "std"))]
use crate::lib::*;

impl<'a> Parser<'a> {
    pub fn reftype(&mut self) -> Result<RefType, Error> {
        if let Some(byte) = self.byte() {
            FromByte::from_byte(byte).ok_or(Error::Expected(format!("reftype")))
        } else {
            Err(Error::UnexpectedEof(format!("reftype")))
        }
    }

    pub fn valtype(&mut self) -> Result<ValType, Error> {
        if let Some(byte) = self.byte() {
            FromByte::from_byte(byte).ok_or(Error::Expected(format!("valtype")))
        } else {
            Err(Error::UnexpectedEof(format!("valtype")))
        }
    }

    pub fn is_valtype(&self, byte: u8) -> bool {
        byte == 0x7F
            || byte == 0x7E
            || byte == 0x7D
            || byte == 0x7c
            || byte == 0x7B
            || byte == 0x70
            || byte == 0x6F
    }

    pub fn result_types(&mut self) -> Result<ResultType, Error> {
        Ok(ResultType(self.vec(Self::valtype)?))
    }

    pub fn functype(&mut self) -> Result<FuncType, Error> {
        if let Some(byte) = self.byte() {
            if byte != 0x60 {
                return Err(Error::Expected(format!("0x60")));
            }
        }

        Ok(FuncType(self.result_types()?, self.result_types()?))
    }

    pub fn limits(&mut self) -> Result<Limits, Error> {
        match self.byte() {
            Some(0x00) => Ok(Limits::Min(self.u32()?)),
            Some(0x01) => Ok(Limits::MinMax(self.u32()?, self.u32()?)),
            Some(_) => Err(Error::Expected(format!("limits"))),
            None => Err(Error::UnexpectedEof(format!("limits"))),
        }
    }

    pub fn memory(&mut self) -> Result<Memory, Error> {
        Ok(Memory(self.limits()?))
    }

    pub fn table(&mut self) -> Result<Table, Error> {
        Ok(Table {
            reftype: self.reftype()?,
            limits: self.limits()?,
        })
    }

    pub fn mut_(&mut self) -> Result<Mut, Error> {
        match self.byte() {
            Some(0x00) => Ok(Mut::Const),
            Some(0x01) => Ok(Mut::Var),
            _ => Err(Error::Expected(format!("0x00 or 0x01"))),
        }
    }

    pub fn globaltype(&mut self) -> Result<GlobalType, Error> {
        Ok(GlobalType {
            valtype: self.valtype()?,
            mut_: self.mut_()?,
        })
    }
}