Refactor into shared support module.

executor/src/wasm_executor.rs

@@ -110,12 +110,12 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		this.heap.deallocate(addr);
 		println!("free {}", addr)
 	},
-	set_storage(key_data: *const u8, key_len: i32, value_data: *const u8, value_len: i32) => {
+	ext_set_storage(key_data: *const u8, key_len: i32, value_data: *const u8, value_len: i32) => {
 		if let (Ok(key), Ok(value)) = (this.memory.get(key_data, key_len as usize), this.memory.get(value_data, value_len as usize)) {
 			this.ext.set_storage(key, value);
 		}
 	},
-	get_allocated_storage(key_data: *const u8, key_len: i32, written_out: *mut i32) -> *mut u8 => {
+	ext_get_allocated_storage(key_data: *const u8, key_len: i32, written_out: *mut i32) -> *mut u8 => {
 		let (offset, written) = if let Ok(key) = this.memory.get(key_data, key_len as usize) {
 			if let Ok(value) = this.ext.storage(&key) {
 				let offset = this.heap.allocate(value.len() as u32) as u32;

runtime/build.sh

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 cargo +nightly build --target=wasm32-unknown-unknown --release
-dirs=`find * -maxdepth 0 -type d | grep -v pwasm-`
+dirs=`find * -maxdepth 0 -type d | grep -v pwasm- | grep -v support`
 for i in $dirs
 do
 	if [[ -e $i/Cargo.toml ]]

runtime/polkadot/Cargo.toml

@@ -7,5 +7,4 @@ authors = ["Parity Technologies <[email protected]>"]
 crate-type = ["cdylib"]
 
 [dependencies]
-pwasm-libc = { path = "../pwasm-libc", version = "0.1" }
-pwasm-alloc = { path = "../pwasm-alloc", version = "0.1" }
+runtime-support = { path = "../support", version = "0.1" }

runtime/polkadot/src/lib.rs

@@ -3,149 +3,33 @@
 #![cfg_attr(feature = "strict", deny(warnings))]
 
 #![feature(alloc)]
-
 extern crate alloc;
 use alloc::vec::Vec;
 
-extern crate pwasm_libc;
-extern crate pwasm_alloc;
-
-#[lang = "panic_fmt"]
-#[no_mangle]
-pub fn panic_fmt() -> ! {
-	  loop {}
-}
-
-extern "C" {
-	fn ext_print(utf8_data: *const u8, utf8_len: i32);
-	fn ext_print_num(value: u64);
-	fn set_storage(key_data: *const u8, key_len: i32, value_data: *const u8, value_len: i32);
-	fn get_allocated_storage(key_data: *const u8, key_len: i32, written_out: *mut i32) -> *mut u8;
-}
-
-pub mod state {
-	use alloc::vec::Vec;
-	use super::{get_allocated_storage, set_storage as super_set_storage};
-
-	pub fn storage(key: &[u8]) -> Vec<u8> {
-		let mut length: i32 = 0;
-		unsafe {
-			let ptr = get_allocated_storage(&key[0], key.len() as i32, &mut length);
-			Vec::from_raw_parts(ptr, length as usize, length as usize)
-		}
-	}
-
-	pub fn set_storage(key: &[u8], value: &[u8]) {
-		unsafe {
-			super_set_storage(
-				&key[0] as *const u8, key.len() as i32,
-				&value[0] as *const u8, value.len() as i32
-			);
-		}
-	}
-
-	pub fn code() -> Vec<u8> {
-		storage(b"\0code")
-	}
-
-	pub fn set_code(new: &[u8]) {
-		set_storage(b"\0code", new)
-	}
-
-	fn value_vec(mut value: usize, initial: Vec<u8>) -> Vec<u8> {
-		let mut acc = initial;
-		while value > 0 {
-			acc.push(value as u8);
-			value /= 256;
-		}
-		acc
-	}
-
-	pub fn set_validator(index: usize, validator: &[u8]) {
-		set_storage(&value_vec(index, b"\0validator".to_vec()), validator);
-	}
-
-	pub fn validator(index: usize) -> Vec<u8> {
-		storage(&value_vec(index, b"\0validator".to_vec()))
-	}
-
-	pub fn set_validator_count(count: usize) {
-		(count..validator_count()).for_each(|i| set_validator(i, &[]));
-		set_storage(b"\0validator_count", &value_vec(count, Vec::new()));
-	}
-
-	pub fn validator_count() -> usize {
-		storage(b"\0validator_count").into_iter().rev().fold(0, |acc, i| (acc << 8) + (i as usize))
-	}
-
-	pub fn validators() -> Vec<Vec<u8>> {
-		(0..validator_count()).into_iter().map(validator).collect()
-	}
-
-	pub fn set_validators(validators: &[&[u8]]) {
-		set_validator_count(validators.len());
-		validators.iter().enumerate().for_each(|(v, i)| set_validator(v, i));
-	}
-}
-
-trait Printable {
-	fn print(self);
-}
-
-impl<'a> Printable for &'a [u8] {
-	fn print(self) {
-		unsafe {
-			ext_print(&self[0] as *const u8, self.len() as i32);
-		}
-	}
-}
-
-impl Printable for u64 {
-	fn print(self) {
-		unsafe { ext_print_num(self); }
-	}
-}
-
-fn print<T: Printable + Sized>(value: T) {
-	value.print();
-}
-
-macro_rules! impl_stub {
-	($name:ident) => {
-		pub mod _internal {
-			#[no_mangle]
-			pub fn $name(input_data: *mut u8, input_len: usize) -> u64 {
-				let input = unsafe {
-					super::alloc::vec::Vec::from_raw_parts(input_data, input_len, input_len)
-				};
-
-				let output = super::$name(input);
-				&output[0] as *const u8 as u64 + ((output.len() as u64) << 32)
-			}
-		}
-	}
-}
+#[macro_use]
+extern crate runtime_support;
+use runtime_support::{set_storage, code, set_code, storage, validators, set_validators, print};
 
 impl_stub!(test_data_in);
 fn test_data_in(input: Vec<u8>) -> Vec<u8> {
 	print(b"set_storage" as &[u8]);
-	state::set_storage(b"input", &input);
+	set_storage(b"input", &input);
 
 	print(b"code" as &[u8]);
-	state::set_storage(b"code", &state::code());
+	set_storage(b"code", &code());
 
 	print(b"set_code" as &[u8]);
-	state::set_code(&input);
+	set_code(&input);
 
 	print(b"storage" as &[u8]);
-	let copy = state::storage(b"input");
+	let copy = storage(b"input");
 
 	print(b"validators" as &[u8]);
-	let mut v = state::validators();
+	let mut v = validators();
 	v.push(copy);
 
 	print(b"set_validators" as &[u8]);
-	state::set_validators(&v.iter().map(Vec::as_slice).collect::<Vec<_>>());
+	set_validators(&v.iter().map(Vec::as_slice).collect::<Vec<_>>());
 
 	print(b"finished!" as &[u8]);
 	b"all ok!".to_vec()

runtime/support/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "runtime-support"
+version = "0.1.0"
+authors = ["Parity Technologies <[email protected]>"]
+
+[dependencies]
+pwasm-libc = { path = "../pwasm-libc", version = "0.1" }
+pwasm-alloc = { path = "../pwasm-alloc", version = "0.1" }
+
+[features]
+strict = []

runtime/support/src/lib.rs

@@ -0,0 +1,123 @@
+#![no_std]
+#![feature(lang_items)]
+#![cfg_attr(feature = "strict", deny(warnings))]
+
+#![feature(alloc)]
+
+extern crate alloc;
+use alloc::vec::Vec;
+
+extern crate pwasm_libc;
+extern crate pwasm_alloc;
+
+#[lang = "panic_fmt"]
+#[no_mangle]
+pub fn panic_fmt() -> ! {
+	  loop {}
+}
+
+extern "C" {
+	fn ext_print(utf8_data: *const u8, utf8_len: i32);
+	fn ext_print_num(value: u64);
+	fn ext_set_storage(key_data: *const u8, key_len: i32, value_data: *const u8, value_len: i32);
+	fn ext_get_allocated_storage(key_data: *const u8, key_len: i32, written_out: *mut i32) -> *mut u8;
+}
+
+pub fn storage(key: &[u8]) -> Vec<u8> {
+	let mut length: i32 = 0;
+	unsafe {
+		let ptr = ext_get_allocated_storage(&key[0], key.len() as i32, &mut length);
+		Vec::from_raw_parts(ptr, length as usize, length as usize)
+	}
+}
+
+pub fn set_storage(key: &[u8], value: &[u8]) {
+	unsafe {
+		ext_set_storage(
+			&key[0] as *const u8, key.len() as i32,
+			&value[0] as *const u8, value.len() as i32
+		);
+	}
+}
+
+pub fn code() -> Vec<u8> {
+	storage(b"\0code")
+}
+
+pub fn set_code(new: &[u8]) {
+	set_storage(b"\0code", new)
+}
+
+fn value_vec(mut value: usize, initial: Vec<u8>) -> Vec<u8> {
+	let mut acc = initial;
+	while value > 0 {
+		acc.push(value as u8);
+		value /= 256;
+	}
+	acc
+}
+
+pub fn set_validator(index: usize, validator: &[u8]) {
+	set_storage(&value_vec(index, b"\0validator".to_vec()), validator);
+}
+
+pub fn validator(index: usize) -> Vec<u8> {
+	storage(&value_vec(index, b"\0validator".to_vec()))
+}
+
+pub fn set_validator_count(count: usize) {
+	(count..validator_count()).for_each(|i| set_validator(i, &[]));
+	set_storage(b"\0validator_count", &value_vec(count, Vec::new()));
+}
+
+pub fn validator_count() -> usize {
+	storage(b"\0validator_count").into_iter().rev().fold(0, |acc, i| (acc << 8) + (i as usize))
+}
+
+pub fn validators() -> Vec<Vec<u8>> {
+	(0..validator_count()).into_iter().map(validator).collect()
+}
+
+pub fn set_validators(validators: &[&[u8]]) {
+	set_validator_count(validators.len());
+	validators.iter().enumerate().for_each(|(v, i)| set_validator(v, i));
+}
+
+pub trait Printable {
+	fn print(self);
+}
+
+impl<'a> Printable for &'a [u8] {
+	fn print(self) {
+		unsafe {
+			ext_print(&self[0] as *const u8, self.len() as i32);
+		}
+	}
+}
+
+impl Printable for u64 {
+	fn print(self) {
+		unsafe { ext_print_num(self); }
+	}
+}
+
+pub fn print<T: Printable + Sized>(value: T) {
+	value.print();
+}
+
+#[macro_export]
+macro_rules! impl_stub {
+	($name:ident) => {
+		pub mod _internal {
+			#[no_mangle]
+			pub fn $name(input_data: *mut u8, input_len: usize) -> u64 {
+				let input = unsafe {
+					super::alloc::vec::Vec::from_raw_parts(input_data, input_len, input_len)
+				};
+
+				let output = super::$name(input);
+				&output[0] as *const u8 as u64 + ((output.len() as u64) << 32)
+			}
+		}
+	}
+}

runtime/test/Cargo.toml

@@ -7,5 +7,4 @@ authors = ["Parity Technologies <[email protected]>"]
 crate-type = ["cdylib"]
 
 [dependencies]
-pwasm-libc = { path = "../pwasm-libc", version = "0.1" }
-pwasm-alloc = { path = "../pwasm-alloc", version = "0.1" }
+runtime-support = { path = "../support", version = "0.1" }