import Data.Maybe( fromMaybe, isJust, fromJust )

import Data.List (find)

import Control.Monad

          (flags, [],      []) | enoughFlags flags -> do

                let m = flag flags isName

                let i = flag flags isInput

                let o = flag flags isOutput

                let a = fromMaybe o $ liftM extractString $ find isAlt flags

                hPutStrLn stdout $ "Main module: " ++ m

                hPutStrLn stdout $ "Input path : " ++ i

                hPutStrLn stdout $ "Output path: " ++ o

                hPutStrLn stdout $ "Altern path: " ++ a

                pas2C m (i++"/") (o++"/") (a++"/")

                hPutStrLn stdout $ "----------------------------"

                      | otherwise ->  error $ usageInfo header options

    where 

        header = "Freepascal to C conversion! Please specify -n -i -o options.\n"

        enoughFlags f = and $ map (isJust . flip find f) [isName, isInput, isOutput]

        flag f = extractString . fromJust . flip find f

extractString :: Flag -> String

extractString (Name s) = s

extractString (Input s) = s

extractString (Output s) = s

extractString (Alternate s) = s

extractString _ = undefined

isName, isInput, isOutput, isAlt :: Flag -> Bool

isName (Name _) = True

isName _ = False

isInput (Input _) = True

isInput _ = False

isOutput (Output _) = True

isOutput _ = False

isAlt (Alternate _) = True

isAlt _ = False