use super::*;

/// An encoder for the instance section.

///

/// Note that this is part of the [module linking proposal][proposal] and is not

/// currently part of stable WebAssembly.

///

/// [proposal]: https://github.com/webassembly/module-linking

///

/// # Example

///

/// ```

/// use wasm_encoder::{Module, InstanceSection, Export};

///

/// let mut instances = InstanceSection::new();

/// instances.instantiate(0, vec![

///     ("x", Export::Function(0)),

///     ("", Export::Module(2)),

///     ("foo", Export::Global(0)),

/// ]);

///

/// let mut module = Module::new();

/// module.section(&instances);

///

/// let wasm_bytes = module.finish();

/// ```

#[derive(Clone, Debug)]

pub struct InstanceSection {

    bytes: Vec<u8>,

    num_added: u32,

}

impl InstanceSection {

    /// Construct a new instance section encoder.

    pub fn new() -> InstanceSection {

        InstanceSection {

            bytes: vec![],

            num_added: 0,

        }

    }

    /// Define an instantiation of the given module with the given items as

    /// arguments to the instantiation.

    pub fn instantiate<'a, I>(&mut self, module: u32, args: I) -> &mut Self

    where

        I: IntoIterator<Item = (&'a str, Export)>,

        I::IntoIter: ExactSizeIterator,

    {

        let args = args.into_iter();

        self.bytes.push(0x00);

        self.bytes.extend(encoders::u32(module));

        self.bytes

            .extend(encoders::u32(u32::try_from(args.len()).unwrap()));

        for (name, export) in args {

            self.bytes.extend(encoders::str(name));

            export.encode(&mut self.bytes);

        }

        self.num_added += 1;

        self

    }

<wasm_encoder::instances::InstanceSection>::instantiate::<core::iter::adapters::map::Map<core::slice::iter::Iter<(alloc::string::String, wasm_smith::Export)>, <wasm_smith::ConfiguredModule<wasm_smith::config::SwarmConfig>>::encode_instances::{closure#0}>>

Line

Count

Source

44

106k

    pub fn instantiate<'a, I>(&mut self, module: u32, args: I) -> &mut Self

45

106k

    where

46

106k

        I: IntoIterator<Item = (&'a str, Export)>,

47

106k

        I::IntoIter: ExactSizeIterator,

48

106k

    {

49

106k

        let args = args.into_iter();

50

106k

51

106k

        self.bytes.push(0x00);

52

106k

        self.bytes.extend(encoders::u32(module));

53

106k

        self.bytes

54

106k

            .extend(encoders::u32(u32::try_from(args.len()).unwrap()));

55

175k

        for (name, export) in args {

56

68.5k

            self.bytes.extend(encoders::str(name));

57

68.5k

            export.encode(&mut self.bytes);

58

68.5k

        }

59

106k

        self.num_added += 1;

60

106k

        self

61

106k

    }

Unexecuted instantiation: <wasm_encoder::instances::InstanceSection>::instantiate::<core::iter::adapters::map::Map<core::slice::iter::Iter<(alloc::string::String, wasm_smith::Export)>, <wasm_smith::ConfiguredModule<wasm_smith::config::DefaultConfig>>::encode_instances::{closure#0}>>

Unexecuted instantiation: <wasm_encoder::instances::InstanceSection>::instantiate::<core::iter::adapters::map::Map<core::slice::iter::Iter<(alloc::string::String, wasm_smith::Export)>, <wasm_smith::ConfiguredModule<wasm_smith::config::SwarmConfig>>::encode_instances::{closure#0}>>

}

impl Section for InstanceSection {

    fn id(&self) -> u8 {

        SectionId::Instance.into()

    }

    fn encode<S>(&self, sink: &mut S)

    where

        S: Extend<u8>,

    {

        let num_added = encoders::u32(self.num_added);

        let n = num_added.len();

        sink.extend(

            encoders::u32(u32::try_from(n + self.bytes.len()).unwrap())

                .chain(num_added)

                .chain(self.bytes.iter().copied()),

        );

    }

}