      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
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200

    use alloc::borrow::Cow;

    use parity_wasm::elements::{
        FunctionType, GlobalType, MemoryType, TableType, ValueType as EValueType,
    };

    /// Signature of a [function].
    ///
    /// Signature of a function consists of zero or more parameter [types][type] and zero or one return [type].
    ///
    /// Two signatures are considered equal if they have equal list of parameters and equal return types.
    ///
    /// [type]: enum.ValueType.html
    /// [function]: struct.FuncInstance.html
    #[derive(Debug, Clone, PartialEq, Eq)]
    pub struct Signature {
        params: Cow<'static, [ValueType]>,
        return_type: Option<ValueType>,
    }

    impl Signature {
        /// Creates new signature with givens
        /// parameter types and optional return type.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use wasmi::{Signature, ValueType};
        ///
        /// // s1: (i32) -> ()
        /// let s1 = Signature::new(&[ValueType::I32][..], None);
        ///
        /// // s2: () -> i32
        /// let s2 = Signature::new(&[][..], Some(ValueType::I32));
        ///
        /// // s3: (I64) -> ()
        /// let dynamic_params = vec![ValueType::I64];
        /// let s3 = Signature::new(dynamic_params, None);
        /// ```
        pub fn new<C: Into<Cow<'static, [ValueType]>>>(
            params: C,
            return_type: Option<ValueType>,
        ) -> Signature {
            Signature {
                params: params.into(),
                return_type: return_type,
            }
        }

        /// Returns parameter types of this signature.
        pub fn params(&self) -> &[ValueType] {
            &self.params.as_ref()
        }

        /// Returns return type of this signature.
        pub fn return_type(&self) -> Option<ValueType> {
            self.return_type
        }

        pub(crate) fn from_elements(func_type: &FunctionType) -> Signature {
            Signature {
                params: func_type
                    .params()
                    .iter()
                    .cloned()
                    .map(ValueType::from_elements)
                    .collect(),
                return_type: func_type.return_type().map(ValueType::from_elements),
            }
        }
    }

    /// Type of a value.
    ///
    /// See [`RuntimeValue`] for details.
    ///
    /// [`RuntimeValue`]: enum.RuntimeValue.html
    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
    pub enum ValueType {
        /// 32-bit signed or unsigned integer.
        I32,
        /// 64-bit signed or unsigned integer.
        I64,
        /// 32-bit IEEE 754-2008 floating point number.
        F32,
        /// 64-bit IEEE 754-2008 floating point number.
        F64,
    }

    impl ValueType {
        pub(crate) fn from_elements(value_type: EValueType) -> ValueType {
            match value_type {
                EValueType::I32 => ValueType::I32,
                EValueType::I64 => ValueType::I64,
                EValueType::F32 => ValueType::F32,
                EValueType::F64 => ValueType::F64,
            }
        }

        pub(crate) fn into_elements(self) -> EValueType {
            match self {
                ValueType::I32 => EValueType::I32,
                ValueType::I64 => EValueType::I64,
                ValueType::F32 => EValueType::F32,
                ValueType::F64 => EValueType::F64,
            }
        }
    }

    /// Description of a global variable.
    ///
    /// Primarly used to describe imports of global variables.
    /// See [`ImportResolver`] for details.
    ///
    /// [`ImportResolver`]: trait.ImportResolver.html
    pub struct GlobalDescriptor {
        value_type: ValueType,
        mutable: bool,
    }

    impl GlobalDescriptor {
        pub(crate) fn from_elements(global_type: &GlobalType) -> GlobalDescriptor {
            GlobalDescriptor {
                value_type: ValueType::from_elements(global_type.content_type()),
                mutable: global_type.is_mutable(),
            }
        }

        /// Returns [`ValueType`] of the requested global.
        ///
        /// [`ValueType`]: enum.ValueType.html
        pub fn value_type(&self) -> ValueType {
            self.value_type
        }

        /// Returns whether the requested global mutable.
        pub fn is_mutable(&self) -> bool {
            self.mutable
        }
    }

    /// Description of a table.
    ///
    /// Primarly used to describe imports of tables.
    /// See [`ImportResolver`] for details.
    ///
    /// [`ImportResolver`]: trait.ImportResolver.html
    pub struct TableDescriptor {
        initial: u32,
        maximum: Option<u32>,
    }

    impl TableDescriptor {
        pub(crate) fn from_elements(table_type: &TableType) -> TableDescriptor {
            TableDescriptor {
                initial: table_type.limits().initial(),
                maximum: table_type.limits().maximum(),
            }
        }

        /// Returns initial size of the requested table.
        pub fn initial(&self) -> u32 {
            self.initial
        }

        /// Returns maximum size of the requested table.
        pub fn maximum(&self) -> Option<u32> {
            self.maximum
        }
    }

    /// Description of a linear memory.
    ///
    /// Primarly used to describe imports of linear memories.
    /// See [`ImportResolver`] for details.
    ///
    /// [`ImportResolver`]: trait.ImportResolver.html
    pub struct MemoryDescriptor {
        initial: u32,
        maximum: Option<u32>,
    }

    impl MemoryDescriptor {
        pub(crate) fn from_elements(memory_type: &MemoryType) -> MemoryDescriptor {
            MemoryDescriptor {
                initial: memory_type.limits().initial(),
                maximum: memory_type.limits().maximum(),
            }
        }

        /// Returns initial size (in pages) of the requested memory.
        pub fn initial(&self) -> u32 {
            self.initial
        }

        /// Returns maximum size (in pages) of the requested memory.
        pub fn maximum(&self) -> Option<u32> {
            self.maximum
        }
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)