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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
-----------------------------------------------------------------------------
-- |
-- 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 status bar for the Xmonad Window Manager
--
-----------------------------------------------------------------------------
module Parsers (
-- * Parsing
-- $parser
parseString
, stringParser
, defaultColors
, colorsAndText
, templateStringParser
, templateCommandParser
, templateParser
, parseTemplate
) where
import Config
import Commands
import Text.ParserCombinators.Parsec
import qualified Data.Map as Map
{- $parser
These are the neede parsers. Don't trust them too much.
There are parsers for the commands output and parsers for the
formatting template.
-}
-- | Runs the actual string parsers
parseString :: Config -> String -> IO [(String, String)]
parseString config s =
case (parse (stringParser config) "" s) of
Left _ -> return [("Could not parse string: " ++ s
, (fgColor config))]
Right x -> return x
-- | Gets the string and combines the needed parsers
stringParser :: Config -> Parser [(String, String)]
stringParser c = manyTill (colorsAndText c <|> defaultColors c) eof
-- | Parses a string with the default color (no color set)
defaultColors :: Config -> Parser (String, String)
defaultColors config =
do { s <- many $ noneOf "<"
; return (s,(fgColor config))
}
<|> colorsAndText config
-- | Parses a string with a color set
colorsAndText :: Config -> Parser (String, String)
colorsAndText config =
do { string "<fc="
; c <- colorSpec
; string ">"
; s <- many $ noneOf "<"
; string "</fc>"
; return (s,c)
}
<|> defaultColors config
-- | Parses a color specification (hex or named)
colorSpec :: Parser String
colorSpec =
do { c <- char '#'
; s <- count 6 hexDigit
; return $ c:s
}
<|> many1 alphaNum
-- | Parses the output template string
templateStringParser :: Config -> Parser (String,String,String)
templateStringParser c =
do{ s <- many $ noneOf (sepChar c)
; (com,_,_) <- templateCommandParser c
; ss <- many $ noneOf (sepChar c)
; return (com, s, ss)
}
-- | Parses the command part of the template string
templateCommandParser :: Config -> Parser (String,String,String)
templateCommandParser c =
do { let chr = head $ sepChar c
; char chr
; com <- many $ noneOf (sepChar c)
; char chr
; return $ (com,"","")
}
-- | Combines the template parsers
templateParser :: Config -> Parser [(String,String,String)]
templateParser c = many (templateStringParser c)
-- | Actually runs the template parsers
parseTemplate :: Config -> String -> IO [(Command,String,String)]
parseTemplate config s =
do str <- case (parse (templateParser config) "" s) of
Left _ -> return [("","","")]
Right x -> return x
let comList = map (show . fst) $ commands config
m = Map.fromList . zip comList . map fst $ (commands config)
return $ combine m str
-- | Given a finite "Map" and a parsed templatet produces the
-- | resulting output string.
combine :: Map.Map String Command -> [(String, String, String)] -> [(Command,String,String)]
combine _ [] = []
combine m ((ts,s,ss):xs) =
[(com, s, ss)] ++ combine m xs
where com = Map.findWithDefault dflt ts m
dflt = Exec ts [] [] --"<" ++ ts ++ " not found!>"
|
