ParseShell.hs

-- | This module splits a shell command line into a list of strings,
--   one for each command / filename
module IHaskell.Eval.ParseShell (parseShell) where 

import Prelude hiding (words)
import Text.ParserCombinators.Parsec hiding (manyTill)
import Control.Applicative hiding ((<|>), many, optional)

eol :: Parser Char
eol = oneOf "\n\r" <?> "end of line"

quote :: Parser Char 
quote = char '\"'

-- | @manyTill p end@ from hidden @manyTill@ in that it appends the result of @end@
manyTill :: Parser a -> Parser [a] -> Parser [a]
manyTill p end = scan
  where
    scan = end <|> do
      x <- p
      xs <- scan
      return $ x:xs

manyTill1 p end = do x <- p 
                     xs <- manyTill p end 
                     return $ x : xs

unescapedChar :: Parser Char -> Parser String 
unescapedChar p = try $ do 
  x <- noneOf "\\"
  lookAhead p
  return [x]

quotedString = do
  quote <?> "expected starting quote"
  (manyTill anyChar (unescapedChar quote) <* quote) <?> "unexpected in quoted String "

unquotedString = manyTill1 anyChar end  
  where end = unescapedChar space 
          <|> (lookAhead eol >> return [])

word = quotedString <|> unquotedString <?> "word"

separator :: Parser String
separator = many1 space <?> "separator"

-- | Input must terminate in a space character (like a \n)
words :: Parser [String]
words = try (eof *> return []) <|> do
  x <-  word 
  rest1 <- lookAhead (many anyToken)
  ss <-  separator 
  rest2 <-  lookAhead (many anyToken)
  xs <-  words 
  return $ x : xs 

parseShell :: String -> Either ParseError [String]
parseShell string = parse words "shell" (string ++ "\n")