module GF.Command.Abstract(module GF.Command.Abstract,Expr,showExpr,Term) where

import PGF(CId,mkCId,Expr,showExpr)
import GF.Grammar.Grammar(Term)

type Ident = String

type CommandLine = [Pipe]

type Pipe = [Command]

data Command
   = Command Ident [Option] Argument
   deriving (Command -> Command -> Bool
(Command -> Command -> Bool)
-> (Command -> Command -> Bool) -> Eq Command
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Command -> Command -> Bool
$c/= :: Command -> Command -> Bool
== :: Command -> Command -> Bool
$c== :: Command -> Command -> Bool
Eq,Eq Command
Eq Command
-> (Command -> Command -> Ordering)
-> (Command -> Command -> Bool)
-> (Command -> Command -> Bool)
-> (Command -> Command -> Bool)
-> (Command -> Command -> Bool)
-> (Command -> Command -> Command)
-> (Command -> Command -> Command)
-> Ord Command
Command -> Command -> Bool
Command -> Command -> Ordering
Command -> Command -> Command
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Command -> Command -> Command
$cmin :: Command -> Command -> Command
max :: Command -> Command -> Command
$cmax :: Command -> Command -> Command
>= :: Command -> Command -> Bool
$c>= :: Command -> Command -> Bool
> :: Command -> Command -> Bool
$c> :: Command -> Command -> Bool
<= :: Command -> Command -> Bool
$c<= :: Command -> Command -> Bool
< :: Command -> Command -> Bool
$c< :: Command -> Command -> Bool
compare :: Command -> Command -> Ordering
$ccompare :: Command -> Command -> Ordering
$cp1Ord :: Eq Command
Ord,Int -> Command -> ShowS
[Command] -> ShowS
Command -> String
(Int -> Command -> ShowS)
-> (Command -> String) -> ([Command] -> ShowS) -> Show Command
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Command] -> ShowS
$cshowList :: [Command] -> ShowS
show :: Command -> String
$cshow :: Command -> String
showsPrec :: Int -> Command -> ShowS
$cshowsPrec :: Int -> Command -> ShowS
Show)

data Option
  = OOpt Ident
  | OFlag Ident Value
  deriving (Option -> Option -> Bool
(Option -> Option -> Bool)
-> (Option -> Option -> Bool) -> Eq Option
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Option -> Option -> Bool
$c/= :: Option -> Option -> Bool
== :: Option -> Option -> Bool
$c== :: Option -> Option -> Bool
Eq,Eq Option
Eq Option
-> (Option -> Option -> Ordering)
-> (Option -> Option -> Bool)
-> (Option -> Option -> Bool)
-> (Option -> Option -> Bool)
-> (Option -> Option -> Bool)
-> (Option -> Option -> Option)
-> (Option -> Option -> Option)
-> Ord Option
Option -> Option -> Bool
Option -> Option -> Ordering
Option -> Option -> Option
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Option -> Option -> Option
$cmin :: Option -> Option -> Option
max :: Option -> Option -> Option
$cmax :: Option -> Option -> Option
>= :: Option -> Option -> Bool
$c>= :: Option -> Option -> Bool
> :: Option -> Option -> Bool
$c> :: Option -> Option -> Bool
<= :: Option -> Option -> Bool
$c<= :: Option -> Option -> Bool
< :: Option -> Option -> Bool
$c< :: Option -> Option -> Bool
compare :: Option -> Option -> Ordering
$ccompare :: Option -> Option -> Ordering
$cp1Ord :: Eq Option
Ord,Int -> Option -> ShowS
[Option] -> ShowS
Option -> String
(Int -> Option -> ShowS)
-> (Option -> String) -> ([Option] -> ShowS) -> Show Option
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Option] -> ShowS
$cshowList :: [Option] -> ShowS
show :: Option -> String
$cshow :: Option -> String
showsPrec :: Int -> Option -> ShowS
$cshowsPrec :: Int -> Option -> ShowS
Show)

data Value
  = VId  Ident
  | VInt Int
  | VStr String
  deriving (Value -> Value -> Bool
(Value -> Value -> Bool) -> (Value -> Value -> Bool) -> Eq Value
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Value -> Value -> Bool
$c/= :: Value -> Value -> Bool
== :: Value -> Value -> Bool
$c== :: Value -> Value -> Bool
Eq,Eq Value
Eq Value
-> (Value -> Value -> Ordering)
-> (Value -> Value -> Bool)
-> (Value -> Value -> Bool)
-> (Value -> Value -> Bool)
-> (Value -> Value -> Bool)
-> (Value -> Value -> Value)
-> (Value -> Value -> Value)
-> Ord Value
Value -> Value -> Bool
Value -> Value -> Ordering
Value -> Value -> Value
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Value -> Value -> Value
$cmin :: Value -> Value -> Value
max :: Value -> Value -> Value
$cmax :: Value -> Value -> Value
>= :: Value -> Value -> Bool
$c>= :: Value -> Value -> Bool
> :: Value -> Value -> Bool
$c> :: Value -> Value -> Bool
<= :: Value -> Value -> Bool
$c<= :: Value -> Value -> Bool
< :: Value -> Value -> Bool
$c< :: Value -> Value -> Bool
compare :: Value -> Value -> Ordering
$ccompare :: Value -> Value -> Ordering
$cp1Ord :: Eq Value
Ord,Int -> Value -> ShowS
[Value] -> ShowS
Value -> String
(Int -> Value -> ShowS)
-> (Value -> String) -> ([Value] -> ShowS) -> Show Value
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Value] -> ShowS
$cshowList :: [Value] -> ShowS
show :: Value -> String
$cshow :: Value -> String
showsPrec :: Int -> Value -> ShowS
$cshowsPrec :: Int -> Value -> ShowS
Show)

