bump version to 1.0 tag

Author: SPY

exec/Main.hs

@@ -5,9 +5,7 @@ import qualified Data.ByteString.Lazy as LBS
 import qualified Data.ByteString.Base64.Lazy as Base64
 import Data.Maybe (fromMaybe)
 
-import qualified Language.Wasm.Lexer as Lexer
-import qualified Language.Wasm.Parser as Parser
-import qualified Language.Wasm.Binary as Binary
+import qualified Language.Wasm as Wasm
 
 import Options.Applicative
 import Data.Semigroup ((<>))
@@ -105,10 +103,7 @@ config = subparser (
   )
 
 toBinary :: LBS.ByteString -> Either String LBS.ByteString
-toBinary content = do
-    lexemes <- Lexer.scanner content
-    mod <- Parser.parseModule lexemes
-    return $ Binary.dumpModuleLazy mod
+toBinary = fmap Wasm.encodeLazy . Wasm.parse
 
 compileAs :: (LBS.ByteString -> LBS.ByteString) -> String -> String -> IO ()
 compileAs transform input output = do

src/Language/Wasm.hs

@@ -1,6 +1,48 @@
 module Language.Wasm (
-    something
+    Module,
+    ValidModule,
+    ValidationError(..),
+    parse,
+    validate,
+    Language.Wasm.parseScript,
+    encode,
+    encodeLazy,
+    decode,
+    decodeLazy,
+    Script,
+    runScript
 ) where
 
-something :: Int
-something = 42
+import qualified Data.ByteString as BS
+import qualified Data.ByteString.Lazy as LBS
+
+import Language.Wasm.Structure as Struct
+import Language.Wasm.Script as Script
+import Language.Wasm.Lexer as Lexer
+import Language.Wasm.Parser as Parser
+import Language.Wasm.Validate as Valid
+import Language.Wasm.Binary as Binary
+
+-- | Parse WebAssembly text representation to `Module`
+parse :: LBS.ByteString -> Either String Module
+parse content = Lexer.scanner content >>= Parser.parseModule
+
+-- | Parse WebAssembly extended scipt grammar
+parseScript :: LBS.ByteString -> Either String Script
+parseScript content = Lexer.scanner content >>= Parser.parseScript
+
+-- | Dump `Module` to binary representation
+encode :: Module -> BS.ByteString
+encode = dumpModule
+
+-- | Dump `Module` to binary representation lazily
+encodeLazy :: Module -> LBS.ByteString
+encodeLazy = dumpModuleLazy
+
+-- | Decode `Module` from binary representation
+decode :: BS.ByteString -> Either String Module
+decode = decodeModule
+
+-- | Decode `Module` from binary representation lazily
+decodeLazy :: LBS.ByteString -> Either String Module
+decodeLazy = decodeModuleLazy

src/Language/Wasm/Interpreter.hs

@@ -53,9 +53,8 @@ import Numeric.IEEE (IEEE, copySign, minNum, maxNum, identicalIEEE)
 import Control.Monad.Except (ExceptT, runExceptT, throwError)
 import Control.Monad.IO.Class (liftIO)
 
-import Debug.Trace as Debug
-
 import Language.Wasm.Structure as Struct
+import Language.Wasm.Validate as Valid
 import Language.Wasm.FloatUtils (
         wordToFloat,
         floatToWord,
@@ -532,8 +531,9 @@ initialize inst Module {elems, datas, start} store = do
         initData (from, mem, chunk) =
             mapM_ (\(i,b) -> IOVector.write mem i b) $ zip [from..] $ LBS.unpack chunk
 
-instantiate :: Store -> Imports -> Module -> IO (Either String (ModuleInstance, Store))
-instantiate st imps m = runExceptT $ do
+instantiate :: Store -> Imports -> Valid.ValidModule -> IO (Either String (ModuleInstance, Store))
+instantiate st imps mod = runExceptT $ do
+    let m = Valid.getModule mod
     inst <- calcInstance st imps m
     let functions = funcInstances st <> (allocFunctions inst $ Struct.functions m)
     globals <- liftIO $ (globalInstances st <>) <$> (allocAndInitGlobals inst st $ Struct.globals m)

src/Language/Wasm/Lexer.x

@@ -21,8 +21,6 @@ import Data.Word (Word8)
 import Data.List (isPrefixOf)
 import Text.Read (readEither)
 
-import qualified Debug.Trace as Debug
-
 }
 
 %wrapper "monadUserState-bytestring"

