Library restructure (#104)

* Move wasmer-runtime to wasmer-runtime-core

* Add the runtime library

* Fix issue with macros using wasmer_runtime, fmt

* Make default compiler dependency optional

* Add instantiate and validate functions

lib/runtime-core/src/error.rs

@@ -0,0 +1,164 @@
+use crate::types::{FuncSig, GlobalDesc, Memory, MemoryIndex, Table, TableIndex, Type};
+
+pub type Result<T> = std::result::Result<T, Box<Error>>;
+pub type CompileResult<T> = std::result::Result<T, Box<CompileError>>;
+pub type LinkResult<T> = std::result::Result<T, Vec<LinkError>>;
+pub type RuntimeResult<T> = std::result::Result<T, Box<RuntimeError>>;
+pub type CallResult<T> = std::result::Result<T, Box<CallError>>;
+
+/// This is returned when the chosen compiler is unable to
+/// successfully compile the provided webassembly module into
+/// a `Module`.
+///
+/// Comparing two `CompileError`s always evaluates to false.
+#[derive(Debug, Clone)]
+pub enum CompileError {
+    ValidationError { msg: String },
+    InternalError { msg: String },
+}
+
+impl PartialEq for CompileError {
+    fn eq(&self, _other: &CompileError) -> bool {
+        false
+    }
+}
+
+/// This is returned when the runtime is unable to
+/// correctly link the module with the provided imports.
+///
+/// Comparing two `LinkError`s always evaluates to false.
+#[derive(Debug, Clone)]
+pub enum LinkError {
+    IncorrectImportType {
+        namespace: String,
+        name: String,
+        expected: String,
+        found: String,
+    },
+    IncorrectImportSignature {
+        namespace: String,
+        name: String,
+        expected: FuncSig,
+        found: FuncSig,
+    },
+    ImportNotFound {
+        namespace: String,
+        name: String,
+    },
+    IncorrectMemoryDescription {
+        namespace: String,
+        name: String,
+        expected: Memory,
+        found: Memory,
+    },
+    IncorrectTableDescription {
+        namespace: String,
+        name: String,
+        expected: Table,
+        found: Table,
+    },
+    IncorrectGlobalDescription {
+        namespace: String,
+        name: String,
+        expected: GlobalDesc,
+        found: GlobalDesc,
+    },
+}
+
+impl PartialEq for LinkError {
+    fn eq(&self, _other: &LinkError) -> bool {
+        false
+    }
+}
+
+/// This is the error type returned when calling
+/// a webassembly function.
+///
+/// The main way to do this is `Instance.call`.
+///
+/// Comparing two `RuntimeError`s always evaluates to false.
+#[derive(Debug, Clone)]
+pub enum RuntimeError {
+    OutOfBoundsAccess { memory: MemoryIndex, addr: u32 },
+    TableOutOfBounds { table: TableIndex },
+    IndirectCallSignature { table: TableIndex },
+    IndirectCallToNull { table: TableIndex },
+    IllegalArithmeticOperation,
+    Unknown { msg: String },
+}
+
+impl PartialEq for RuntimeError {
+    fn eq(&self, _other: &RuntimeError) -> bool {
+        false
+    }
+}
+
+/// This error type is produced by calling a wasm function
+/// exported from a module.
+///
+/// If the module traps in some way while running, this will
+/// be the `CallError::Runtime(RuntimeError)` variant.
+///
+/// Comparing two `CallError`s always evaluates to false.
+#[derive(Debug, Clone)]
+pub enum CallError {
+    Signature { expected: FuncSig, found: Vec<Type> },
+    NoSuchExport { name: String },
+    ExportNotFunc { name: String },
+    Runtime(RuntimeError),
+}
+
+impl PartialEq for CallError {
+    fn eq(&self, _other: &CallError) -> bool {
+        false
+    }
+}
+
+/// The amalgamation of all errors that can occur
+/// during the compilation, instantiation, or execution
+/// of a webassembly module.
+///
+/// Comparing two `Error`s always evaluates to false.
+#[derive(Debug, Clone)]
+pub enum Error {
+    CompileError(CompileError),
+    LinkError(Vec<LinkError>),
+    RuntimeError(RuntimeError),
+    CallError(CallError),
+}
+
+impl PartialEq for Error {
+    fn eq(&self, _other: &Error) -> bool {
+        false
+    }
+}
+
+impl From<Box<CompileError>> for Box<Error> {
+    fn from(compile_err: Box<CompileError>) -> Self {
+        Box::new(Error::CompileError(*compile_err))
+    }
+}
+
+impl From<Vec<LinkError>> for Box<Error> {
+    fn from(link_err: Vec<LinkError>) -> Self {
+        Box::new(Error::LinkError(link_err))
+    }
+}
+
+impl From<Box<RuntimeError>> for Box<Error> {
+    fn from(runtime_err: Box<RuntimeError>) -> Self {
+        Box::new(Error::RuntimeError(*runtime_err))
+    }
+}
+
+impl From<Box<CallError>> for Box<Error> {
+    fn from(call_err: Box<CallError>) -> Self {
+        Box::new(Error::CallError(*call_err))
+    }
+}
+
+impl From<Box<RuntimeError>> for Box<CallError> {
+    fn from(runtime_err: Box<RuntimeError>) -> Self {
+        Box::new(CallError::Runtime(*runtime_err))
+    }
+}