     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

    use alloc::rc::Rc;
    use core::cell::Cell;
    use parity_wasm::elements::ValueType as EValueType;
    use types::ValueType;
    use value::RuntimeValue;
    use Error;

    /// Reference to a global variable (See [`GlobalInstance`] for details).
    ///
    /// This reference has a reference-counting semantics.
    ///
    /// [`GlobalInstance`]: struct.GlobalInstance.html
    #[derive(Clone, Debug)]
    pub struct GlobalRef(Rc<GlobalInstance>);

    impl ::core::ops::Deref for GlobalRef {
        type Target = GlobalInstance;
        fn deref(&self) -> &GlobalInstance {
            &self.0
        }
    }

    /// Runtime representation of a global variable (or `global` for short).
    ///
    /// Global contains a value of a specified type and flag which specifies whether this
    /// global are mutable or immutable. Neither type of the value nor immutability can't be changed
    /// after creation.
    ///
    /// Attempt to change value of immutable global or to change type of
    /// the value (e.g. assign [`I32`] value to a global that was created with [`I64`] type) will lead to an error.
    ///
    /// [`I32`]: enum.RuntimeValue.html#variant.I32
    /// [`I64`]: enum.RuntimeValue.html#variant.I64
    #[derive(Debug)]
    pub struct GlobalInstance {
        val: Cell<RuntimeValue>,
        mutable: bool,
    }

    impl GlobalInstance {
        /// Allocate a global variable instance.
        ///
        /// Since it is possible to export only immutable globals,
        /// users likely want to set `mutable` to `false`.
        pub fn alloc(val: RuntimeValue, mutable: bool) -> GlobalRef {
            GlobalRef(Rc::new(GlobalInstance {
                val: Cell::new(val),
                mutable,
            }))
        }

        /// Change the value of this global variable.
        ///
        /// # Errors
        ///
        /// Returns `Err` if this global isn't mutable or if
        /// type of `val` doesn't match global's type.
        pub fn set(&self, val: RuntimeValue) -> Result<(), Error> {
            if !self.mutable {
                return Err(Error::Global(
                    "Attempt to change an immutable variable".into(),
                ));
            }
            if self.value_type() != val.value_type() {
                return Err(Error::Global("Attempt to change variable type".into()));
            }
            self.val.set(val);
            Ok(())
        }

        /// Get the value of this global variable.
        pub fn get(&self) -> RuntimeValue {
            self.val.get()
        }

        /// Returns if this global variable is mutable.
        ///
        /// Note: Imported and/or exported globals are always immutable.
        pub fn is_mutable(&self) -> bool {
            self.mutable
        }

        /// Returns value type of this global variable.
        pub fn value_type(&self) -> ValueType {
            self.val.get().value_type()
        }

        pub(crate) fn elements_value_type(&self) -> EValueType {
            self.value_type().into_elements()
        }
    }

# 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`)