{-# LANGUAGE CPP #-}
{-|
Module      : Idris.CmdOptions
Description : A parser for the CmdOptions for the Idris executable.
License     : BSD3
Maintainer  : The Idris Community.
-}

{-# LANGUAGE Arrows #-}

module Idris.CmdOptions
  ( opt, getClient, getPkg, getPkgCheck, getPkgClean, getPkgMkDoc,
    getPkgREPL, getPkgTest, getPort, getIBCSubDir,
    pureArgParser, execArgParserPure, runArgParser
  ) where

import Idris.Info (getIdrisVersion)
import Idris.Options
import IRTS.CodegenCommon

import qualified Control.Monad.Fail as Fail
import Control.Monad.Trans (lift)
import Control.Monad.Trans.Except (throwE)
import Control.Monad.Trans.Reader (ask)
import Data.Char
import Data.Maybe
import Data.Monoid ((<>))
import Options.Applicative
import Options.Applicative.Arrows
import Options.Applicative.Types (ReadM(..))

import Text.ParserCombinators.ReadP hiding (many, option)

import Safe (lastMay)
import qualified Text.PrettyPrint.ANSI.Leijen as PP

runArgParser :: IO [Opt]
runArgParser :: IO [Opt]
runArgParser = do [Opt]
opts <- ParserInfo [Opt] -> IO [Opt]
forall a. ParserInfo a -> IO a
execParser (ParserInfo [Opt] -> IO [Opt]) -> ParserInfo [Opt] -> IO [Opt]
forall a b. (a -> b) -> a -> b
$ Parser [Opt] -> InfoMod [Opt] -> ParserInfo [Opt]
forall a. Parser a -> InfoMod a -> ParserInfo a
info Parser [Opt]
parser
                          (InfoMod [Opt]
forall a. InfoMod a
fullDesc
                           InfoMod [Opt] -> InfoMod [Opt] -> InfoMod [Opt]
forall a. Semigroup a => a -> a -> a
<> Maybe Doc -> InfoMod [Opt]
forall a. Maybe Doc -> InfoMod a
headerDoc   (Doc -> Maybe Doc
forall a. a -> Maybe a
Just Doc
idrisHeader)
                           InfoMod [Opt] -> InfoMod [Opt] -> InfoMod [Opt]
forall a. Semigroup a => a -> a -> a
<> Maybe Doc -> InfoMod [Opt]
forall a. Maybe Doc -> InfoMod a
progDescDoc (Doc -> Maybe Doc
forall a. a -> Maybe a
Just Doc
idrisProgDesc)
                           InfoMod [Opt] -> InfoMod [Opt] -> InfoMod [Opt]
forall a. Semigroup a => a -> a -> a
<> Maybe Doc -> InfoMod [Opt]
forall a. Maybe Doc -> InfoMod a
footerDoc   (Doc -> Maybe Doc
forall a. a -> Maybe a
Just Doc
idrisFooter)
                          )
                  [Opt] -> IO [Opt]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Opt] -> IO [Opt]) -> [Opt] -> IO [Opt]
forall a b. (a -> b) -> a -> b
$ [Opt] -> [Opt]
preProcOpts [Opt]
opts
               where
                 idrisHeader :: Doc
idrisHeader = [Doc] -> Doc
PP.hsep [String -> Doc
PP.text "Idris version", String -> Doc
PP.text String
getIdrisVersion, String -> Doc
PP.text ", (C) The Idris Community 2016"]
                 idrisProgDesc :: Doc
