module StdIoUtil(linesSP, inputLinesSP, echoK, echoStderrK,
          appendChanK, appendStdoutK, appendStderrK,
          outputF, stdioF, stderrF, stdoutF, stdinF) where
--import Command
import CompOps((>==<))
import CompSP(serCompSP)
--import Event
import HaskellIO(hIOSucc)
import Srequest
import IoF
import Message(message)
import Transceivers(receiverF)
import Sockets
import Spops
--import Xtypes
import Fudget
--import FudgetIO
import NullF(getK{-,F,K-})
import ContinuationIO(stdout,stderr)
import DialogueIO hiding (IOError)

stdoutF :: F String a
stdoutF = forall a. String -> F String a
outputF String
stdout
stderrF :: F String a
stderrF = forall a. String -> F String a
outputF String
stderr
stdioF :: F String String
stdioF = forall {hi}. F hi String
stdinF forall {a1} {b} {a2}. F a1 b -> F a2 a1 -> F a2 b
>==< forall {a}. F String a
stdoutF

outputF :: String -> F String a
outputF :: forall a. String -> F String a
outputF = forall {a} {b}. K a b -> F a b
ioF forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {ho}. String -> K String ho
outputK

stdinF :: F hi String
stdinF = forall {f :: * -> * -> *} {hi} {ho}.
FudgetIO f =>
SocketRequest -> (SocketResponse -> f hi ho) -> f hi ho
sIO SocketRequest
GetStdinSocket forall a b. (a -> b) -> a -> b
$ \ (Socket Socket
s) -> forall {e}. Socket -> F e String
receiverF Socket
s

{-
outputK chan =
    let f msg =
            case msg of
              High s -> [Low (DoIO (AppendChan chan s))]
              _ -> []
    in  concmapSP f
-}

outputK :: String -> K String ho
outputK String
chan =
  forall {hi} {ho}. Cont (K hi ho) (KEvent hi)
getK forall a b. (a -> b) -> a -> b
$ forall {t1} {t2} {t3}.
(t1 -> t2) -> (t3 -> t2) -> Message t1 t3 -> t2
message (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ String -> K String ho
outputK String
chan) forall a b. (a -> b) -> a -> b
$ \ String
s ->
  forall {f :: * -> * -> *} {hi} {ho}.
FudgetIO f =>
String -> String -> f hi ho -> f hi ho
appendChanK String
chan String
s forall a b. (a -> b) -> a -> b
$
  String -> K String ho
outputK String
chan

appendChanK :: String -> String -> f hi ho -> f hi ho
appendChanK String
chan String
s = forall {f :: * -> * -> *} {hi} {ho}.
FudgetIO f =>
Request -> f hi ho -> f hi ho
hIOSucc (String -> String -> Request
AppendChan String
chan String
s)

appendStdoutK :: String -> f hi ho -> f hi ho
appendStdoutK String
s = forall {f :: * -> * -> *} {hi} {ho}.
FudgetIO f =>
String -> String -> f hi ho -> f hi ho
appendChanK String
stdout String
s
appendStderrK :: String -> f hi ho -> f hi ho
appendStderrK String
s = forall {f :: * -> * -> *} {hi} {ho}.
FudgetIO f =>
String -> String -> f hi ho -> f hi ho
appendChanK String
stderr String
s
echoK :: String -> f hi ho -> f hi ho
echoK         String
s = forall {f :: * -> * -> *} {hi} {ho}.
FudgetIO f =>
String -> f hi ho -> f hi ho
appendStdoutK (String
s forall a. [a] -> [a] -> [a]
++ String
"\n")
echoStderrK :: String -> f hi ho -> f hi ho
echoStderrK   String
s = forall {f :: * -> * -> *} {hi} {ho}.
FudgetIO f =>
String -> f hi ho -> f hi ho
appendStderrK (String
s forall a. [a] -> [a] -> [a]
++ String
"\n")

linesSP :: SP Char String
linesSP = String -> SP Char String
lnSP []
  where
    lnSP :: String -> SP Char String
lnSP String
acc =
      forall a b. Cont (SP a b) a
getSP forall a b. (a -> b) -> a -> b
$ \Char
msg ->
      case Char
msg of
        Char
'\n' -> forall b a. b -> SP a b -> SP a b
putSP (forall a. [a] -> [a]
reverse String
acc) (String -> SP Char String
lnSP [])
	Char
c    -> String -> SP Char String
lnSP (Char
c forall a. a -> [a] -> [a]
: String
acc)

inputLinesSP :: SP String String
inputLinesSP = SP Char String
linesSP forall {a1} {b} {a2}. SP a1 b -> SP a2 a1 -> SP a2 b
`serCompSP` forall {b}. SP [b] b
concatSP -- inefficient!!!