Simple sequences

Commands separated by newlines or semicolons will now be executed
sequentially. The logic for commands that exit with non-zero exit codes
will still need some close work.

src/lib/ast.ml

···
   | CST.SeparatorOp_Uppersand -> Ampersand
   | CST.SeparatorOp_Semicolon -> Semicolon
 
-and clist : CST.clist -> clist =
- fun x ->
+and clist : ?sep:separator -> CST.clist -> clist =
+ fun ?(sep = Nosep) x ->
   match x with
   | CList_CList_SeparatorOp_AndOr (a, b, c) ->
-      let rest = clist a.value in
-      let sep = separator_op b.value in
+      let next_sep = separator_op b.value in
+      let rest = clist ~sep:next_sep a.value in
       let command = and_or c.value in
-      Nslist.cons sep command rest
+      Nslist.append rest (Nlist.Singleton (command, sep))
   | CList_AndOr a ->
       let a = and_or a.value in
-      Nslist.singleton Nosep a
+      Nslist.singleton sep a
 
 and and_or : ?sep:and_or -> CST.and_or -> pipeline and_or_list =
  fun ?(sep = Noand_or) x ->

src/lib/eval.ml

···
     | Ast.IoRedirect_IoHere _ ->
         Fmt.failwith "HERE documents not yet implemented!"
 
-  let exec ctx (ast : Ast.complete_command) =
-    let command, _ = ast in
-    let execute_commands local_switch p =
-      let rec loop (status_of_previous, stdout_of_previous) = function
-        | Ast.SimpleCommand (Prefixed _) :: next ->
-            loop (status_of_previous, stdout_of_previous) next
-        | Ast.SimpleCommand (Named (executable, None)) :: rest -> (
-            let some_read, some_write =
-              stdout_for_pipeline ~sw:local_switch rest
-            in
-            match stdout_of_previous with
-            | None ->
-                E.exec ctx.executor ?stdout:some_write
+  let execute_commands ctx local_switch p =
+    let rec loop (status_of_previous, stdout_of_previous) = function
+      | Ast.SimpleCommand (Prefixed _) :: next ->
+          loop (status_of_previous, stdout_of_previous) next
+      | Ast.SimpleCommand (Named (executable, None)) :: rest -> (
+          let some_read, some_write =
+            stdout_for_pipeline ~sw:local_switch rest
+          in
+          match stdout_of_previous with
+          | None ->
+              E.exec ctx.executor ?stdout:some_write
+                (List.map word_component_to_string executable)
+              |> Option.some
+          | Some stdout ->
+              let res =
+                E.exec ctx.executor ~stdin:stdout ?stdout:some_write
                   (List.map word_component_to_string executable)
+              in
+              Option.iter Eio.Flow.close some_write;
+              loop (Some res, some_read) rest)
+      | Ast.SimpleCommand (Named (executable, Some suffix)) :: rest -> (
+          let args =
+            List.filter_map
+              (function
+                | Ast.Suffix_word w ->
+                    Some (List.map word_component_to_string w)
+                | Ast.Suffix_redirect _ -> None)
+              suffix
+          in
+          let redirect =
+            List.fold_left
+              (fun acc -> function
+                | Ast.Suffix_word _ -> acc
+                | Ast.Suffix_redirect rdr ->
+                    handle_one_redirection ~sw:local_switch ctx rdr :: acc)
+              [] suffix
+            |> List.rev |> List.filter_map Fun.id
+          in
+          let some_read, some_write =
+            stdout_for_pipeline ~sw:local_switch rest
+          in
+          match stdout_of_previous with
+          | None ->
+              let res =
+                E.exec ~fds:redirect ctx.executor ?stdout:some_write
+                  (List.map word_component_to_string executable
+                  @ List.concat args)
                 |> Option.some
-            | Some stdout ->
-                let res =
-                  E.exec ctx.executor ~stdin:stdout ?stdout:some_write
-                    (List.map word_component_to_string executable)
-                in
-                Option.iter Eio.Flow.close some_write;
-                loop (Some res, some_read) rest)
-        | Ast.SimpleCommand (Named (executable, Some suffix)) :: rest -> (
-            let args =
-              List.filter_map
-                (function
-                  | Ast.Suffix_word w ->
-                      Some (List.map word_component_to_string w)
-                  | Ast.Suffix_redirect _ -> None)
-                suffix
-            in
-            let redirect =
-              List.fold_left
-                (fun acc -> function
-                  | Ast.Suffix_word _ -> acc
-                  | Ast.Suffix_redirect rdr ->
-                      handle_one_redirection ~sw:local_switch ctx rdr :: acc)
-                [] suffix
-              |> List.rev |> List.filter_map Fun.id
-            in
-            let some_read, some_write =
-              stdout_for_pipeline ~sw:local_switch rest
-            in
-            match stdout_of_previous with
-            | None ->
-                let res =
-                  E.exec ~fds:redirect ctx.executor ?stdout:some_write
-                    (List.map word_component_to_string executable
-                    @ List.concat args)
-                  |> Option.some
-                in
-                Option.iter Eio.Flow.close some_write;
-                loop (res, some_read) rest
-            | Some stdout ->
-                let res =
-                  E.exec ~fds:redirect ctx.executor ~stdin:stdout
-                    ?stdout:some_write
-                    (List.map word_component_to_string executable
-                    @ List.concat args)
-                  |> Option.some
-                in
-                Option.iter Eio.Flow.close some_write;
-                loop (res, some_read) rest)
-        | v :: _ ->
-            Fmt.epr "TODO: %a" Yojson.Safe.pp (Ast.command_to_yojson v);
-            failwith "Err"
-        | [] -> status_of_previous
-      in
-      loop (None, None) p
+              in
+              Option.iter Eio.Flow.close some_write;
+              loop (res, some_read) rest
+          | Some stdout ->
+              let res =
+                E.exec ~fds:redirect ctx.executor ~stdin:stdout
+                  ?stdout:some_write
+                  (List.map word_component_to_string executable
+                  @ List.concat args)
+                |> Option.some
+              in
+              Option.iter Eio.Flow.close some_write;
+              loop (res, some_read) rest)
+      | v :: _ ->
+          Fmt.epr "TODO: %a" Yojson.Safe.pp (Ast.command_to_yojson v);
+          failwith "Err"
+      | [] -> status_of_previous
     in
