rustfmt (wasmi-labs#151)

benches/build.rs

@@ -1,32 +1,31 @@
 use std::env;
 use std::process;
 
-
 fn main() {
-	println!("cargo:rerun-if-changed=./wasm-kernel/");
+    println!("cargo:rerun-if-changed=./wasm-kernel/");
 
-	// The CARGO environment variable provides a path to the executable that
-	// runs this build process.
-	let cargo_bin = env::var("CARGO").expect("CARGO env variable should be defined");
+    // The CARGO environment variable provides a path to the executable that
+    // runs this build process.
+    let cargo_bin = env::var("CARGO").expect("CARGO env variable should be defined");
 
-	// Build a release version of wasm-kernel. The code in the output wasm binary
-	// will be used in benchmarks.
-	let output = process::Command::new(cargo_bin)
-		.arg("build")
-		.arg("--target=wasm32-unknown-unknown")
-		.arg("--release")
-		.arg("--manifest-path=./wasm-kernel/Cargo.toml")
-		.arg("--verbose")
-		.output()
-		.expect("failed to execute `cargo`");
+    // Build a release version of wasm-kernel. The code in the output wasm binary
+    // will be used in benchmarks.
+    let output = process::Command::new(cargo_bin)
+        .arg("build")
+        .arg("--target=wasm32-unknown-unknown")
+        .arg("--release")
+        .arg("--manifest-path=./wasm-kernel/Cargo.toml")
+        .arg("--verbose")
+        .output()
+        .expect("failed to execute `cargo`");
 
-	if !output.status.success() {
-		let msg = format!(
-			"status: {status}\nstdout: {stdout}\nstderr: {stderr}\n",
-			status=output.status,
-			stdout=String::from_utf8_lossy(&output.stdout),
-			stderr=String::from_utf8_lossy(&output.stderr),
-		);
-		panic!("{}", msg);
-	}
+    if !output.status.success() {
+        let msg = format!(
+            "status: {status}\nstdout: {stdout}\nstderr: {stderr}\n",
+            status = output.status,
+            stdout = String::from_utf8_lossy(&output.stdout),
+            stderr = String::from_utf8_lossy(&output.stderr),
+        );
+        panic!("{}", msg);
+    }
 }

examples/interpret.rs

@@ -4,14 +4,14 @@ extern crate wasmi;
 
 use std::env::args;
 use std::fs::File;
-use wasmi::{ModuleInstance, NopExternals, RuntimeValue, ImportsBuilder, Module};
+use wasmi::{ImportsBuilder, Module, ModuleInstance, NopExternals, RuntimeValue};
 
 fn load_from_file(filename: &str) -> Module {
-	use std::io::prelude::*;
-	let mut file = File::open(filename).unwrap();
-	let mut buf = Vec::new();
-	file.read_to_end(&mut buf).unwrap();
-	Module::from_buffer(buf).unwrap()
+    use std::io::prelude::*;
+    let mut file = File::open(filename).unwrap();
+    let mut buf = Vec::new();
+    file.read_to_end(&mut buf).unwrap();
+    Module::from_buffer(buf).unwrap()
 }
 
 fn main() {
@@ -27,10 +27,10 @@ fn main() {
     let module = load_from_file(&args[1]);
 
     // Intialize deserialized module. It adds module into It expects 3 parameters:
-     // - a name for the module
-     // - a module declaration
-     // - "main" module doesn't import native module(s) this is why we don't need to provide external native modules here
-     // This test shows how to implement native module https://github.com/NikVolf/parity-wasm/blob/master/src/interpreter/tests/basics.rs#L197
+    // - a name for the module
+    // - a module declaration
+    // - "main" module doesn't import native module(s) this is why we don't need to provide external native modules here
+    // This test shows how to implement native module https://github.com/NikVolf/parity-wasm/blob/master/src/interpreter/tests/basics.rs#L197
     let main = ModuleInstance::new(&module, &ImportsBuilder::default())
         .expect("Failed to instantiate module")
         .run_start(&mut NopExternals)
@@ -40,5 +40,8 @@ fn main() {
     let argument: i32 = args[2].parse().expect("Integer argument required");
 
     // "_call" export of function to be executed with an i32 argument and prints the result of execution
-    println!("Result: {:?}", main.invoke_export("_call", &[RuntimeValue::I32(argument)], &mut NopExternals));
+    println!(
+        "Result: {:?}",
+        main.invoke_export("_call", &[RuntimeValue::I32(argument)], &mut NopExternals)
+    );
 }

examples/invoke.rs

@@ -3,9 +3,8 @@ extern crate wasmi;
 
 use std::env::args;
 
-use parity_wasm::elements::{Internal, External, Type, FunctionType, ValueType};
-use wasmi::{RuntimeValue, ModuleInstance, NopExternals, ImportsBuilder};
-
+use parity_wasm::elements::{External, FunctionType, Internal, Type, ValueType};
+use wasmi::{ImportsBuilder, ModuleInstance, NopExternals, RuntimeValue};
 
 fn main() {
     let args: Vec<_> = args().collect();
@@ -23,14 +22,19 @@ fn main() {
         // Export section has an entry with a func_name with an index inside a module
         let export_section = module.export_section().expect("No export section found");
         // It's a section with function declarations (which are references to the type section entries)
-        let function_section = module.function_section().expect("No function section found");
+        let function_section = module
+            .function_section()
+            .expect("No function section found");
         // Type section stores function types which are referenced by function_section entries
         let type_section = module.type_section().expect("No type section found");
 
         // Given function name used to find export section entry which contains
         // an `internal` field which points to the index in the function index space
-        let found_entry = export_section.entries().iter()
-            .find(|entry| func_name == entry.field()).expect(&format!("No export with name {} found", func_name));
+        let found_entry = export_section
+            .entries()
+            .iter()
+            .find(|entry| func_name == entry.field())
+            .expect(&format!("No export with name {} found", func_name));
 
         // Function index in the function index space (internally-defined + imported)
         let function_index: usize = match found_entry.internal() {
@@ -41,32 +45,59 @@ fn main() {
         // We need to count import section entries (functions only!) to subtract it from function_index
         // and obtain the index within the function section
         let import_section_len: usize = match module.import_section() {
-            Some(import) =>
-                import.entries().iter().filter(|entry| match entry.external() {
+            Some(import) => import
+                .entries()
+                .iter()
+                .filter(|entry| match entry.external() {
                     &External::Function(_) => true,
                     _ => false,
-                    }).count(),
+                })
+                .count(),
             None => 0,
         };
 
         // Calculates a function index within module's function section
         let function_index_in_section = function_index - import_section_len;
 
         // Getting a type reference from a function section entry
-        let func_type_ref: usize = function_section.entries()[function_index_in_section].type_ref() as usize;
+        let func_type_ref: usize =
+            function_section.entries()[function_index_in_section].type_ref() as usize;
 
         // Use the reference to get an actual function type
         let function_type: &FunctionType = match &type_section.types()[func_type_ref] {
             &Type::Function(ref func_type) => func_type,
         };
 
         // Parses arguments and constructs runtime values in correspondence of their types
-        function_type.params().iter().enumerate().map(|(i, value)| match value {
-            &ValueType::I32 => RuntimeValue::I32(program_args[i].parse::<i32>().expect(&format!("Can't parse arg #{} as i32", program_args[i]))),
-            &ValueType::I64 => RuntimeValue::I64(program_args[i].parse::<i64>().expect(&format!("Can't parse arg #{} as i64", program_args[i]))),
-            &ValueType::F32 => RuntimeValue::F32(program_args[i].parse::<f32>().expect(&format!("Can't parse arg #{} as f32", program_args[i])).into()),
-            &ValueType::F64 => RuntimeValue::F64(program_args[i].parse::<f64>().expect(&format!("Can't parse arg #{} as f64", program_args[i])).into()),
-        }).collect::<Vec<RuntimeValue>>()
+        function_type
+            .params()
+            .iter()
+            .enumerate()
+            .map(|(i, value)| match value {
+                &ValueType::I32 => RuntimeValue::I32(
+                    program_args[i]
+                        .parse::<i32>()
+                        .expect(&format!("Can't parse arg #{} as i32", program_args[i])),
+                ),
+                &ValueType::I64 => RuntimeValue::I64(
+                    program_args[i]
+                        .parse::<i64>()
+                        .expect(&format!("Can't parse arg #{} as i64", program_args[i])),
+                ),
+                &ValueType::F32 => RuntimeValue::F32(
+                    program_args[i]
+                        .parse::<f32>()
+                        .expect(&format!("Can't parse arg #{} as f32", program_args[i]))
+                        .into(),
+                ),
+                &ValueType::F64 => RuntimeValue::F64(
+                    program_args[i]
+                        .parse::<f64>()
+                        .expect(&format!("Can't parse arg #{} as f64", program_args[i]))
+                        .into(),
+                ),
+            })
+            .collect::<Vec<RuntimeValue>>()
     };
 
     let loaded_module = wasmi::Module::from_parity_wasm_module(module).expect("Module to be valid");
@@ -81,5 +112,9 @@ fn main() {
         .run_start(&mut NopExternals)
         .expect("Failed to run start function in module");
 
-    println!("Result: {:?}", main.invoke_export(func_name, &args, &mut NopExternals).expect(""));
+    println!(
+        "Result: {:?}",
+        main.invoke_export(func_name, &args, &mut NopExternals)
+            .expect("")
+    );
 }