Move build logic to lib (#97)

* refactored out build to lib

* save_raw returns

* fix indentations and other small fixes

* fix build API

* rename Target to SourceTarget

* fix formatting

* make join runtime_type into runtime_type and runtime_version

src/build.rs

@@ -0,0 +1,123 @@
+use std;
+use super::{
+	CREATE_SYMBOL,
+	CALL_SYMBOL,
+	optimize,
+	pack_instance,
+	ununderscore_funcs,
+	externalize_mem,
+	shrink_unknown_stack,
+	inject_runtime_type,
+	PackingError,
+	OptimizerError,
+};
+use parity_wasm;
+use parity_wasm::elements;
+
+#[derive(Debug)]
+pub enum Error {
+	Encoding(elements::Error),
+	Packing(PackingError),
+	NoCreateSymbolFound,
+	Optimizer,
+}
+
+impl From<OptimizerError> for Error {
+	fn from(_err: OptimizerError) -> Self {
+		Error::Optimizer
+	}
+}
+
+impl From<PackingError> for Error {
+	fn from(err: PackingError) -> Self {
+		Error::Packing(err)
+	}
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum SourceTarget {
+	Emscripten,
+	Unknown,
+}
+
+impl std::fmt::Display for Error {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+		use self::Error::*;
+		match *self {
+			Encoding(ref err) => write!(f, "Encoding error ({})", err),
+			Optimizer => write!(f, "Optimization error due to missing export section. Pointed wrong file?"),
+			Packing(ref e) => write!(f, "Packing failed due to module structure error: {}. Sure used correct libraries for building contracts?", e),
+			NoCreateSymbolFound => write!(f, "Packing failed: no \"{}\" symbol found?", CREATE_SYMBOL),
+		}
+	}
+}
+
+fn has_ctor(module: &elements::Module) -> bool {
+	if let Some(ref section) = module.export_section() {
+		section.entries().iter().any(|e| CREATE_SYMBOL == e.field())
+	} else {
+		false
+	}
+}
+
+pub fn build(
+	mut module: elements::Module,
+	constructor: bool,
+	source_target: SourceTarget,
+	runtime_type_version: Option<([u8; 4], u32)>,
+	public_api_entries: &[&str],
+	enforce_stack_adjustment: bool,
+	stack_size: u32,
+	skip_optimization: bool,
+) -> Result<(elements::Module, Option<elements::Module>), Error> {
+
+	if let SourceTarget::Emscripten = source_target {
+		module = ununderscore_funcs(module);
+	}
+
+	if let SourceTarget::Unknown = source_target {
+		// 49152 is 48kb!
+		if enforce_stack_adjustment {
+			assert!(stack_size <= 1024*1024);
+			let (new_module, new_stack_top) = shrink_unknown_stack(module, 1024 * 1024 - stack_size);
+			module = new_module;
+			let mut stack_top_page = new_stack_top / 65536;
+			if new_stack_top % 65536 > 0 { stack_top_page += 1 };
+			module = externalize_mem(module, Some(stack_top_page), 16);
+		} else {
+			module = externalize_mem(module, None, 16);
+		}
+	}
+
+	if let Some(runtime_type_version) = runtime_type_version {
+		let (runtime_type, runtime_version) = runtime_type_version;
+		module = inject_runtime_type(module, runtime_type, runtime_version);
+	}
+
+	let mut ctor_module = module.clone();
+
+	let mut public_api_entries = public_api_entries.to_vec();
+	public_api_entries.push(CALL_SYMBOL);
+	if !skip_optimization {
+		optimize(
+			&mut module,
+			public_api_entries,
+		)?;
+	}
+
+	if constructor {
+		if !has_ctor(&ctor_module) {
+			Err(Error::NoCreateSymbolFound)?
+		}
+		if !skip_optimization {
+			optimize(&mut ctor_module, vec![CREATE_SYMBOL])?;
+		}
+		let ctor_module = pack_instance(
+			parity_wasm::serialize(module.clone()).map_err(Error::Encoding)?,
+			ctor_module.clone(),
+		)?;
+		Ok((module, Some(ctor_module)))
+	} else {
+		Ok((module, None))
+	}
+}

src/lib.rs

@@ -15,6 +15,7 @@ pub static RET_SYMBOL: &'static str = "ret";
 
 pub mod rules;
 
+mod build;
 mod optimizer;
 mod gas;
 mod symbols;
@@ -24,6 +25,7 @@ mod runtime_type;
 
 pub mod stack_height;
 
+pub use build::{build, SourceTarget, Error as BuildError};
 pub use optimizer::{optimize, Error as OptimizerError};
 pub use gas::inject_gas_counter;
 pub use ext::{externalize, externalize_mem, underscore_funcs, ununderscore_funcs, shrink_unknown_stack};

src/runtime_type.rs

@@ -2,7 +2,7 @@ use parity_wasm::{elements, builder};
 use self::elements::{ Module, GlobalEntry, External, ExportEntry, GlobalType, ValueType, InitExpr, Instruction, Internal };
 use byteorder::{ LittleEndian, ByteOrder };
 
-pub fn inject_runtime_type(module: Module, runtime_type: &[u8], runtime_version: u32) -> Module {
+pub fn inject_runtime_type(module: Module, runtime_type: [u8; 4], runtime_version: u32) -> Module {
 	let runtime_type: u32 = LittleEndian::read_u32(&runtime_type);
 	let globals_count: u32 = match module.global_section() {
 		Some(ref section) => section.entries().len() as u32,
@@ -33,7 +33,9 @@ mod tests {
 		let mut module = builder::module()
 			.with_global(GlobalEntry::new(GlobalType::new(ValueType::I32, false), InitExpr::new(vec![Instruction::I32Const(42 as i32)])))
 		.build();
-		module = inject_runtime_type(module, b"emcc", 1);
+		let mut runtime_type: [u8; 4] = Default::default();
+		runtime_type.copy_from_slice(b"emcc");
+		module = inject_runtime_type(module, runtime_type, 1);
 		let global_section = module.global_section().expect("Global section expected");
 		assert_eq!(3, global_section.entries().len());
 		let export_section = module.export_section().expect("Export section expected");