+    loop (None, None) p
+
+  let handle_single_pipeline ~sw ctx c =
     let pipeline = function
       | Ast.Pipeline p -> (Fun.id, p)
       | Ast.Pipeline_Bang p ->
           (Option.map (fun i -> if Int.equal i 0 then -1 else 0), p)
     in
-    let loop : Eio.Switch.t -> Ast.clist -> int option =
+
+    let rec fold :
+        Ast.and_or * int option -> Ast.pipeline Ast.and_or_list -> int option =
+     fun (sep, exit_so_far) pipe ->
+      match (sep, pipe) with
+      | And, Nlist.Singleton (p, _) -> (
+          match exit_so_far with
+          | Some 0 ->
+              let f, p = pipeline p in
+              f @@ execute_commands ctx sw p
+          | v -> v)
+      | Or, Nlist.Singleton (p, _) -> (
+          match exit_so_far with
+          | Some 0 -> Some 0
+          | _ ->
+              let f, p = pipeline p in
+              f @@ execute_commands ctx sw p)
+      | Noand_or, Nlist.Singleton (p, _) ->
+          let f, p = pipeline p in
+          f @@ execute_commands ctx sw p
+      | Noand_or, Nlist.Cons ((p, next_sep), rest) ->
+          let f, p = pipeline p in
+          fold (next_sep, f (execute_commands ctx sw p)) rest
+      | And, Nlist.Cons ((p, next_sep), rest) -> (
+          match exit_so_far with
+          | Some 0 ->
+              let f, p = pipeline p in
+              fold (next_sep, f (execute_commands ctx sw p)) rest
+          | (None | Some _) as v -> v)
+      | Or, Nlist.Cons ((p, next_sep), rest) -> (
+          match exit_so_far with
+          | Some 0 -> fold (next_sep, exit_so_far) rest
+          | None | Some _ ->
+              let f, p = pipeline p in
+              fold (next_sep, f (execute_commands ctx sw p)) rest)
+    in
+    fold (Noand_or, None) c
+
+  let exec ctx (ast : Ast.complete_command) =
+    let command, _ = ast in
+    let rec loop : Eio.Switch.t -> Ast.clist -> int option =
      fun sw -> function
-       | Nlist.Singleton (c, _) ->
-           let rec fold :
-               Ast.and_or * int option ->
-               Ast.pipeline Ast.and_or_list ->
-               int option =
-            fun (sep, exit_so_far) pipe ->
-             match (sep, pipe) with
-             | And, Nlist.Singleton (p, _) -> (
-                 match exit_so_far with
-                 | Some 0 ->
-                     let f, p = pipeline p in
-                     f @@ execute_commands sw p
-                 | v -> v)
-             | Or, Nlist.Singleton (p, _) -> (
-                 match exit_so_far with
-                 | Some 0 -> Some 0
-                 | _ ->
-                     let f, p = pipeline p in
-                     f @@ execute_commands sw p)
-             | Noand_or, Nlist.Singleton (p, _) ->
-                 let f, p = pipeline p in
-                 f @@ execute_commands sw p
-             | Noand_or, Nlist.Cons ((p, next_sep), rest) ->
-                 let f, p = pipeline p in
-                 fold (next_sep, f (execute_commands sw p)) rest
-             | And, Nlist.Cons ((p, next_sep), rest) -> (
-                 match exit_so_far with
-                 | Some 0 ->
-                     let f, p = pipeline p in
-                     fold (next_sep, f (execute_commands sw p)) rest
-                 | (None | Some _) as v -> v)
-             | Or, Nlist.Cons ((p, next_sep), rest) -> (
-                 match exit_so_far with
-                 | Some 0 -> fold (next_sep, exit_so_far) rest
-                 | None | Some _ ->
-                     let f, p = pipeline p in
-                     fold (next_sep, f (execute_commands sw p)) rest)
-           in
-           fold (Noand_or, None) c
-       | _ -> Fmt.failwith "TODO!!!"
+       | Nlist.Singleton (c, _) -> handle_single_pipeline ~sw ctx c
+       | Nlist.Cons ((c, (Semicolon | Nosep)), cs) -> (
+           match handle_single_pipeline ~sw ctx c with
+           | Some 0 -> loop sw cs
+           | v -> v)
+       | _ -> Fmt.failwith "Background tasks not implemented yet!"
     in
     Eio.Switch.run @@ fun sw -> (loop sw command, ctx, ast)
 

test/simple.t

···
   $ osh -c "echo hello 3>out.txt >&3"
   $ cat out.txt
   hello
+
+2.7 Sequences
+
+A simple, semicolon sequence.
+
+  $ osh -c "echo hello; echo world; echo 'that is all'"
+  hello
+  world
+  that is all
+
+  $ cat > test.sh <<EOF
+  > echo hello
+  > echo world
+  > echo 'that is all'
+  > EOF
+
+  $ osh test.sh
+  hello
+  world
+  that is all