src/Language/Wasm/Parser.y

@@ -96,8 +96,6 @@ import Language.Wasm.Lexer (
         asDouble
     )
 
-import Debug.Trace as Debug
-
 }
 
 %name parseModule mod

src/Language/Wasm/Script.hs

@@ -95,12 +95,12 @@ runScript onAssertFail script = do
         addModule :: Maybe Ident -> Struct.Module -> ScriptState -> IO ScriptState
         addModule ident m st =
             case Validate.validate m of
-                Validate.Valid -> do
+                Right m -> do
                     res <- Interpreter.instantiate (store st) (buildImports st) m
                     case res of
                         Right (modInst, store') -> return $ addToStore ident modInst $ st { lastModule = Just modInst, store = store' }
                         Left reason -> error $ "Module instantiation failed dut to invalid module with reason: " ++ show reason
-                reason -> error $ "Module instantiation failed dut to invalid module with reason: " ++ show reason
+                Left reason -> error $ "Module instantiation failed dut to invalid module with reason: " ++ show reason
 
         getModule :: ScriptState -> Maybe Ident -> Maybe Interpreter.ModuleInstance
         getModule st (Just (Ident i)) = Map.lookup i (modules st)
@@ -156,7 +156,7 @@ runScript onAssertFail script = do
         checkModuleInvalid :: Struct.Module -> IO ()
         checkModuleInvalid _ = return ()
 
-        getFailureString :: Validate.ValidationResult -> [TL.Text]
+        getFailureString :: Validate.ValidationError -> [TL.Text]
         getFailureString (Validate.TypeMismatch _ _) = ["type mismatch"]
         getFailureString Validate.ResultTypeDoesntMatch = ["type mismatch"]
         getFailureString Validate.MoreThanOneMemory = ["multiple memories"]
@@ -194,8 +194,8 @@ runScript onAssertFail script = do
         runAssert st assert@(AssertInvalid moduleDef failureString) =
             let (_, m) = buildModule moduleDef in
             case Validate.validate m of
-                Validate.Valid -> onAssertFail "Invalid module pass validation" assert
-                reason ->
+                Right _ -> onAssertFail "Invalid module pass validation" assert
+                Left reason ->
                     if failureString `elem` getFailureString reason
                     then return ()
                     else
@@ -216,12 +216,12 @@ runScript onAssertFail script = do
         runAssert st assert@(AssertUnlinkable moduleDef failureString) =
             let (_, m) = buildModule moduleDef in
             case Validate.validate m of
-                Validate.Valid -> do
+                Right m -> do
                     res <- Interpreter.instantiate (store st) (buildImports st) m
                     case res of
                         Left err -> return ()
                         Right _ -> onAssertFail ("Module linking should fail with failure string " ++ show failureString) assert
-                reason -> error $ "Module linking failed dut to invalid module with reason: " ++ show reason
+                Left reason -> error $ "Module linking failed dut to invalid module with reason: " ++ show reason
         runAssert st assert@(AssertTrap (Left action) failureString) = do
             result <- runAction st action
             if isNothing result
@@ -230,12 +230,12 @@ runScript onAssertFail script = do
         runAssert st assert@(AssertTrap (Right moduleDef) failureString) =
             let (_, m) = buildModule moduleDef in
             case Validate.validate m of
-                Validate.Valid -> do
+                Right m -> do
                     res <- Interpreter.instantiate (store st) (buildImports st) m
                     case res of
                         Left "Start function terminated with trap" -> return ()
                         _ -> onAssertFail ("Module linking should fail with trap during execution of a start function") assert
-                reason -> error $ "Module linking failed dut to invalid module with reason: " ++ show reason
+                Left reason -> error $ "Module linking failed dut to invalid module with reason: " ++ show reason
         runAssert st assert@(AssertExhaustion action failureString) = do
             result <- runAction st action
             if isNothing result