b188fe1 · Idris-dev · git.iko.soy

126textUntilEol :: MonadicParsing m => m String

127textUntilEol = many (P.satisfy (not . isEol)) <* eol <* P.someSpace

128

129+clause :: String -> PParser a -> (PkgDesc -> a -> PkgDesc) -> PParser ()

130+clause name p f = do value <- reserved name *> lchar '=' *> p

131+ modify $ \st -> f st value

132+

133+commaSep :: MonadicParsing m => m a -> m [a]

134+commaSep p = P.sepBy1 p (lchar ',')

135+

129pClause :: PParser ()

136pClause :: PParser ()

130−pClause = do reserved "executable"; lchar '=';

137+pClause = clause "executable" filename (\st v -> st { execout = Just v })

131− exec <- filename

132− st <- get

133− put (st { execout = Just exec })

134−

135− <|> do reserved "main"; lchar '=';

136− main <- fst <$> iName []

137− st <- get

138− put (st { idris_main = Just main })

138+ <|> clause "main" (fst <$> iName []) (\st v -> st { idris_main = Just v })

139−

140− <|> do reserved "sourcedir"; lchar '=';

141− src <- fst <$> identifier

139+ <|> clause "sourcedir" (fst <$> identifier) (\st v -> st { sourcedir = v })

142− st <- get

143− put (st { sourcedir = src })

144−

145− <|> do reserved "opts"; lchar '=';

146− opts <- P.stringLiteral

147− st <- get

148− let args = pureArgParser (words opts)

149− put (st { idris_opts = args ++ idris_opts st })

140+ <|> clause "opts" (pureArgParser . words <$> P.stringLiteral) (\st v -> st { idris_opts = v ++ idris_opts st })

150−

151− <|> do reserved "pkgs"; lchar '=';

152− ps <- P.sepBy1 (pPkgName <* P.someSpace) (lchar ',')

141+ <|> clause "pkgs" (commaSep (pPkgName <* P.someSpace)) (\st ps ->

153− st <- get

154 let pkgs = pureArgParser $ concatMap (\x -> ["-p", show x]) ps

142 let pkgs = pureArgParser $ concatMap (\x -> ["-p", show x]) ps

155−

156− put (st { pkgdeps = ps `union` (pkgdeps st)

143+ in st { pkgdeps = ps `union` pkgdeps st

157− , idris_opts = pkgs ++ idris_opts st})

144+ , idris_opts = pkgs ++ idris_opts st })

158−

159− <|> do reserved "modules"; lchar '=';

160− ms <- P.sepBy1 (fst <$> iName []) (lchar ',')

161− st <- get

162− put (st { modules = modules st ++ ms })

145+ <|> clause "modules" (commaSep (fst <$> iName [])) (\st v -> st { modules = modules st ++ v })

163−

164− <|> do reserved "libs"; lchar '=';

165− ls <- P.sepBy1 (fst <$> identifier) (lchar ',')

166− st <- get

167− put (st { libdeps = libdeps st ++ ls })

146+ <|> clause "libs" (commaSep (fst <$> identifier)) (\st v -> st { libdeps = libdeps st ++ v })

168−

147+ <|> clause "objs" (commaSep (fst <$> identifier)) (\st v -> st { objs = objs st ++ v })

169− <|> do reserved "objs"; lchar '=';

170− ls <- P.sepBy1 (fst <$> identifier) (lchar ',')

171− st <- get

172− put (st { objs = objs st ++ ls })

173−

174− <|> do reserved "makefile"; lchar '=';

175− mk <- fst <$> iName []

176− st <- get

177− put (st { makefile = Just (show mk) })

148+ <|> clause "makefile" (fst <$> iName []) (\st v -> st { makefile = Just (show v) })

178−

179− <|> do reserved "tests"; lchar '=';

180− ts <- P.sepBy1 (fst <$> iName []) (lchar ',')

181− st <- get

182− put st { idris_tests = idris_tests st ++ ts }

149+ <|> clause "tests" (commaSep (fst <$> iName [])) (\st v -> st { idris_tests = idris_tests st ++ v })

183−

184− <|> do reserved "version"

185− lchar '='

186− vStr <- many (P.satisfy (not . isEol))

187− eol

188− P.someSpace

189− st <- get

190− put st {pkgversion = Just vStr}

150+ <|> clause "version" textUntilEol (\st v -> st { pkgversion = Just v })

191−

192− <|> do reserved "readme"

193− lchar '='

194− rme <- textUntilEol

195− st <- get

196− put (st { pkgreadme = Just rme })

151+ <|> clause "readme" textUntilEol (\st v -> st { pkgreadme = Just v })

197−

198− <|> do reserved "license"

199− lchar '='

200− lStr <- textUntilEol

201− st <- get

202− put st {pkglicense = Just lStr}

152+ <|> clause "license" textUntilEol (\st v -> st { pkglicense = Just v })

203−

204− <|> do reserved "homepage"

205− lchar '='

206− www <- textUntilEol

207− st <- get

208− put st {pkghomepage = Just www}

153+ <|> clause "homepage" textUntilEol (\st v -> st { pkghomepage = Just v })

209−

210− <|> do reserved "sourceloc"

211− lchar '='

212− srcpage <- textUntilEol

213− st <- get

214− put st {pkgsourceloc = Just srcpage}

154+ <|> clause "sourceloc" textUntilEol (\st v -> st { pkgsourceloc = Just v })

215−

216− <|> do reserved "bugtracker"

217− lchar '='

218− src <- textUntilEol

219− st <- get

220− put st {pkgbugtracker = Just src}

155+ <|> clause "bugtracker" textUntilEol (\st v -> st { pkgbugtracker = Just v })

221−

156+ <|> clause "brief" (P.stringLiteral <* P.someSpace) (\st v -> st { pkgbrief = Just v })

222− <|> do reserved "brief"

223− lchar '='

224− brief <- P.stringLiteral

225− st <- get

226− P.someSpace

227− put st {pkgbrief = Just brief}

228−

229− <|> do reserved "author"; lchar '=';

230− author <- many (P.satisfy (not . isEol))

231− eol

232− P.someSpace

233− st <- get

234− put st {pkgauthor = Just author}

157+ <|> clause "author" textUntilEol (\st v -> st { pkgauthor = Just v })

235−

236− <|> do reserved "maintainer"; lchar '=';

237− maintainer <- many (P.satisfy (not . isEol))

238− eol

239− P.someSpace

240− st <- get

241− put st {pkgmaintainer = Just maintainer}

158+ <|> clause "maintainer" textUntilEol (\st v -> st { pkgmaintainer = Just v })