idrisProgDesc = [Doc] -> Doc
PP.vsep [Doc
PP.empty,
                                          String -> Doc
PP.text "Idris is a general purpose pure functional programming language with dependent",
                                          String -> Doc
PP.text "types. Dependent types allow types to be predicated on values, meaning that",
                                          String -> Doc
PP.text "some aspects of a program's behaviour can be specified precisely in the type.",
                                          String -> Doc
PP.text "It is compiled, with eager evaluation. Its features are influenced by Haskell",
                                          String -> Doc
PP.text "and ML.",
                                          Doc
PP.empty,
                                          [Doc] -> Doc
PP.vsep ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ (String -> Doc) -> [String] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Doc -> Doc
PP.indent 4 (Doc -> Doc) -> (String -> Doc) -> String -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc
PP.text) [
                                              "+ Full dependent types with dependent pattern matching",
                                              "+ Simple case expressions, where-clauses, with-rule",
                                              "+ Pattern matching let- and lambda-bindings",
                                              "+ Overloading via Interfaces (Type class-like), Monad comprehensions",
                                              "+ do-notation, idiom brackets",
                                              "+ Syntactic conveniences for lists, tuples, dependent pairs",
                                              "+ Totality checking",
                                              "+ Coinductive types",
                                              "+ Indentation significant syntax, Extensible syntax",
                                              "+ Tactic based theorem proving (influenced by Coq)",
                                              "+ Cumulative universes",
                                              "+ Simple Foreign Function Interface",
                                              "+ Hugs style interactive environment"
                                            ]]
                 idrisFooter :: Doc
idrisFooter = [Doc] -> Doc
PP.vsep [String -> Doc
PP.text "It is important to note that Idris is first and foremost a research tool",
                                        String -> Doc
PP.text "and project. Thus the tooling provided and resulting programs created",
                                        String -> Doc
PP.text "should not necessarily be seen as production ready nor for industrial use.",
                                        Doc
PP.empty,
                                        String -> Doc
PP.text "More details over Idris can be found online here:",
                                        Doc
PP.empty,
                                        Int -> Doc -> Doc
PP.indent 4 (String -> Doc
PP.text "https://www.idris-lang.org/")]

execArgParserPure :: [String] -> ParserResult [Opt]
execArgParserPure :: [String] -> ParserResult [Opt]
execArgParserPure args :: [String]
args = [Opt] -> [Opt]
preProcOpts ([Opt] -> [Opt]) -> ParserResult [Opt] -> ParserResult [Opt]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserPrefs -> ParserInfo [Opt] -> [String] -> ParserResult [Opt]
forall a. ParserPrefs -> ParserInfo a -> [String] -> ParserResult a
execParserPure (PrefsMod -> ParserPrefs
prefs PrefsMod
forall m. Monoid m => m
idm) (Parser [Opt] -> InfoMod [Opt] -> ParserInfo [Opt]
forall a. Parser a -> InfoMod a -> ParserInfo a
info Parser [Opt]
parser InfoMod [Opt]
forall m. Monoid m => m
idm) [String]
args

pureArgParser :: [String] -> [Opt]
pureArgParser :: [String] -> [Opt]
pureArgParser args :: [String]
args = case ParserResult [Opt] -> Maybe [Opt]
forall a. ParserResult a -> Maybe a
getParseResult ([String] -> ParserResult [Opt]
execArgParserPure [String]
args) of
  Just opts :: [Opt]
opts -> [Opt] -> [Opt]
preProcOpts [Opt]
opts
  Nothing   -> []

parser :: Parser [Opt]
parser :: Parser [Opt]
parser = A Parser () [Opt] -> Parser [Opt]
forall (f :: * -> *) a. Applicative f => A f () a -> f a
runA (A Parser () [Opt] -> Parser [Opt])
-> A Parser () [Opt] -> Parser [Opt]
forall a b. (a -> b) -> a -> b
$ proc () -> do
  [Opt]
flags <- Parser [Opt] -> A Parser () [Opt]
forall (f :: * -> *) a. Applicative f => f a -> A f () a
asA Parser [Opt]
parseFlags -< ()
  [Opt]
files <- Parser [Opt] -> A Parser () [Opt]
forall (f :: * -> *) a. Applicative f => f a -> A f () a
asA (Parser Opt -> Parser [Opt]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser Opt -> Parser [Opt]) -> Parser Opt -> Parser [Opt]
forall a b. (a -> b) -> a -> b
$ ReadM Opt -> Mod ArgumentFields Opt -> Parser Opt
forall a. ReadM a -> Mod ArgumentFields a -> Parser a
argument ((String -> Opt) -> ReadM String -> ReadM Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> Opt
Filename ReadM String
forall s. IsString s => ReadM s
str) (String -> Mod ArgumentFields Opt
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "FILES")) -< ()
  Parser ([Opt] -> [Opt]) -> A Parser [Opt] [Opt]
