implementation module IRC
+import StdGeneric
import StdList
+import StdTuple
import GenPrint
+import GenBimap
import StdOverloaded
import Data.Maybe
import Data.Either
import StdFunc
import StdString
import StdChar
+import StdBool
+import _SystemArray
import Text.Parsers.Simple.Core
import Text.Parsers.Simple.Chars
+import Data.Tuple
import Control.Monad
import Control.Applicative
from Data.Functor import <$>
from Data.Func import $
-from Text import class Text(concat), instance Text String
+from Text import class Text(ltrim,indexOf,concat), instance Text String
import qualified Text
from StdMisc import undef
+import StdDebug
jon :== 'Text'.join
-derive gPrint IRCCommands, IRCReplies, IRCErrors, (,), Maybe, (), Either
+derive gPrint IRCCommand, IRCReplies, IRCErrors, (,), Maybe, (), Either, IRCMessage, IRCUser, IRCNumReply
-:: IRCMessage =
- { irc_prefix :: Maybe (Either String IRCUser)
- , irc_command :: IRCCommands
- }
-
-:: IRCUser =
- { irc_nick :: String
- , irc_user :: Maybe String
- , irc_host :: Maybe String
- }
-
-//Start = runParser parseMessage $ fromString ":frobnicator!~frobnicat@92.110.128.124 PRIVMSG #cloogle :!query ^_^\r\n"
-Start = runParser parseMessage $ fromString ":frobnicator!~frobnicat@92.110.128.124 QUIT\r\n"
+Start = jon "\n" $ map printToString
+ [ parseIRCMessage ":clooglebot!~cloogle@dhcp-077-249-221-037.chello.nl QUIT\r\n"
+ , parseIRCMessage ":clooglebot!~cloogle QUIT\r\n"
+ , parseIRCMessage ":frobnicator!~frobnicat@92.110.128.124 QUIT\r\n"
+ , parseIRCMessage ":frobnicator!~frobnicat@92.110.128.124 AWAY test\r\n"
+ , parseIRCMessage ":frobnicator!~frobnicat@92.110.128.124 AWAY :test with spaces\r\n"
+ , parseIRCMessage ":cherryh.freenode.net NOTICE * :*** Found your hostname\r\n"
+ , parseIRCMessage ":cherryh.freenode.net QUIT :hoi hoi\r\n"
+ ]
(<+) infixr 5 :: a b -> String | toString a & toString b
(<+) a b = toString a +++ toString b
-parseIRCMessage :: (String -> Either [Error] IRCMessage)
-parseIRCMessage = parse parseMessage o fromString
-
-parseMessage :: Parser Char IRCMessage
-parseMessage = optional (parseEither parseHost parseUser) <* spaceParser
- >>= \mprefix->parseCommand
- <* pToken '\r' <* pToken '\n'
- >>= \cmd->pure {IRCMessage | irc_prefix=mprefix, irc_command=cmd}
-
-pCommand :: String -> Parser Char [Char]
-pCommand s = pList (map pToken $ fromString s) <* spaceParser
-
-parseCommand :: Parser Char IRCCommands
-parseCommand = pFail//pCommand "QUIT" >>| QUIT <$> optional (pure "")
-
+parseIRCMessage :: String -> Either [Error] IRCMessage
+parseIRCMessage s = case runParser parsePrefix (fromString s) of
+ ([(prefix, rest):_], _)
+ = case parse parseReply rest of
+ Left e = case parseCmd rest of
+ Left e2 = Left $ e2 ++ e
+ Right cmd = Right {IRCMessage | irc_prefix=prefix, irc_command=Right cmd}
+ Right repl = Right {IRCMessage | irc_prefix=prefix, irc_command=Left repl}
+ (_, es) = Left ["couldn't parse prefix":es]
+
+parsePrefix :: Parser Char (Maybe (Either IRCUser String))
+parsePrefix = optional (pToken ':' >>| parseEither parseUser parseHost) <* pToken ' '
+
+generic gIRCParse a :: [String] -> (Either [Error] a, [String])
+gIRCParse{|UNIT|} a = (Right UNIT, a)
+gIRCParse{|String|} [a:as] = (Right a, as)
+gIRCParse{|String|} [] = (Left ["Expected a string"], [])
+gIRCParse{|Int|} [a:as] = (Right $ toInt a, as)
+gIRCParse{|Int|} [] = (Left ["Expected an integer"], [])
+gIRCParse{|EITHER|} lp rp as = case lp as of
+ (Right a, rest) = (Right $ LEFT a, rest)
+ (Left e1, rest) = case rp as of
+ (Right a, rest) = (Right $ RIGHT a, rest)
+ (Left e2, rest) = (Left $ e1 ++ e2, [])
+gIRCParse{|OBJECT|} p as = case p as of
+ (Right e, rest) = (Right $ OBJECT e, rest)
+ (Left e, rest) = (Left e, [])
+gIRCParse{|CONS of d|} p [] = (Left ["Expected a cmd constructor: " +++ d.gcd_name], [])
+gIRCParse{|CONS of d|} p [a:as]
+| a <> d.gcd_name = (Left ["Wrong constructor. expected: " +++ d.gcd_name +++ ", got: " +++ a], [])
+= case p as of
+ (Right a, rest) = (Right $ CONS a, rest)
+ (Left e, rest) = (Left e, [])
+gIRCParse{|PAIR|} pl pr as = case pl as of
+ (Right a1, rest) = case pr rest of
+ (Right a2, rest) = (Right $ PAIR a1 a2, rest)
+ (Left e, rest) = (Left e, [])
+ (Left e, rest) = (Left e, [])
+gIRCParse{|[]|} pl as = plist pl as
+where
+ plist pl as = case pl as of
+ (Right e, rest) = case plist pl rest of
+ (Right es, rest) = (Right [e:es], rest)
+ (Left e, rest) = (Left e, [])
+ (Left e, rest) = (Right [], as)
+gIRCParse{|Maybe|} pm as = case pm as of
+ (Right a, rest) = (Right $ Just a, rest)
+ (Left e, rest) = (Right Nothing, as)
+
+derive gIRCParse (,), (,,), IRCCommand
+
+parseCmd :: [Char] -> Either [Error] IRCCommand
+parseCmd cs = fst $ gIRCParse{|*|} $ argfun $ 'Text'.split " " $ toString cs
+//= parse cmdParser $ argfun $ 'Text'.split " " $ toString cs
+ where
+ argfun :: [String] -> [String]
+ argfun [] = []
+ argfun [x:xs]
+ # x = 'Text'.trim x
+ | x.[0] == ':' = [jon " " $ [x:map 'Text'.rtrim xs]]
+ | otherwise = [x:argfun xs]
+
+ p = pSatisfy (const True)
+ lst = fmap $ 'Text'.split ","
+ opt = optional p
+ pInt = toInt <$> p
+
+ nn p f = pToken p >>| f
+
+ cmdParser :: Parser String IRCCommand
+ cmdParser =
+ (nn "ADMIN" $ fmap ADMIN opt)
+ <|> (nn "AWAY" $ fmap AWAY p)
+ <|> (nn "CONNECT" $ liftM2 CONNECT p (optional $ liftM2 tuple pInt opt))
+ <|> (nn "DIE" $ pure DIE)
+ <|> (nn "ERROR" $ fmap ERROR p)
+ <|> (nn "INFO" $ fmap INFO opt)
+ <|> (nn "INVITE" $ liftM2 INVITE p p)
+ <|> (nn "ISON" $ fmap ISON $ pMany p)
+// <|> (nn "JOIN" $ fmap JOIN $ lst p >>= \ch->lst p >>= \ks->pure (zip2 ch (ks ++ repeat Nothing)))
+ <|> (nn "KICK" $ liftM3 KICK p p opt)
+ <|> (nn "KILL" $ liftM2 KILL p p)
+ <|> (nn "LINKS" $ fmap LINKS $ optional $ liftM2 tuple opt p)
+ <|> (nn "LIST" $ fmap LIST $ optional $ liftM2 tuple ('Text'.split "," <$> p) opt)
+ <|> (nn "LUSERS" $ fmap LUSERS $ optional $ liftM2 tuple p opt)
+ <|> (nn "MODE" $ liftM5 MODE p p opt opt opt)
+ <|> (nn "MOTD" $ fmap MOTD $ opt)
+ <|> (nn "NAMES" $ fmap NAMES $ lst p)
+ <|> (nn "NICK" $ fmap NAMES $ lst p)
+ //"NICK" = String (Maybe String)
+ //"NJOIN" = command0 NJOIN args
+ //"NOTICE" = String String
+ //"OPER" = String String
+ //"PART" = [String]
+ //"PASS" = String
+ //"PING" = String (Maybe String)
+ //"PONG" = String (Maybe String)
+ //"PRIVMSG" = [String] String
+// "QUIT" = case args of
+// [_,_:_] = Left $ "QUIT has too many arguments"
+// x = Right $ QUIT $ listToMaybe x
+// "REHASH" = command0 REHASH args
+// "RESTART" = command0 REHASH args
+// "SERVER" = command0 REHASH args
+ //"SERVICE" = String String String String
+ //"SERVLIST" = (Maybe (String, Maybe String))
+ //"SQUERY" = String String
+// "SQUIRT" = command0 REHASH args
+ //"SQUIT" = String String
+ //"STATS" = (Maybe (String, Maybe String))
+ //"SUMMON" = String (Maybe (String, Maybe String))
+ //"TIME" = (Maybe String)
+ //"TOPIC" = String (Maybe String)
+ //"TRACE" = (Maybe String)
+ //"USER" = String String String
+ //"USERHOST" = [String]
+ //"USERS" = (Maybe String)
+ //"VERSION" = (Maybe String)
+ //"WALLOPS" = String
+ //"WHO" = (Maybe String)
+ //"WHOIS" = (Maybe String) [String]
+ //"WHOWAS" = (Maybe String) [String]
+
+parseReply :: Parser Char IRCNumReply
+parseReply = (toString <$> pSome pDigit)
+ >>= \rep->pMiddle
+ >>= \recipient->spaceParser >>| (toString <$> pSome (pNoneOf illegal))
+ >>= \msg->pure {IRCNumReply|irc_reply=fs rep,irc_recipient=recipient,irc_message=msg}
+ where
+ fs :: String -> IRCReplies
+ fs s = fromInt $ toInt s
spaceParser :: Parser Char [Char]
spaceParser = pMany $ pToken ' '
parseEither p q = Left <$> p <|> Right <$> q
parseUser :: Parser Char IRCUser
-parseUser = pToken ':' >>| parseNick
+parseUser = parseNick
>>= \nick->optional (pToken '!' >>| parseUsr)
>>= \muser->optional (pToken '@' >>| parseHost)
>>= \mhost->pure {IRCUser | irc_nick=nick, irc_user=muser, irc_host=mhost}
parseUsr :: Parser Char String
-parseUsr = toString <$> pSome (pSatisfy (not o flip isMember [' ', '\x00', '\x0d', '\x0a', '@']))
+parseUsr = toString <$> pSome (pNoneOf [' ', '@':illegal])
parseNick :: Parser Char String
parseNick = pAlpha >>= \c->pMany (pAlpha <|> pDigit <|> pSpecial)
pSpecial = pOneOf ['-', '[', ']', '\\', '\`', '^', '{', '}']
parseHost :: Parser Char String
-parseHost = parseName
- >>= \nm->pMany (pToken '.' >>| parseName)
- >>= \nms->pure (concat [nm:nms])
+parseHost = jon "." <$> pSepBy parseName (pToken '.')
where
parseName :: Parser Char String
- parseName = toString <$> pSome (pAlpha <|> pDigit <|> pToken '.')
-
-IRCCommandParser :: Parser Char IRCCommands
-IRCCommandParser = pFail
+ parseName = toString <$> pSome (pAlpha <|> pDigit <|> pOneOf ['-'])
+instance toString IRCNumReply where
+ toString m = toInt m.irc_reply <+ " " <+ m.irc_recipient <+ " " <+ formatMSG m.irc_message
instance toString IRCMessage where
- toString m = maybe "" (\s->either id ((<+) ":") s <+ " ") m.irc_prefix <+ m.irc_command
+ toString m = maybe "" (\s->either ((<+) ":") id s <+ " ") m.irc_prefix
+ <+ either toString toString m.irc_command
instance toString IRCUser where
toString m = m.irc_nick <+ maybe "" ((<+) "!") m.irc_user
<+ maybe "" ((<+) "@") m.irc_host
-instance toString IRCCommands where
- toString r = flip (+++) "\r\n" case r of
- //ADMIN (Maybe String)
- //AWAY String
- //CONNECT String Int (Maybe String)
+cons :: a [a] -> [a]
+cons a as = [a:as]
+
+pMiddle :: Parser Char String
+pMiddle = fmap toString $
+ spaceParser >>| liftM2 cons (pNotSatisfy ((==)':')) (pMany $ pNoneOf [' ':illegal])
+
+pTrailing :: Parser Char String
+pTrailing = fmap toString $
+ spaceParser >>| pToken ':' >>| pMany (pNoneOf illegal)
+
+pParam :: Parser Char String
+pParam = pMiddle <|> pTrailing
+
+pNoneOf :: [a] -> Parser a a | Eq a
+pNoneOf l = pSatisfy (not o flip isMember l)
+
+pNotSatisfy :: (a -> Bool) -> Parser a a | Eq a
+pNotSatisfy f = pSatisfy (not o f)
+
+pInt :: Parser Char Int
+pInt = toInt o toString <$> (spaceParser >>| pSome pDigit)
+
+illegal :: [Char]
+illegal = ['\x00','\r','\n']
+
+instance toString IRCCommand where
+ toString r = jon " " (print r) +++ "\r\n"
+
+print :: IRCCommand -> [String]
+print r = case r of
+ ADMIN mm = ["ADMIN":maybeToList mm]
+ AWAY m = ["AWAY",m]
+ //CONNECT String (Maybe (Int, Maybe String))
//DIE
//ERROR String
//INFO (Maybe String)
//INVITE String String
//ISON [String]
- JOIN chs = "JOIN " +++ (if (isEmpty chs) "0"
- (jon ", " [jon " " [ch:maybeToList mk]\\(ch, mk)<-chs]))
+ JOIN chs = ["JOIN",if (isEmpty chs) "0"
+ (jon ", " [jon " " [ch:maybeToList mk]\\(ch, mk)<-chs])]
//KICK String String (Maybe String)
//KILL String String
//LINKS (Maybe (Maybe String, String))
- //LIST [String]
+ //LIST (Maybe ([String], Maybe String))
//LUSERS (Maybe (String, Maybe String))
- //MODE String
+ //MODE String String (Maybe String) (Maybe String) (Maybe String)
//MOTD (Maybe String)
//NAMES [String]
- NICK n = jon " " ["NICK", n]
+ NICK n ms = ["NICK", n]
//NJOIN
//NOTICE String String
//OPER String String
//PART [String]
//PASS String
- PING a mb = jon " " ["PING",a:maybeToList mb]
- PONG a mb = jon " " ["PONG",a:maybeToList mb]
- PRIVMSG dest msg = jon " " ["PRIVMSG", dest, ":"+++msg]
- QUIT msg = jon " " ["QUIT":maybeToList msg]
+ PING a mb = ["PING",a:maybeToList mb]
+ PONG a mb = ["PONG",a:maybeToList mb]
+ PRIVMSG dest msg = ["PRIVMSG",jon "," dest,formatMSG msg]
+ QUIT msg = ["QUIT":maybeToList msg]
//REHASH
//RESTART
//SERVER
//TIME (Maybe String)
//TOPIC String (Maybe String)
//TRACE (Maybe String)
- USER login mode rn = jon " " ["USER", login, toString mode, "*", ":"+++rn]
+ USER login mode rn = ["USER", login, mode, "*", ":"+++rn]
//USERHOST [String]
//USERS (Maybe String)
//VERSION (Maybe String)
//WHO (Maybe String)
//WHOIS (Maybe String) [String]
//WHOWAS (Maybe String) [String]
- _ = printToString r
+ _ = [printToString r]
+
+formatMSG :: String -> String
+formatMSG s = if (indexOf " " s > 0 || indexOf " " s > 0) (":" +++ s) s
instance toString IRCReplies where toString r = printToString r