import Control.Monad

import Data.Char

    r <- runParserT (preprocessFile fn) (Map.empty, [True]) "" ""

    preprocessor, codeBlock, switch :: ParsecT String (Map.Map String String, [Bool]) IO String

    preprocessor = chainr codeBlock (return (++)) ""

    codeBlock = do

        s <- choice [

            , char '\'' >> many (noneOf "'\n") >>= \s -> char '\'' >> return ('\'' : s ++ "'")

            , identifier >>= replace

            , noneOf "{" >>= \a -> return [a]

        (_, ok) <- getState

        return $ if and ok then s else ""

    --otherChar c = c `notElem` "{/('_" && not (isAlphaNum c)

    identifier = do

        c <- letter <|> oneOf "_"

        s <- many (alphaNum <|> oneOf "_")

        return $ c:s

            , ifdef

            , elseSwitch

            , endIf

            , define

    ifdef = do

        s <- try (string "IFDEF") <|> try (string "IFNDEF")

        let f = if s == "IFNDEF" then not else id

        spaces

        d <- many1 alphaNum

        spaces

        char '}'

        updateState $ \(m, b) ->

            (m, (f $ d `Map.member` m) : b)

        return ""

    elseSwitch = do

        try $ string "ELSE}"

        updateState $ \(m, b:bs) -> (m, (not b):bs)

        return ""

    endIf = do

        try $ string "ENDIF}"

        updateState $ \(m, b:bs) -> (m, bs)

        return ""

    define = do

        try $ string "DEFINE"

        spaces

        i <- identifier        

        d <- option "" (string ":=" >> many (noneOf "}"))

        char '}'

        updateState $ \(m, b) -> (if and b then Map.insert i d m else m, b)

        return ""

    replace s = do

        (m, _) <- getState

        return $ Map.findWithDefault s s m

        return $ "{$" ++ fn ++ "}"