From fc677010d14fa5e3b062d86926be883577ada3ed Mon Sep 17 00:00:00 2001 From: Andrew Dirksen Date: Wed, 21 Nov 2018 18:04:04 -0800 Subject: [PATCH] change pub(crate) to pub where possible --- src/common/stack.rs | 31 ++++++++++++++++++++----------- src/runner.rs | 4 ++-- 2 files changed, 22 insertions(+), 13 deletions(-) diff --git a/src/common/stack.rs b/src/common/stack.rs index c9d8409..0c4743a 100644 --- a/src/common/stack.rs +++ b/src/common/stack.rs @@ -79,7 +79,7 @@ impl StackWithLimit { /// /// Returns Err(StackOverflow) if stack is already full. #[inline] - pub(crate) fn push(&mut self, value: T) -> Result<(), StackOverflow> { + pub fn push(&mut self, value: T) -> Result<(), StackOverflow> { if self.stack.len() == self.stack.capacity() { if self.stack.len() == self.limit { return Err(StackOverflow); @@ -106,7 +106,7 @@ impl StackWithLimit { Ok(()) } - pub(crate) fn pop(&mut self) -> Option { + pub fn pop(&mut self) -> Option { self.stack.pop() } @@ -114,7 +114,7 @@ impl StackWithLimit { /// If this is called on a zero length stack, bad things will happen. /// Do not call this method unless you can prove the stack has length. #[inline] - pub(crate) unsafe fn pop_unchecked(&mut self) -> T { + pub unsafe fn pop_unchecked(&mut self) -> T { debug_assert!(self.stack.len() > 0); let len = self.stack.len(); self.stack.set_len(len - 1); @@ -126,7 +126,16 @@ impl StackWithLimit { /// `bstack.nth_from_top(0)` gets the top of the stack /// /// `bstack.nth_from_top(1)` gets the item just below the stack - pub(crate) fn nth_from_top(&self, depth: usize) -> Option<&T> { + /// + /// ``` + /// # extern crate wasmi; + /// # use wasmi::{StackWithLimit, StackSize}; + /// let bstack = StackWithLimit::::with_size(StackSize::from_element_count(2)); + /// bstack.push(4); + /// assert_eq!(bstack.nth_from_top(0, Some(&4)); + /// assert_eq!(bstack.nth_from_top(1, None); + /// ``` + pub fn nth_from_top(&self, depth: usize) -> Option<&T> { // Be cognizant of integer underflow and overflow here. Both are possible in this situation. // len() is unsigned, so if len() == 0, subtraction is a problem // depth can legally be 2^32. On a 32 bit system, adding may overflow @@ -141,7 +150,7 @@ impl StackWithLimit { /// Return mutable reference to item `depth` distance away from top /// /// Does not check whether depth is in range. - pub(crate) fn nth_from_top_mut_unchecked(&mut self, depth: usize) -> &mut T { + pub fn nth_from_top_mut_unchecked(&mut self, depth: usize) -> &mut T { let offset = self.stack.len() - 1 - depth; &mut self.stack[offset] } @@ -157,7 +166,7 @@ impl StackWithLimit { /// /// Panics if `a` or `b` are out of bound. #[inline] - pub(crate) fn swap(&mut self, a: usize, b: usize) { + pub fn swap(&mut self, a: usize, b: usize) { self.stack.swap(a, b) } @@ -174,25 +183,25 @@ impl StackWithLimit { self.stack.swap_remove(index) } - pub(crate) fn top(&self) -> Option<&T> { + pub fn top(&self) -> Option<&T> { self.stack.last() } - pub(crate) fn top_mut(&mut self) -> Option<&mut T> { + pub fn top_mut(&mut self) -> Option<&mut T> { self.stack.last_mut() } // Same as Vec::[truncate](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.truncate) - pub(crate) fn truncate(&mut self, new_size: usize) { + pub fn truncate(&mut self, new_size: usize) { self.stack.truncate(new_size) } #[inline] - pub(crate) fn len(&self) -> usize { + pub fn len(&self) -> usize { self.stack.len() } - pub(crate) fn is_empty(&self) -> bool { + pub fn is_empty(&self) -> bool { self.stack.is_empty() } } diff --git a/src/runner.rs b/src/runner.rs index 8f001a2..6933e66 100644 --- a/src/runner.rs +++ b/src/runner.rs @@ -216,7 +216,7 @@ impl Interpreter { self.state = InterpreterState::Initialized; } - pub(crate) fn state(&self) -> &InterpreterState { + pub fn state(&self) -> &InterpreterState { &self.state } @@ -1228,7 +1228,7 @@ pub struct FunctionContext { } impl FunctionContext { - pub(crate) fn new(function: FuncRef) -> Self { + pub fn new(function: FuncRef) -> Self { let module = match function.as_internal() { FuncInstanceInternal::Internal { module, .. } => module.upgrade().expect("module deallocated"), FuncInstanceInternal::Host { .. } => panic!("Host functions can't be called as internally defined functions; Thus FunctionContext can be created only with internally defined functions; qed"),