From 17facb529bc3aa45e3dd78cc511dd7fd38c1b6a3 Mon Sep 17 00:00:00 2001 From: Sergey Pepyakin Date: Mon, 27 Nov 2017 16:22:00 +0300 Subject: [PATCH] =?UTF-8?q?Rename=20env=20=E2=86=92=20base.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/interpreter/emscripten.rs | 2 +- src/interpreter/mod.rs | 4 +-- src/interpreter/module.rs | 2 +- src/interpreter/{env_native.rs => native.rs} | 37 +++++++++++--------- src/interpreter/tests/basics.rs | 12 +++---- 5 files changed, 30 insertions(+), 27 deletions(-) rename src/interpreter/{env_native.rs => native.rs} (89%) diff --git a/src/interpreter/emscripten.rs b/src/interpreter/emscripten.rs index 8c8044c..d45c045 100644 --- a/src/interpreter/emscripten.rs +++ b/src/interpreter/emscripten.rs @@ -7,7 +7,7 @@ use builder::module; use elements::{Module, ExportEntry, Internal, GlobalEntry, GlobalType, ValueType, InitExpr, Opcode, Opcodes}; use interpreter::Error; -use interpreter::env_native::NATIVE_INDEX_FUNC_MIN; +use interpreter::native::NATIVE_INDEX_FUNC_MIN; use interpreter::module::{ModuleInstanceInterface, ModuleInstance, ExecutionParams, ItemIndex, CallerContext, ExportEntryType, InternalFunctionReference, InternalFunction, FunctionSignature}; use interpreter::memory::{MemoryInstance, LINEAR_MEMORY_PAGE_SIZE}; diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs index f0c056e..8cd6613 100644 --- a/src/interpreter/mod.rs +++ b/src/interpreter/mod.rs @@ -121,7 +121,7 @@ impl From for Error where U: UserError + Sized { } mod emscripten; -mod env_native; +mod native; mod imports; mod memory; mod module; @@ -143,5 +143,5 @@ pub use self::table::TableInstance; pub use self::program::ProgramInstance; pub use self::value::RuntimeValue; pub use self::variable::{VariableInstance, VariableType, ExternalVariableValue}; -pub use self::env_native::{env_native_module, UserDefinedElements, UserFunctionExecutor, UserFunctionDescriptor}; +pub use self::native::{native_module, UserDefinedElements, UserFunctionExecutor, UserFunctionDescriptor}; pub use self::emscripten::EnvParams; diff --git a/src/interpreter/module.rs b/src/interpreter/module.rs index 33b0af6..876d566 100644 --- a/src/interpreter/module.rs +++ b/src/interpreter/module.rs @@ -4,7 +4,7 @@ use std::sync::{Arc, Weak}; use std::fmt; use elements::{Module, InitExpr, Opcode, Type, FunctionType, Internal, External, BlockType, ResizableLimits, Local, ValueType}; use interpreter::Error; -use interpreter::env_native::UserFunctionDescriptor; +use interpreter::native::UserFunctionDescriptor; use interpreter::imports::ModuleImports; use interpreter::memory::MemoryInstance; use interpreter::program::ProgramInstanceEssence; diff --git a/src/interpreter/env_native.rs b/src/interpreter/native.rs similarity index 89% rename from src/interpreter/env_native.rs rename to src/interpreter/native.rs index edb75b4..ec1f5f8 100644 --- a/src/interpreter/env_native.rs +++ b/src/interpreter/native.rs @@ -1,3 +1,6 @@ +//! This module provides a way to create wasm modules that is backed in +//! a native Rust code. + use std::sync::Arc; use std::collections::HashMap; use std::borrow::Cow; @@ -79,8 +82,8 @@ pub struct UserDefinedElements<'a> { /// Native module instance. pub struct NativeModuleInstance<'a> { - /// Underllying module reference. - env: Arc, + /// Underlying module reference. + base: Arc, /// User function executor. executor: RwLock>, /// By-name functions index. @@ -95,13 +98,13 @@ pub struct NativeModuleInstance<'a> { impl<'a> NativeModuleInstance<'a> { /// Create new native module - pub fn new(env: Arc, elements: UserDefinedElements<'a>) -> Result { + pub fn new(base: Arc, elements: UserDefinedElements<'a>) -> Result { if !elements.functions.is_empty() && elements.executor.is_none() { return Err(Error::Function("trying to construct native env module with functions, but without executor".into())); } Ok(NativeModuleInstance { - env: env, + base: base, executor: RwLock::new(elements.executor), functions_by_name: elements.functions.iter().enumerate().map(|(i, f)| (f.name().to_owned(), i as u32)).collect(), functions: elements.functions, @@ -113,11 +116,11 @@ impl<'a> NativeModuleInstance<'a> { impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { fn execute_index(&self, index: u32, params: ExecutionParams) -> Result, Error> { - self.env.execute_index(index, params) + self.base.execute_index(index, params) } fn execute_export(&self, name: &str, params: ExecutionParams) -> Result, Error> { - self.env.execute_export(name, params) + self.base.execute_export(name, params) } fn export_entry<'b>(&self, name: &str, required_type: &ExportEntryType) -> Result { @@ -174,15 +177,15 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { } } - self.env.export_entry(name, required_type) + self.base.export_entry(name, required_type) } fn table(&self, index: ItemIndex) -> Result, Error> { - self.env.table(index) + self.base.table(index) } fn memory(&self, index: ItemIndex) -> Result, Error> { - self.env.memory(index) + self.base.memory(index) } fn global<'b>(&self, global_index: ItemIndex, variable_type: Option, externals: Option<&'b HashMap>>) -> Result, Error> { @@ -192,7 +195,7 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { }; if index < NATIVE_INDEX_GLOBAL_MIN { - return self.env.global(global_index, variable_type, externals); + return self.base.global(global_index, variable_type, externals); } self.globals @@ -208,7 +211,7 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { }; if index < NATIVE_INDEX_FUNC_MIN || index >= NATIVE_INDEX_GLOBAL_MIN { - return self.env.function_type(function_index); + return self.base.function_type(function_index); } Ok(FunctionSignature::User(self.functions @@ -221,11 +224,11 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { } fn function_reference<'b>(&self, index: ItemIndex, externals: Option<&'b HashMap>>) -> Result, Error> { - self.env.function_reference(index, externals) + self.base.function_reference(index, externals) } fn function_reference_indirect<'b>(&self, table_idx: u32, type_idx: u32, func_idx: u32, externals: Option<&'b HashMap>>) -> Result, Error> { - self.env.function_reference_indirect(table_idx, type_idx, func_idx, externals) + self.base.function_reference_indirect(table_idx, type_idx, func_idx, externals) } fn function_body<'b>(&'b self, _internal_index: u32) -> Result>, Error> { @@ -234,7 +237,7 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { fn call_internal_function(&self, outer: CallerContext, index: u32) -> Result, Error> { if index < NATIVE_INDEX_FUNC_MIN || index >= NATIVE_INDEX_GLOBAL_MIN { - return self.env.call_internal_function(outer, index); + return self.base.call_internal_function(outer, index); } self.functions @@ -247,9 +250,9 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { } } -/// Create wrapper for env module with given native user functions. -pub fn env_native_module<'a>(env: Arc, user_elements: UserDefinedElements<'a>) -> Result { - NativeModuleInstance::new(env, user_elements) +/// Create wrapper for a module with given native user functions. +pub fn native_module<'a>(base: Arc, user_elements: UserDefinedElements<'a>) -> Result { + NativeModuleInstance::new(base, user_elements) } impl<'a> PartialEq for UserFunctionDescriptor { diff --git a/src/interpreter/tests/basics.rs b/src/interpreter/tests/basics.rs index 2d14cf9..e9e9d6b 100644 --- a/src/interpreter/tests/basics.rs +++ b/src/interpreter/tests/basics.rs @@ -7,7 +7,7 @@ use builder::module; use elements::{ExportEntry, Internal, ImportEntry, External, GlobalEntry, GlobalType, InitExpr, ValueType, BlockType, Opcodes, Opcode, FunctionType, TableType, MemoryType}; use interpreter::{Error, UserError, ProgramInstance}; -use interpreter::env_native::{env_native_module, UserDefinedElements, UserFunctionExecutor, UserFunctionDescriptor}; +use interpreter::native::{native_module, UserDefinedElements, UserFunctionExecutor, UserFunctionDescriptor}; use interpreter::memory::MemoryInstance; use interpreter::module::{ModuleInstance, ModuleInstanceInterface, CallerContext, ItemIndex, ExecutionParams, ExportEntryType, FunctionSignature}; use interpreter::validator::{FunctionValidationContext, Validator}; @@ -213,7 +213,7 @@ fn native_env_function() { globals: HashMap::new(), functions: ::std::borrow::Cow::from(SIGNATURES), }; - let native_env_instance = Arc::new(env_native_module(env_instance, functions).unwrap()); + let native_env_instance = Arc::new(native_module(env_instance, functions).unwrap()); let params = ExecutionParams::with_external("env".into(), native_env_instance); let module = module() @@ -287,7 +287,7 @@ fn native_env_function_own_memory() { let env_instance = program.module("env").unwrap(); let memory_ref = Arc::new(OwnMemoryReference { memory: RefCell::new(None) }); let mut executor = OwnMemoryExecutor { memory_ref: memory_ref.clone() }; - let native_env_instance = Arc::new(env_native_module(env_instance, UserDefinedElements { + let native_env_instance = Arc::new(native_module(env_instance, UserDefinedElements { executor: Some(&mut executor), globals: HashMap::new(), functions: ::std::borrow::Cow::from(SIGNATURES), @@ -328,7 +328,7 @@ fn native_env_global() { let module_constructor = |elements| { let program = ProgramInstance::with_emscripten_env(Default::default()).unwrap(); let env_instance = program.module("env").unwrap(); - let native_env_instance = Arc::new(env_native_module(env_instance.clone(), elements).unwrap()); + let native_env_instance = Arc::new(native_module(env_instance.clone(), elements).unwrap()); let params = ExecutionParams::with_external("env".into(), native_env_instance); let module = module() @@ -384,7 +384,7 @@ fn native_custom_error() { globals: HashMap::new(), functions: ::std::borrow::Cow::from(SIGNATURES), }; - let native_env_instance = Arc::new(env_native_module(env_instance, functions).unwrap()); + let native_env_instance = Arc::new(native_module(env_instance, functions).unwrap()); let params = ExecutionParams::with_external("env".into(), native_env_instance); let module = module() @@ -444,7 +444,7 @@ fn env_native_export_entry_type_check() { memory: program.module("env").unwrap().memory(ItemIndex::Internal(0)).unwrap(), values: Vec::new(), }; - let native_env_instance = Arc::new(env_native_module(program.module("env").unwrap(), UserDefinedElements { + let native_env_instance = Arc::new(native_module(program.module("env").unwrap(), UserDefinedElements { executor: Some(&mut function_executor), globals: vec![("ext_global".into(), Arc::new(VariableInstance::new(false, VariableType::I32, RuntimeValue::I32(1312)).unwrap()))].into_iter().collect(), functions: ::std::borrow::Cow::from(SIGNATURES),