Fix bug in IO runtime

runtime/src/juvix/arch/wasi.c

@@ -5,11 +5,15 @@
 
 _Noreturn void exit(int code) { proc_exit(code); }
 
-void puts(const char *msg) {
+void puts_nonl(const char *msg) {
     size_t n = 0;
     while (msg[n]) ++n;
     ciovec_t vec = {.buf = (uint8_t *)msg, .buf_len = n};
     fd_write(1, &vec, 1, 0);
+}
+
+void puts(const char *msg) {
+    puts_nonl(msg);
     uint8_t c = '\n';
     ciovec_t vec1 = {.buf = &c, .buf_len = 1};
     fd_write(1, &vec1, 1, 0);

runtime/src/juvix/arch/wasi.h

@@ -7,6 +7,7 @@
 
 _Noreturn void exit(int code);
 
+void puts_nonl(const char *str);
 void puts(const char *str);
 
 typedef struct Ciovec {

runtime/src/juvix/defs.h

@@ -19,12 +19,20 @@ extern int errno;
 /**********************************************/
 /* Basic primitive functions and macros */
 
-static void print_msg(const char *msg) {
+static inline void print_msg(const char *msg) {
 #if defined(API_LIBC) || defined(API_WASI)
     puts(msg);
 #endif
 }
 
+static inline void print_msg_nonl(const char *msg) {
+#if defined(API_LIBC)
+    fputs(msg, stdout);
+#elif defined(API_WASI)
+    puts_nonl(msg);
+#endif
+}
+
 _Noreturn static inline void error_exit() {
 #if defined(API_LIBC)
     abort();

runtime/src/juvix/io.c

@@ -26,7 +26,7 @@ void io_flush() {
         io_index = 0;
 #else
         io_buffer[io_index] = 0;
-        print_msg(io_buffer);
+        print_msg_nonl(io_buffer);
         io_index = 0;
 #endif
     }
@@ -84,6 +84,11 @@ static word_t io_readln() {
         error_exit_msg("read error");
     }
     io_buffer[MAX_CSTRING_LENGTH - 1] = 0;
+    // remove trailing newline
+    size_t len = strlen(io_buffer);
+    if (len > 0) {
+        io_buffer[len - 1] = 0;
+    }
     return alloc_cstring(io_buffer);
 #elif defined(API_WASI)
     io_flush();

runtime/src/juvix/io.h

@@ -35,6 +35,7 @@ bool io_interpret(word_t x, word_t *ret, word_t *arg);
             CALL_CLOSURE(juvix_io_ret, juvix_io_interpret_label_1);      \
             STACK_LEAVE;                                                 \
         } else {                                                         \
+            RESTORE_MEMORY_POINTERS;                                     \
             juvix_result = juvix_io_ret;                                 \
             RETURN_NS;                                                   \
         }                                                                \

src/Juvix/Compiler/Asm/Pretty/Base.hs

@@ -46,6 +46,14 @@ quoteAsmName txt =
       (":", "__colon__")
     ]
 
+quoteAsmFunName :: Text -> Text
+quoteAsmFunName txt =
+  foldr
+    (uncurry Text.replace)
+    txt
+    [ ("readLn", "__readLn__")
+    ]
+
 ppConstrName :: (Member (Reader Options) r) => Tag -> Sem r (Doc Ann)
 ppConstrName tag = do
   opts <- ask
@@ -70,7 +78,7 @@ ppFunName sym = do
         annotate (AnnKind KNameFunction) $
           pretty ("unnamed_function_" ++ show sym :: String)
     )
-    (\fi -> return $ annotate (AnnKind KNameFunction) (pretty (quoteAsmName (fi ^. functionName))))
+    (\fi -> return $ annotate (AnnKind KNameFunction) (pretty (quoteAsmFunName $ quoteAsmName (fi ^. functionName))))
     (HashMap.lookup sym (tab ^. infoFunctions))
 
 instance PrettyCode BuiltinDataTag where
@@ -342,7 +350,7 @@ instance PrettyCode FunctionInfo where
     c <- ppCodeCode _functionCode
     return $
       keyword Str.function
-        <+> annotate (AnnKind KNameFunction) (pretty _functionName)
+        <+> annotate (AnnKind KNameFunction) (pretty (quoteAsmFunName $ quoteAsmName _functionName))
           <> encloseSep lparen rparen ", " argtys
         <+> colon
         <+> targetty
@@ -354,7 +362,7 @@ ppFunSig FunctionInfo {..} = do
   targetty <- ppCode (typeTarget _functionType)
   return $
     keyword Str.function
-      <+> annotate (AnnKind KNameFunction) (pretty (quoteAsmName _functionName))
+      <+> annotate (AnnKind KNameFunction) (pretty (quoteAsmFunName $ quoteAsmName _functionName))
         <> encloseSep lparen rparen ", " argtys
       <+> colon
       <+> targetty

test/Asm/Compile/Base.hs

@@ -11,8 +11,8 @@ import Juvix.Compiler.Backend.C qualified as C
 import Juvix.Compiler.Pipeline qualified as Pipeline
 import Runtime.Base qualified as Runtime
 
-asmCompileAssertion' :: InfoTable -> Path Abs File -> Path Abs File -> (String -> IO ()) -> Assertion
-asmCompileAssertion' tab mainFile expectedFile step = do
+asmCompileAssertion' :: InfoTable -> Path Abs File -> Path Abs File -> Text -> (String -> IO ()) -> Assertion
+asmCompileAssertion' tab mainFile expectedFile stdinText step = do
   step "Generate C code"
   case run $ runError @JuvixError $ Pipeline.asmToMiniC asmOpts tab of
     Left e -> do
@@ -23,16 +23,16 @@ asmCompileAssertion' tab mainFile expectedFile step = do
         ( \dirPath -> do
             let cFile = dirPath <//> replaceExtension' ".c" (filename mainFile)
             TIO.writeFile (toFilePath cFile) _resultCCode
-            Runtime.clangAssertion cFile expectedFile "" step
+            Runtime.clangAssertion cFile expectedFile stdinText step
         )
   where
     asmOpts :: Options
     asmOpts = makeOptions Backend.TargetCNative64 True
 
-asmCompileAssertion :: Path Abs File -> Path Abs File -> (String -> IO ()) -> Assertion
-asmCompileAssertion mainFile expectedFile step = do
+asmCompileAssertion :: Path Abs File -> Path Abs File -> Text -> (String -> IO ()) -> Assertion
+asmCompileAssertion mainFile expectedFile stdinText step = do
   step "Parse"
   s <- readFile (toFilePath mainFile)
   case runParser (toFilePath mainFile) s of
     Left err -> assertFailure (show err)
-    Right tab -> asmCompileAssertion' tab mainFile expectedFile step
+    Right tab -> asmCompileAssertion' tab mainFile expectedFile stdinText step

test/Asm/Compile/Positive.hs

@@ -12,7 +12,7 @@ testDescr Run.PosTest {..} =
    in TestDescr
         { _testName = _name,
           _testRoot = tRoot,
-          _testAssertion = Steps $ asmCompileAssertion file' expected'
+          _testAssertion = Steps $ asmCompileAssertion file' expected' ""
         }
 
 allTests :: TestTree

test/Compilation/Base.hs

@@ -9,20 +9,29 @@ import Juvix.Compiler.Core.Translation.FromInternal.Data qualified as Core
 import Juvix.Compiler.Pipeline
 import Juvix.Data.PPOutput
 
+data CompileAssertionMode
+  = EvalOnly
+  | -- | Specify text to be sent to stdin of the process under test
+    CompileOnly Text
+  | EvalAndCompile
+
 compileAssertion ::
-  Bool ->
+  CompileAssertionMode ->
   Path Abs File ->
   Path Abs File ->
   (String -> IO ()) ->
   Assertion
-compileAssertion onlyEval mainFile expectedFile step = do
+compileAssertion mode mainFile expectedFile step = do
   step "Translate to JuvixCore"
   cwd <- getCurrentDir
   let entryPoint = defaultEntryPoint cwd mainFile
   tab <- (^. Core.coreResultTable) . snd <$> runIO' iniState entryPoint upToCore
   case run $ runError $ Core.toEval tab of
     Left err -> assertFailure (show (pretty (fromJuvixError @GenericError err)))
     Right tab' -> do
-      coreEvalAssertion' tab' mainFile expectedFile step
-      unless onlyEval $
-        coreCompileAssertion' tab' mainFile expectedFile step
+      let evalAssertion = coreEvalAssertion' tab' mainFile expectedFile step
+          compileAssertion' stdinText = coreCompileAssertion' tab' mainFile expectedFile stdinText step
+      case mode of
+        EvalOnly -> evalAssertion
+        CompileOnly stdinText -> compileAssertion' stdinText
+        EvalAndCompile -> evalAssertion >> compileAssertion' ""

test/Compilation/Positive.hs

@@ -7,7 +7,7 @@ data PosTest = PosTest
   { _name :: String,
     _dir :: Path Abs Dir,
     _file :: Path Abs File,
-    _onlyEval :: Bool,
+    _assertionMode :: CompileAssertionMode,
     _expectedFile :: Path Abs File
   }
 
@@ -27,7 +27,7 @@ toTestDescr PosTest {..} =
    in TestDescr
         { _testName = _name,
           _testRoot = tRoot,
-          _testAssertion = Steps $ compileAssertion _onlyEval file' expected'
+          _testAssertion = Steps $ compileAssertion _assertionMode file' expected'
         }
 
 allTests :: TestTree
@@ -36,19 +36,26 @@ allTests =
     "Juvix compilation pipeline positive tests"
     (map (mkTest . toTestDescr) tests)
 
-posTest' :: Bool -> String -> Path Rel Dir -> Path Rel File -> Path Rel File -> PosTest
-posTest' _onlyEval _name rdir rfile routfile =
+posTest' :: CompileAssertionMode -> String -> Path Rel Dir -> Path Rel File -> Path Rel File -> PosTest
+posTest' _assertionMode _name rdir rfile routfile =
   let _dir = root <//> rdir
       _file = _dir <//> rfile
       _expectedFile = root <//> routfile
    in PosTest {..}
 
+posTestStdin :: String -> Path Rel Dir -> Path Rel File -> Path Rel File -> Text -> PosTest
+posTestStdin _name rdir rfile routfile _stdinText =
+  let t = posTest _name rdir rfile routfile
+   in t
+        { _assertionMode = CompileOnly _stdinText
+        }
+
 posTest :: String -> Path Rel Dir -> Path Rel File -> Path Rel File -> PosTest
-posTest = posTest' False
+posTest = posTest' EvalAndCompile
 
 -- tests which use large integers are only evaluated but not compiled
 posTestEval :: String -> Path Rel Dir -> Path Rel File -> Path Rel File -> PosTest
-posTestEval = posTest' True
+posTestEval = posTest' EvalOnly
 
 tests :: [PosTest]
 tests =
@@ -266,5 +273,11 @@ tests =
       "Builtin trace"
       $(mkRelDir ".")
       $(mkRelFile "test043.juvix")
-      $(mkRelFile "out/test043.out")
+      $(mkRelFile "out/test043.out"),
+    posTestStdin
+      "Builtin readline"
+      $(mkRelDir ".")
+      $(mkRelFile "test044.juvix")
+      $(mkRelFile "out/test044.out")
+      "a\n"
   ]

test/Core/Compile/Base.hs

@@ -32,30 +32,32 @@ toTestDescr Test {..} =
    in TestDescr
         { _testName = _name,
           _testRoot = tRoot,
-          _testAssertion = Steps $ coreCompileAssertion file' expected'
+          _testAssertion = Steps $ coreCompileAssertion file' expected' ""
         }
 
 coreCompileAssertion' ::
   InfoTable ->
   Path Abs File ->
   Path Abs File ->
+  Text ->
   (String -> IO ()) ->
   Assertion
-coreCompileAssertion' tab mainFile expectedFile step = do
+coreCompileAssertion' tab mainFile expectedFile stdinText step = do
   step "Translate to JuvixAsm"
   case run $ runError $ toStripped tab of
     Left err -> assertFailure (show (pretty (fromJuvixError @GenericError err)))
     Right tab0 -> do
       let tab' = Asm.fromCore $ Stripped.fromCore $ tab0
       length (fromText (Asm.ppPrint tab' tab') :: String) `seq`
-        Asm.asmCompileAssertion' tab' mainFile expectedFile step
+        Asm.asmCompileAssertion' tab' mainFile expectedFile stdinText step
 
 coreCompileAssertion ::
   Path Abs File ->
   Path Abs File ->
+  Text ->
   (String -> IO ()) ->
   Assertion
-coreCompileAssertion mainFile expectedFile step = do
+coreCompileAssertion mainFile expectedFile stdinText step = do
   step "Parse"
   r <- parseFile mainFile
   case r of
@@ -65,4 +67,4 @@ coreCompileAssertion mainFile expectedFile step = do
       expected <- TIO.readFile (toFilePath expectedFile)
       assertEqDiffText ("Check: EVAL output = " <> toFilePath expectedFile) "" expected
     Right (tabIni, Just node) ->
-      coreCompileAssertion' (setupMainFunction tabIni node) mainFile expectedFile step
+      coreCompileAssertion' (setupMainFunction tabIni node) mainFile expectedFile stdinText step

tests/Compilation/positive/out/test044.out

@@ -0,0 +1 @@
+a

tests/Compilation/positive/test044.juvix

@@ -0,0 +1,10 @@
+-- Builtin readline
+module test044;
+
+builtin string axiom String : Type;
+builtin IO axiom IO : Type;
+builtin IO-readline axiom readLn : (String → IO) → IO;
+builtin string-print axiom printString : String → IO;
+
+main : IO;
+main := readLn printString;