forall (f :: * -> *) a b. f (a -> b) -> A f a b
A Parser ([Opt] -> [Opt])
forall a. Parser (a -> a)
parseVersion A Parser [Opt] [Opt]
-> A Parser [Opt] [Opt] -> A Parser [Opt] [Opt]
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Parser ([Opt] -> [Opt]) -> A Parser [Opt] [Opt]
forall (f :: * -> *) a b. f (a -> b) -> A f a b
A Parser ([Opt] -> [Opt])
forall a. Parser (a -> a)
helper -< ([Opt]
flags [Opt] -> [Opt] -> [Opt]
forall a. [a] -> [a] -> [a]
++ [Opt]
files)

parseFlags :: Parser [Opt]
parseFlags :: Parser [Opt]
parseFlags = Parser Opt -> Parser [Opt]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser Opt -> Parser [Opt]) -> Parser Opt -> Parser [Opt]
forall a b. (a -> b) -> a -> b
$
      Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
NoBanner (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "nobanner" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Suppress the banner")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
Quiet    (Char -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'q' Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "quiet" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Quiet verbosity")

  -- IDE Mode Specific Flags
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
Idemode       (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "ide-mode"        Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Run the Idris REPL with machine-readable syntax")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
IdemodeSocket (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "ide-mode-socket" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Choose a socket for IDE mode to listen on")

  -- Client flags
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
Client (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "client")

  -- Logging Flags
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Opt
OLogging (Int -> Opt) -> Parser Int -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM Int
forall a. Read a => ReadM a
auto (String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "log" Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Int
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "LEVEL" Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help "Debugging log level")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [LogCat] -> Opt
OLogCats ([LogCat] -> Opt) -> Parser [LogCat] -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM [LogCat] -> Mod OptionFields [LogCat] -> Parser [LogCat]
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (ReadM String
forall s. IsString s => ReadM s
str ReadM String -> (String -> ReadM [LogCat]) -> ReadM [LogCat]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> ReadM [LogCat]
forall (m :: * -> *). MonadFail m => String -> m [LogCat]
parseLogCats)
                           (String -> Mod OptionFields [LogCat]
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "logging-categories"
                         Mod OptionFields [LogCat]
-> Mod OptionFields [LogCat] -> Mod OptionFields [LogCat]
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields [LogCat]
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "CATS"
                         Mod OptionFields [LogCat]
-> Mod OptionFields [LogCat] -> Mod OptionFields [LogCat]
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields [LogCat]
forall (f :: * -> *) a. String -> Mod f a
help "Colon separated logging categories. Use --listlogcats to see list.")

  -- Turn off things
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
NoBasePkgs (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "nobasepkgs" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Do not use the given base package")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
NoPrelude  (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "noprelude"  Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Do not use the given prelude")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
NoBuiltins (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "nobuiltins" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Do not use the builtin functions")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
NoREPL     (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "check"      Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Typecheck only, don't start the REPL")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
Output (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Char -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'o' Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "output" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "FILE" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Specify output file")

  --   <|> flag' TypeCase (long "typecase")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
Interface      (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "interface"   Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Generate interface files from ExportLists")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
TypeInType     (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "typeintype"  Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Turn off Universe checking")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
DefaultTotal   (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "total"       Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Require functions to be total by default")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
DefaultPartial (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "partial")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
WarnPartial    (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "warnpartial" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Warn about undeclared partial functions")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
WarnReach      (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "warnreach"   Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Warn about reachable but inaccessible arguments")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
AuditIPkg      (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "warnipkg"    Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Warn about possible incorrect package specifications")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
NoCoverage     (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "nocoverage")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
ErrContext     (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "errorcontext")

  -- Show things
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
ShowAll         (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "info"        Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Display information about installation.")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
ShowLoggingCats (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "listlogcats" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Display logging categories")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
ShowLibs        (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "link"        Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Display link flags")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
ShowPkgs        (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "listlibs"    Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Display installed libraries")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
ShowLibDir      (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "libdir"      Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Display library directory")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
ShowDocDir      (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "docdir"      Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Display idrisdoc install directory")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
ShowIncs        (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "include"     Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Display the includes flags")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Int -> Opt
Verbose 3) (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "V2" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Loudest verbosity")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Int -> Opt
Verbose 2) (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "V1" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Louder verbosity")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Int -> Opt
Verbose 1) (Char -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'V' Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "V0" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<>String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "verbose" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Loud verbosity")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
IBCSubDir (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "ibcsubdir" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "FILE" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Write IBC files into sub directory")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
ImportDir (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Char -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'i' Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "idrispath" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Add directory to the list of import paths")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
SourceDir (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "sourcepath" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Add directory to the list of source search paths")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
WarnOnly (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "warn")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
Pkg  (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Char -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'p' Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "package" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Add package as a dependency")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> REPLPort -> Opt
Port (REPLPort -> Opt) -> Parser REPLPort -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM REPLPort -> Mod OptionFields REPLPort -> Parser REPLPort
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM REPLPort
portReader (String -> Mod OptionFields REPLPort
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "port" Mod OptionFields REPLPort
-> Mod OptionFields REPLPort -> Mod OptionFields REPLPort
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields REPLPort
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "PORT" Mod OptionFields REPLPort
-> Mod OptionFields REPLPort -> Mod OptionFields REPLPort
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields REPLPort
forall (f :: * -> *) a. String -> Mod f a
help "REPL TCP port - pass \"none\" to not bind any port")

  -- Package commands
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
PkgBuild   (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "build"    Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "IPKG" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Build package")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
PkgInstall (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "install"  Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "IPKG" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Install package")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
PkgREPL    (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "repl"     Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "IPKG" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Launch REPL, only for executables")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
PkgClean   (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "clean"    Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "IPKG" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Clean package")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (String -> Opt
PkgDocBuild   (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "mkdoc"      Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "IPKG" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Generate IdrisDoc for package"))
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
PkgDocInstall (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "installdoc" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "IPKG" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Install IdrisDoc for package")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
PkgCheck   (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "checkpkg" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "IPKG" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Check package only")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
PkgTest    (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "testpkg"  Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "IPKG" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Run tests for package")

  -- Interactive Editing Flags
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Opt
IndentWith    (Int -> Opt) -> Parser Int -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM Int
forall a. Read a => ReadM a
auto (String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "indent-with"
                                           Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Int
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "INDENT"
                                           Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help "Indentation to use with :makewith (default 2)")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Opt
IndentClause  (Int -> Opt) -> Parser Int -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM Int
forall a. Read a => ReadM a
auto (String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "indent-clause"
                                           Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Int
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "INDENT"
                                           Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help "Indentation to use with :addclause (default 2)")

  -- Misc options
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
BCAsm (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "bytecode")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (OutputType -> Opt
OutputTy OutputType
Raw)          (Char -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'S' Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "codegenonly" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Do no further compilation of code generator output")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (OutputType -> Opt
OutputTy OutputType
Object)       (Char -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'c' Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "compileonly" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Compile to object files rather than an executable")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
DumpDefun (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "dumpdefuns")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
DumpCases (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "dumpcases")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Codegen -> Opt
UseCodegen (Codegen -> Opt) -> (String -> Codegen) -> String -> Opt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Codegen
parseCodegen) (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "codegen"
                                              Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "TARGET"
                                              Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Select code generator: C, Javascript, Node and bytecode are bundled with Idris")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((Codegen -> Opt
UseCodegen (Codegen -> Opt) -> (String -> Codegen) -> String -> Opt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IRFormat -> String -> Codegen
Via IRFormat
JSONFormat) (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "portable-codegen"
                                                 Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "TARGET"
                                                 Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Pass the name of the code generator. This option is for codegens that take JSON formatted IR."))

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
CodegenArgs (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "cg-opt"
                                 Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "ARG"
                                 Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Arguments to pass to code generator")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
EvalExpr (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "eval"
                              Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> Char -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'e'
                              Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "EXPR"
                              Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Evaluate an expression without loading the REPL")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (String -> Opt
InterpretScript "Main.main") (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "execute" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Execute as idris")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
InterpretScript (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption      (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "exec" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "EXPR" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Execute as idris")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((LanguageExt -> Opt
Extension (LanguageExt -> Opt) -> (String -> LanguageExt) -> String -> Opt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> LanguageExt
getExt) (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "extension"
                                        Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> Char -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'X'
                                        Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "EXT"
                                        Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Turn on language extension (TypeProviders or ErrorReflection)"))

  -- Optimisation Levels
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Int -> Opt
OptLevel 3) (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "O3")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Int -> Opt
OptLevel 2) (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "O2")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Int -> Opt
OptLevel 1) (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "O1")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Int -> Opt
OptLevel 0) (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "O0")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Optimisation -> Opt
AddOpt Optimisation
PETransform) (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "partial-eval")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Optimisation -> Opt
RemoveOpt Optimisation
PETransform) (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "no-partial-eval" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Switch off partial evaluation, mainly for debugging purposes")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Optimisation -> Opt
AddOpt Optimisation
GeneralisedNatHack) (
    String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "optimise-nat-like-types"
    Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "optimize-nat-like-types"
    Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Enable compilation of Nat-like types to bigints"
  )
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Optimisation -> Opt
RemoveOpt Optimisation
GeneralisedNatHack) (
    String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "no-optimise-nat-like-types"
    Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "no-optimize-nat-like-types"
    Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Disable compilation of Nat-like types to bigints"
  )

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Opt
OptLevel (Int -> Opt) -> Parser Int -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM Int
forall a. Read a => ReadM a
auto (Char -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'O' Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "level")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
TargetTriple (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "target" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "TRIPLE" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "If supported the codegen will target the named triple.")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> Opt
TargetCPU    (String -> Opt) -> Parser String -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "cpu"    Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "CPU"    Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "If supported the codegen will target the named CPU e.g. corei7 or cortex-m3")

  -- Colour Options
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Bool -> Opt
ColourREPL Bool
True)  (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "colour"   Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "color"   Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Force coloured output")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' (Bool -> Opt
ColourREPL Bool
False) (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "nocolour" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "nocolor" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Disable coloured output")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (ConsoleWidth -> Opt
UseConsoleWidth (ConsoleWidth -> Opt) -> Parser ConsoleWidth -> Parser Opt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM ConsoleWidth
-> Mod OptionFields ConsoleWidth -> Parser ConsoleWidth
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (ReadM String
forall s. IsString s => ReadM s
str ReadM String
-> (String -> ReadM ConsoleWidth) -> ReadM ConsoleWidth
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> ReadM ConsoleWidth
forall (m :: * -> *). MonadFail m => String -> m ConsoleWidth
parseConsoleWidth) (String -> Mod OptionFields ConsoleWidth
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "consolewidth" Mod OptionFields ConsoleWidth
-> Mod OptionFields ConsoleWidth -> Mod OptionFields ConsoleWidth
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields ConsoleWidth
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "WIDTH" Mod OptionFields ConsoleWidth
-> Mod OptionFields ConsoleWidth -> Mod OptionFields ConsoleWidth
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields ConsoleWidth
forall (f :: * -> *) a. String -> Mod f a
help "Select console width: auto, infinite, nat"))

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
DumpHighlights (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "highlight" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Emit source code highlighting")

  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
NoOldTacticDeprecationWarnings (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "no-tactic-deprecation-warnings" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Disable deprecation warnings for the old tactic sublanguage")
  Parser Opt -> Parser Opt -> Parser Opt
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Opt -> Mod FlagFields Opt -> Parser Opt
forall a. a -> Mod FlagFields a -> Parser a
flag' Opt
AllowCapitalizedPatternVariables (String -> Mod FlagFields Opt
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "allow-capitalized-pattern-variables" Mod FlagFields Opt -> Mod FlagFields Opt -> Mod FlagFields Opt
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Opt
forall (f :: * -> *) a. String -> Mod f a
help "Allow pattern variables to be capitalized")

    where
      getExt :: String -> LanguageExt
      getExt :: String -> LanguageExt
getExt s :: String
s = LanguageExt -> Maybe LanguageExt -> LanguageExt
forall a. a -> Maybe a -> a
fromMaybe (String -> LanguageExt
forall a. HasCallStack => String -> a
error ("Unknown extension " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
s)) (String -> Maybe LanguageExt
maybeRead String
s)
      maybeRead :: String -> Maybe LanguageExt
      maybeRead :: String -> Maybe LanguageExt
maybeRead = ((LanguageExt, String) -> LanguageExt)
-> Maybe (LanguageExt, String) -> Maybe LanguageExt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LanguageExt, String) -> LanguageExt
forall a b. (a, b) -> a
fst (Maybe (LanguageExt, String) -> Maybe LanguageExt)
-> (String -> Maybe (LanguageExt, String))
-> String
-> Maybe LanguageExt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(LanguageExt, String)] -> Maybe (LanguageExt, String)
forall a. [a] -> Maybe a
listToMaybe ([(LanguageExt, String)] -> Maybe (LanguageExt, String))
-> (String -> [(LanguageExt, String)])
-> String
-> Maybe (LanguageExt, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [(LanguageExt, String)]
forall a. Read a => ReadS a
reads
      portReader :: ReadM REPLPort
      portReader :: ReadM REPLPort
portReader =
        ((PortNumber -> REPLPort
ListenPort (PortNumber -> REPLPort)
-> (Integer -> PortNumber) -> Integer -> REPLPort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> PortNumber
forall a b. (Integral a, Num b) => a -> b
fromIntegral) (Integer -> REPLPort) -> ReadM Integer -> ReadM REPLPort
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM Integer
forall a. Read a => ReadM a
auto) ReadM REPLPort -> ReadM REPLPort -> ReadM REPLPort
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
        (ReaderT String (Except ParseError) REPLPort -> ReadM REPLPort
forall a. ReaderT String (Except ParseError) a -> ReadM a
ReadM (ReaderT String (Except ParseError) REPLPort -> ReadM REPLPort)
-> ReaderT String (Except ParseError) REPLPort -> ReadM REPLPort
forall a b. (a -> b) -> a -> b
$ do String
opt <- ReaderT String (Except ParseError) String
forall (m :: * -> *) r. Monad m => ReaderT r m r
ask
                    if (Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower String
opt String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "none"
                      then REPLPort -> ReaderT String (Except ParseError) REPLPort
forall (m :: * -> *) a. Monad m => a -> m a
return (REPLPort -> ReaderT String (Except ParseError) REPLPort)
-> REPLPort -> ReaderT String (Except ParseError) REPLPort
forall a b. (a -> b) -> a -> b
$ REPLPort
DontListen
                      else ExceptT ParseError Identity REPLPort
-> ReaderT String (Except ParseError) REPLPort
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ExceptT ParseError Identity REPLPort
 -> ReaderT String (Except ParseError) REPLPort)
-> ExceptT ParseError Identity REPLPort
-> ReaderT String (Except ParseError) REPLPort
forall a b. (a -> b) -> a -> b
$ ParseError -> ExceptT ParseError Identity REPLPort
forall (m :: * -> *) e a. Monad m => e -> ExceptT e m a
throwE (ParseError -> ExceptT ParseError Identity REPLPort)
-> ParseError -> ExceptT ParseError Identity REPLPort
forall a b. (a -> b) -> a -> b
$ String -> ParseError
ErrorMsg (String -> ParseError) -> String -> ParseError
forall a b. (a -> b) -> a -> b
$
                           "got " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
opt String -> String -> String
forall a. Semigroup a => a -> a -> a
<> " expected port number or \"none\"")

parseVersion :: Parser (a -> a)
parseVersion :: Parser (a -> a)
parseVersion = String -> Mod OptionFields (a -> a) -> Parser (a -> a)
forall a. String -> Mod OptionFields (a -> a) -> Parser (a -> a)
infoOption String
getIdrisVersion (Char -> Mod OptionFields (a -> a)
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'v' Mod OptionFields (a -> a)
-> Mod OptionFields (a -> a) -> Mod OptionFields (a -> a)
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields (a -> a)
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "version" Mod OptionFields (a -> a)
-> Mod OptionFields (a -> a) -> Mod OptionFields (a -> a)
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields (a -> a)
forall (f :: * -> *) a. String -> Mod f a
help "Print version information")

preProcOpts :: [Opt] -> [Opt]
preProcOpts :: [Opt] -> [Opt]
preProcOpts (NoBuiltins : xs :: [Opt]
xs) = Opt
NoBuiltins Opt -> [Opt] -> [Opt]
forall a. a -> [a] -> [a]
: Opt
NoPrelude Opt -> [Opt] -> [Opt]
forall a. a -> [a] -> [a]
: [Opt] -> [Opt]
preProcOpts [Opt]
xs
preProcOpts (Output s :: String
s : xs :: [Opt]
xs)   = String -> Opt
Output String
s Opt -> [Opt] -> [Opt]
forall a. a -> [a] -> [a]
: Opt
NoREPL Opt -> [Opt] -> [Opt]
forall a. a -> [a] -> [a]
: [Opt] -> [Opt]
preProcOpts [Opt]
xs
preProcOpts (BCAsm s :: String
s : xs :: [Opt]
xs)    = String -> Opt
BCAsm String
s Opt -> [Opt] -> [Opt]
forall a. a -> [a] -> [a]
: Opt
NoREPL Opt -> [Opt] -> [Opt]
forall a. a -> [a] -> [a]
: [Opt] -> [Opt]
preProcOpts [Opt]
xs
preProcOpts (x :: Opt
x:xs :: [Opt]
xs)            = Opt
x Opt -> [Opt] -> [Opt]
forall a. a -> [a] -> [a]
: [Opt] -> [Opt]
preProcOpts [Opt]
xs
preProcOpts []                = []

parseCodegen :: String -> Codegen
parseCodegen :: String -> Codegen
parseCodegen "bytecode" = Codegen
Bytecode
parseCodegen cg :: String
cg         = IRFormat -> String -> Codegen
Via IRFormat
IBCFormat ((Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower String
cg)

parseLogCats :: Fail.MonadFail m => String -> m [LogCat]
parseLogCats :: String -> m [LogCat]
parseLogCats s :: String
s =
    case [([LogCat], String)] -> Maybe ([LogCat], String)
forall a. [a] -> Maybe a
lastMay (ReadP [LogCat] -> ReadS [LogCat]
forall a. ReadP a -> ReadS a
readP_to_S ReadP [LogCat]
doParse String
s) of
      Just (xs :: [LogCat]
xs, _) -> [LogCat] -> m [LogCat]
forall (m :: * -> *) a. Monad m => a -> m a
return [LogCat]
xs
      _            -> String -> m [LogCat]
forall (m :: * -> *) a. MonadFail m => String -> m a
fail "Incorrect categories specified"
  where
    doParse :: ReadP [LogCat]
    doParse :: ReadP [LogCat]
doParse = do
      [[LogCat]]
cs <- ReadP [LogCat] -> ReadP Char -> ReadP [[LogCat]]
forall a sep. ReadP a -> ReadP sep -> ReadP [a]
sepBy1 ReadP [LogCat]
parseLogCat (Char -> ReadP Char
char ':')
      ReadP ()
eof
      [LogCat] -> ReadP [LogCat]
forall (m :: * -> *) a. Monad m => a -> m a
return ([[LogCat]] -> [LogCat]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[LogCat]]
cs)

    parseLogCat :: ReadP [LogCat]
    parseLogCat :: ReadP [LogCat]
parseLogCat = (String -> ReadP String
string (LogCat -> String
strLogCat LogCat
IParse)    ReadP String -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> [LogCat] -> ReadP [LogCat]
forall (m :: * -> *) a. Monad m => a -> m a
return [LogCat]
parserCats)
              ReadP [LogCat] -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (String -> ReadP String
string (LogCat -> String
strLogCat LogCat
IElab)     ReadP String -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> [LogCat] -> ReadP [LogCat]
forall (m :: * -> *) a. Monad m => a -> m a
return [LogCat]
elabCats)
              ReadP [LogCat] -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (String -> ReadP String
string (LogCat -> String
strLogCat LogCat
ICodeGen)  ReadP String -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> [LogCat] -> ReadP [LogCat]
forall (m :: * -> *) a. Monad m => a -> m a
return [LogCat]
codegenCats)
              ReadP [LogCat] -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (String -> ReadP String
string (LogCat -> String
strLogCat LogCat
ICoverage) ReadP String -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> [LogCat] -> ReadP [LogCat]
forall (m :: * -> *) a. Monad m => a -> m a
return [LogCat
ICoverage])
              ReadP [LogCat] -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (String -> ReadP String
string (LogCat -> String
strLogCat LogCat
IIBC)      ReadP String -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> [LogCat] -> ReadP [LogCat]
forall (m :: * -> *) a. Monad m => a -> m a
return [LogCat
IIBC])
              ReadP [LogCat] -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (String -> ReadP String
string (LogCat -> String
strLogCat LogCat
IErasure)  ReadP String -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> [LogCat] -> ReadP [LogCat]
forall (m :: * -> *) a. Monad m => a -> m a
return [LogCat
IErasure])
              ReadP [LogCat] -> ReadP [LogCat] -> ReadP [LogCat]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ReadP [LogCat]
parseLogCatBad

    parseLogCatBad :: ReadP [LogCat]
    parseLogCatBad :: ReadP [LogCat]
parseLogCatBad = do
      String
s <- ReadP String
look
      String -> ReadP [LogCat]
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> ReadP [LogCat]) -> String -> ReadP [LogCat]
forall a b. (a -> b) -> a -> b
$ "Category: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ " is not recognised."

parseConsoleWidth :: Fail.MonadFail m => String -> m ConsoleWidth
parseConsoleWidth :: String -> m ConsoleWidth
parseConsoleWidth "auto"     = ConsoleWidth -> m ConsoleWidth
forall (m :: * -> *) a. Monad m => a -> m a
return ConsoleWidth
AutomaticWidth
parseConsoleWidth "infinite" = ConsoleWidth -> m ConsoleWidth
forall (m :: * -> *) a. Monad m => a -> m a
return ConsoleWidth
InfinitelyWide
parseConsoleWidth  s :: String
s =
  case [(Int, String)] -> Maybe (Int, String)
forall a. [a] -> Maybe a
lastMay (ReadP Int -> ReadS Int
forall a. ReadP a -> ReadS a
readP_to_S ReadP Int
integerReader String
s) of
     Just (r :: Int
r, _) -> ConsoleWidth -> m ConsoleWidth
forall (m :: * -> *) a. Monad m => a -> m a
return (ConsoleWidth -> m ConsoleWidth) -> ConsoleWidth -> m ConsoleWidth
forall a b. (a -> b) -> a -> b
$ Int -> ConsoleWidth
ColsWide Int
r
     _           -> String -> m ConsoleWidth
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m ConsoleWidth) -> String -> m ConsoleWidth
forall a b. (a -> b) -> a -> b
$ "Cannot parse: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
s

integerReader :: ReadP Int
integerReader :: ReadP Int
integerReader = do
    String
digits <- ReadP Char -> ReadP String
forall a. ReadP a -> ReadP [a]
many1 (ReadP Char -> ReadP String) -> ReadP Char -> ReadP String
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> ReadP Char
satisfy Char -> Bool
isDigit
    Int -> ReadP Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> ReadP Int) -> Int -> ReadP Int
forall a b. (a -> b) -> a -> b
$ String -> Int
forall a. Read a => String -> a
read String
digits