data Argument
  = AExpr Expr
  | ATerm Term
  | ANoArg
  | AMacro Ident
  deriving (Argument -> Argument -> Bool
(Argument -> Argument -> Bool)
-> (Argument -> Argument -> Bool) -> Eq Argument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Argument -> Argument -> Bool
$c/= :: Argument -> Argument -> Bool
== :: Argument -> Argument -> Bool
$c== :: Argument -> Argument -> Bool
Eq,Eq Argument
Eq Argument
-> (Argument -> Argument -> Ordering)
-> (Argument -> Argument -> Bool)
-> (Argument -> Argument -> Bool)
-> (Argument -> Argument -> Bool)
-> (Argument -> Argument -> Bool)
-> (Argument -> Argument -> Argument)
-> (Argument -> Argument -> Argument)
-> Ord Argument
Argument -> Argument -> Bool
Argument -> Argument -> Ordering
Argument -> Argument -> Argument
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Argument -> Argument -> Argument
$cmin :: Argument -> Argument -> Argument
max :: Argument -> Argument -> Argument
$cmax :: Argument -> Argument -> Argument
>= :: Argument -> Argument -> Bool
$c>= :: Argument -> Argument -> Bool
> :: Argument -> Argument -> Bool
$c> :: Argument -> Argument -> Bool
<= :: Argument -> Argument -> Bool
$c<= :: Argument -> Argument -> Bool
< :: Argument -> Argument -> Bool
$c< :: Argument -> Argument -> Bool
compare :: Argument -> Argument -> Ordering
$ccompare :: Argument -> Argument -> Ordering
$cp1Ord :: Eq Argument
Ord,Int -> Argument -> ShowS
[Argument] -> ShowS
Argument -> String
(Int -> Argument -> ShowS)
-> (Argument -> String) -> ([Argument] -> ShowS) -> Show Argument
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Argument] -> ShowS
$cshowList :: [Argument] -> ShowS
show :: Argument -> String
$cshow :: Argument -> String
showsPrec :: Int -> Argument -> ShowS
$cshowsPrec :: Int -> Argument -> ShowS
Show)

valCIdOpts :: String -> CId -> [Option] -> CId
valCIdOpts :: String -> CId -> [Option] -> CId
valCIdOpts String
flag CId
def [Option]
opts =
  case [String
v | OFlag String
f (VId String
v) <- [Option]
opts, String
f String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
flag] of
    (String
v:[String]
_) -> String -> CId
mkCId String
v
    [String]
_     -> CId
def

valIntOpts :: String -> Int -> [Option] -> Int
valIntOpts :: String -> Int -> [Option] -> Int
valIntOpts String
flag Int
def [Option]
opts =
  case [Int
v | OFlag String
f (VInt Int
v) <- [Option]
opts, String
f String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
flag] of
    (Int
v:[Int]
_) -> Int
v
    [Int]
_     -> Int
def

valStrOpts :: String -> String -> [Option] -> String
valStrOpts :: String -> String -> [Option] -> String
valStrOpts String
flag String
def [Option]
opts =
  case String -> [Option] -> [Value]
listFlags String
flag [Option]
opts of
    Value
v:[Value]
_ -> Value -> String
valueString Value
v
    [Value]
_   -> String
def

listFlags :: String -> [Option] -> [Value]
listFlags String
flag [Option]
opts = [Value
v | OFlag String
f Value
v <- [Option]
opts, String
f String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
flag]

valueString :: Value -> String
valueString Value
v =
  case Value
v of
    VStr String
v -> String
v
    VId  String
v -> String
v
    VInt Int
v -> Int -> String
forall a. Show a => a -> String
show Int
v

isOpt :: String -> [Option] -> Bool
isOpt :: String -> [Option] -> Bool
isOpt String
o [Option]
opts = Option -> [Option] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem (String -> Option
OOpt String
o) [Option]
opts

isFlag :: String -> [Option] -> Bool
isFlag :: String -> [Option] -> Bool
isFlag String
o [Option]
opts = String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem String
o [String
x | OFlag String
x Value
_ <- [Option]
opts]

optsAndFlags :: [Option] -> ([Option],[Option])
optsAndFlags :: [Option] -> ([Option], [Option])
optsAndFlags = (Option -> ([Option], [Option]) -> ([Option], [Option]))
-> ([Option], [Option]) -> [Option] -> ([Option], [Option])
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Option -> ([Option], [Option]) -> ([Option], [Option])
add ([],[]) where
  add :: Option -> ([Option], [Option]) -> ([Option], [Option])
add Option
o ([Option]
os,[Option]
fs) = case Option
o of
    OOpt String
_    -> (Option
oOption -> [Option] -> [Option]
forall a. a -> [a] -> [a]
:[Option]
os,[Option]
fs)
    OFlag String
_ Value
_ -> ([Option]
os,Option
oOption -> [Option] -> [Option]
forall a. a -> [a] -> [a]
:[Option]
fs)

prOpt :: Option -> String
prOpt :: Option -> String
prOpt Option
o = case Option
o of
  OOpt String
i    -> String
i
  OFlag String
f Value
x -> String
f String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"=" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Value -> String
forall a. Show a => a -> String
show Value
x

mkOpt :: String -> Option
mkOpt :: String -> Option
mkOpt = String -> Option
OOpt

-- abbreviation convention from gf commands
getCommandOp :: ShowS
getCommandOp String
s = case (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
'_') String
s of
     (Char
a:String
_,Char
_:Char
b:String
_) -> [Char
a,Char
b]  -- axx_byy --> ab
     (String, String)
_ -> case String
s of
       [Char
a,Char
b] -> String
s          -- ab  --> ab
       Char
a:String
_ -> [Char
a]          -- axx --> a