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
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use std::io;
use super::{Deserialize, Serialize, Error, VarUint32, CountedList, InitExpr, CountedListWriter};

/// Entry in the element section.
pub struct ElementSegment {
    index: u32,
    offset: InitExpr,
    members: Vec<u32>,
}

impl ElementSegment {
    /// New element segment.
    pub fn new(index: u32, offset: InitExpr, members: Vec<u32>) -> Self {
        ElementSegment { index: index, offset: offset, members: members }
    }

    /// Sequence of function indices.
    pub fn members(&self) -> &[u32] { &self.members }

    /// Table index (currently valid only value of `0`)
    pub fn index(&self) -> u32 { self.index }

    /// An i32 initializer expression that computes the offset at which to place the elements.
    pub fn offset(&self) -> &InitExpr { &self.offset }
}

impl Deserialize for ElementSegment {
     type Error = Error;

    fn deserialize<R: io::Read>(reader: &mut R) -> Result<Self, Self::Error> {
        let index = VarUint32::deserialize(reader)?;
        let offset = InitExpr::deserialize(reader)?;
        let funcs: Vec<u32> = CountedList::<VarUint32>::deserialize(reader)?
            .into_inner()
            .into_iter()
            .map(Into::into)
            .collect();

        Ok(ElementSegment { 
            index: index.into(), 
            offset: offset,  
            members: funcs,
        })
    }   
}

impl Serialize for ElementSegment {
    type Error = Error;
    
    fn serialize<W: io::Write>(self, writer: &mut W) -> Result<(), Self::Error> {
        VarUint32::from(self.index).serialize(writer)?;
        self.offset.serialize(writer)?;
        let data = self.members;
        let counted_list = CountedListWriter::<VarUint32, _>(
            data.len(),
            data.into_iter().map(Into::into),
        );        
        counted_list.serialize(writer)?;        
        Ok(())
    }
}

/// Data segment definition.
pub struct DataSegment {
    index: u32,
    offset: InitExpr,
    value: Vec<u8>,
}

impl DataSegment {
    /// New data segments.
    pub fn new(index: u32, offset: InitExpr, value: Vec<u8>) -> Self {
        DataSegment {
            index: index,
            offset: offset,
            value: value,
        }
    }

    /// Linear memory index (currently the only valid value is `0`).
    pub fn index(&self) -> u32 { self.index }
    /// An i32 initializer expression that computes the offset at which to place the data.
    pub fn offset(&self) -> &InitExpr { &self.offset }   
    /// Initial value of the data segment.
    pub fn value(&self) -> &[u8] { &self.value }
}

impl Deserialize for DataSegment {
     type Error = Error;

    fn deserialize<R: io::Read>(reader: &mut R) -> Result<Self, Self::Error> {
        let index = VarUint32::deserialize(reader)?;
        let offset = InitExpr::deserialize(reader)?;
        let value_len = VarUint32::deserialize(reader)?;

        let mut value_buf = vec![0u8; value_len.into()];
        reader.read_exact(&mut value_buf[..])?;

        Ok(DataSegment { 
            index: index.into(), 
            offset: offset,  
            value: value_buf,
        })
    }   
}

impl Serialize for DataSegment {
    type Error = Error;
    
    fn serialize<W: io::Write>(self, writer: &mut W) -> Result<(), Self::Error> {
        VarUint32::from(self.index).serialize(writer)?;
        self.offset.serialize(writer)?;

        let value = self.value;
        VarUint32::from(value.len()).serialize(writer)?;
        writer.write_all(&value[..])?;
        Ok(())
    }
}