1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
-----------------------------------------------------------------------------
-- |
-- Module : Xmobar.Parsers
-- Copyright : (c) Andrea Rossato
-- License : BSD-style (see LICENSE)
--
-- Maintainer : Andrea Rossato <andrea.rossato@unibz.it>
-- Stability : unstable
-- Portability : unportable
--
-- Parsers needed for Xmobar, a text based status bar
--
-----------------------------------------------------------------------------
module Parsers
( parseString
, stringParser
, colorParser
, colorsAndText
, templateStringParser
, templateCommandParser
, templateParser
, parseTemplate
) where
import Config
import Commands
import Runnable
import Text.ParserCombinators.Parsec
import qualified Data.Map as Map
-- | Runs the string parser
parseString :: Config -> String -> IO [(String, String)]
parseString c s =
case parse (stringParser c) "" s of
Left _ -> return [("Could not parse string: " ++ s, fgColor c)]
Right x -> return (concat x)
-- | Gets the string and combines the needed parsers
stringParser :: Config -> Parser [[(String, String)]]
stringParser = flip manyTill eof . colorParser
-- | Parses a string with the default color (no color set)
colorParser :: Config -> Parser [(String, String)]
colorParser c = do
s <- manyTill anyChar (tryString "<fc" <|> endOfLine "")
n <- colorsAndText <|> endOfLine ("","")
return [(s,fgColor c),n]
-- | Parses a string with a color set
colorsAndText :: Parser (String, String)
colorsAndText = do
c <- inside (string "=") colors (string ">")
s <- manyTill anyChar (tryString "</fc>")
return (s,c)
-- | Parses a color specification (hex or named)
colors :: Parser String
colors = many1 (alphaNum <|> char ',' <|> char '#')
-- | Parses the output template string
templateStringParser :: Config -> Parser (String,String,String)
templateStringParser c = do
s <- allTillSep c
com <- templateCommandParser c
ss <- allTillSep c
return (com, s, ss)
-- | Parses the command part of the template string
templateCommandParser :: Config -> Parser String
templateCommandParser c =
let chr = char . head . sepChar
in inside (chr c) (allTillSep c) (chr c)
-- | Combines the template parsers
templateParser :: Config -> Parser [(String,String,String)]
templateParser = many . templateStringParser
-- | Actually runs the template parsers
parseTemplate :: Config -> String -> IO [(Runnable,String,String)]
parseTemplate c s =
do str <- case (parse (templateParser c) "" s) of
Left _ -> return [("","","")]
Right x -> return x
let cl = map alias (commands c)
m = Map.fromList $ zip cl (commands c)
return $ combine c m str
-- | Given a finite "Map" and a parsed templatet produces the
-- | resulting output string.
combine :: Config -> Map.Map String Runnable -> [(String, String, String)] -> [(Runnable,String,String)]
combine _ _ [] = []
combine c m ((ts,s,ss):xs) = (com, s, ss) : combine c m xs
where com = Map.findWithDefault dflt ts m
dflt = Run $ Com ts [] [] 10
endOfLine :: a -> Parser a
endOfLine r = eof >> return r
tryString :: String -> Parser String
tryString = try . string
allTillSep :: Config -> Parser String
allTillSep = many . noneOf . sepChar
inside :: Parser a -> Parser b -> Parser c -> Parser b
inside pa pb pc = pa >> pb >>= \r -> pc >> return r
|
