opcodes and wip

src/elements/mod.rs

@@ -6,13 +6,14 @@ mod primitives;
 mod types;
 mod import_entry;
 mod export_entry;
+mod ops;
 
 pub use self::module::Module;
 pub use self::section::Section;
 pub use self::import_entry::{ImportEntry, MemoryType, TableType, External};
 pub use self::export_entry::{ExportEntry, Internal};
 pub use self::primitives::{VarUint32, VarUint7, VarUint1, VarInt7, Uint32, CountedList};
-pub use self::types::ValueType;
+pub use self::types::{ValueType, BlockType};
 
 pub trait Deserialize : Sized {
     type Error;

src/elements/ops.rs

@@ -0,0 +1,192 @@
+use std::io;
+use super::{Deserialize, Error, VarUint7, VarInt7, VarUint1, CountedList, BlockType};
+
+pub struct Opcodes(Vec<Opcode>);
+
+pub enum Opcode {
+    Unreachable,
+    Nop,
+    Block(BlockType, Opcodes),
+    Loop(BlockType, Opcodes),
+    If(BlockType, Opcodes),
+    Else,
+    End,
+    Br(u32),
+    BrIf(u32),
+    BrTable(Vec<u32>, u32),
+    Return,
+
+    Call(u32),
+    CallIndirect(u32, bool),
+
+    Drop,
+    Select,
+
+    GetLocal(u32),
+    SetLocal(u32),
+    TeeLocal(u32),
+    GetGlobal(u32),
+    SetGlobal(u32),
+
+    I32Load(u32, u32),
+    I64Load(u32, u32),
+    F32Load(u32, u32),
+    F64Load(u32, u32),
+    I32Load8S(u32, u32),
+    I32Load8U(u32, u32),
+    I32Load16S(u32, u32),
+    I32Load16U(u32, u32),
+    I64Load8S(u32, u32),
+    I64Load8U(u32, u32),
+    I64Load16S(u32, u32),
+    I64Load16U(u32, u32),
+    I64Load32S(u32, u32),
+    I64Load32U(u32, u32),
+    I32Store(u32, u32),
+    I64Store(u32, u32),
+    F32Store(u32, u32),
+    F64Store(u32, u32),
+    I32Store8(u32, u32),
+    I32Store16(u32, u32),
+    I64Store8(u32, u32),
+    I64Store16(u32, u32),
+    I64Store32(u32, u32),
+    CurrentMemory(bool),
+    GrowMemory(bool),
+
+    I32Const(u32),
+    I64Const(u64),
+    F32Const(u32),
+    F64Const(u64),
+
+    I32Eqz,
+    I32Eq,
+    I32Ne,
+    I32LtS,
+    I32LtU,
+    I32GtS,
+    I32GtU,
+    I32LeS,
+    I32LeU,
+    I32GeS,
+    I32GeU,
+    
+    I64Eqz,
+    I64Eq,
+    I64Ne,
+    I64LtS,
+    I64LtU,
+    I64GtS,
+    I64GtU,
+    I64LeS,
+    I64LeU,
+    I64GeS,
+    I64GeU,
+
+    F32Eq,
+    F32Ne,
+    F32Lt,
+    F32Gt,
+    F32Le,
+    F32Ge,
+
+    F64Eq,
+    F64Ne,
+    F64Lt,
+    F64Gt,
+    F64Le,
+    F64Ge,
+
+    I32Clz,
+    I32Ctz,
+    I32Popcnt,
+    I32Add,
+    I32Sub,
+    I32Mul,
+    I32DivS,
+    I32DivU,
+    I32RemS,
+    I32RemU,
+    I32And,
+    I32Or,
+    I32Xor,
+    I32Shl,
+    I32ShlS,
+    I32ShrU,
+    I32Rotl,
+    I32Rotr,
+
+    I64Clz,
+    I64Ctz,
+    I64Popcnt,
+    I64Add,
+    I64Sub,
+    I64Mul,
+    I64DivS,
+    I64DivU,
+    I64RemS,
+    I64RemU,
+    I64And,
+    I64Or,
+    I64Xor,
+    I64Shl,
+    I64ShrS,
+    I64ShrU,
+    I64Rotl,
+    I64Rotr,
+    F32Abs,
+    F32Neg,
+    F32Ceil,
+    F32Floor,
+    F32Trunc,
+    F32Nearest,
+    F32Sqrt,
+    F32Add,
+    F32Sub,
+    F32Mul,
+    F32Div,
+    F32Min,
+    F32Max,
+    F32Copysign,
+    F64Abs,
+    F64Neg,
+    F64Ceil,
+    F64Floor,
+    F64Trunc,
+    F64Nearest,
+    F64Sqrt,
+    F64Add,
+    F64Sub,
+    F64Mul,
+    F64Div,
+    F64Min,
+    F64Max,
+    F64Copysign,
+
+    I32WarpI64,
+    I32TruncSF32,
+    I32TruncUF32,
+    I32TruncSF64,
+    I32TruncUF64,
+    I64ExtendSI32,
+    I64ExtendUI32,
+    I64TruncSF32,
+    I64TruncUF32,
+    I64TruncSF64,
+    I64TruncUF64,
+    F32ConvertSI32,
+    F32ConvertUI32,
+    F32ConvertSI64,
+    F32ConvertUI64,
+    F32DemoteF64,
+    F64ConvertSI32,
+    F64ConvertUI32,
+    F64ConvertSI64,
+    F64ConvertUI64,
+    F64PromoteF32,
+
+    I32ReinterpretF32,
+    I64ReinterpretF64,
+    F32ReinterpretI32,
+    F64ReinterpretI64,
+}

src/elements/section.rs

@@ -26,6 +26,7 @@ pub enum Section {
     Table(TableSection),
     Memory(MemorySection),
     Export(ExportSection),
+    Start(u32),
 }
 
 impl Deserialize for Section {
@@ -61,6 +62,10 @@ impl Deserialize for Section {
                 7 => {
                     Section::Export(ExportSection::deserialize(reader)?)
                 },
+                8 => {
+                    let _section_length = VarUint32::deserialize(reader)?;
+                    Section::Start(VarUint32::deserialize(reader)?.into())
+                },
                 _ => {
                     Section::Unparsed { id: id.into(), payload: Unparsed::deserialize(reader)?.into() }
                 }

src/elements/types.rs

@@ -37,6 +37,30 @@ impl Deserialize for ValueType {
     }    
 }
 
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum BlockType {
+    Value(ValueType),
+    NoResult,
+}
+
+impl Deserialize for BlockType {
+    type Error = Error;
+
+    fn deserialize<R: io::Read>(reader: &mut R) -> Result<Self, Self::Error> {
+        let val = VarInt7::deserialize(reader)?;
+
+        match val.into() {
+            -0x01 => Ok(BlockType::Value(ValueType::I32)),
+            -0x02 => Ok(BlockType::Value(ValueType::I64)),
+            -0x03 => Ok(BlockType::Value(ValueType::F32)),
+            -0x04 => Ok(BlockType::Value(ValueType::F64)),
+            -0x40 => Ok(BlockType::NoResult),
+            _ => Err(Error::UnknownValueType(val.into())),
+        }
+    }    
+}
+
+
 pub struct FunctionType {
     form: u8,
     params: Vec<ValueType>,