module Parse
( identifier
) where

import           Control.Monad
import qualified Data.Map as Map
import           Text.ParserCombinators.Parsec
import           Data.Either
import           Data.Maybe

data Token = TokIdentifier String
           | TokAlignAs
           | TokAlignOf
           | TokAsm
           | TokAuto
           | TokBool
           | TokBreak
           | TokCase
           | TokCatch
           | TokChar
           | TokChar16T
           | TokChar32T
           | TokClass
           | TokCompl
           | TokConst
           | TokConstExpr
           | TokConstCast
           | TokContinue
           | TokDeclType
           | TokDefault
           | TokDelete
           | TokDo
           | TokDouble
           | TokDynamicCast
           | TokElse
           | TokEnum
           | TokExplicit
           | TokExport
           | TokExtern
           | TokFalse
           | TokFinal
           | TokFloat
           | TokFor
           | TokFriend
           | TokGoTo
           | TokIf
           | TokInline
           | TokInt
           | TokLong
           | TokMutable
           | TokNamespace
           | TokNew
           | TokNoExcept
           | TokNullPtr
           | TokOperator
           | TokOverride
           | TokPrivate
           | TokProtected
           | TokPublic
           | TokRegister
           | TokReinterpretCast
           | TokReturn
           | TokShort
           | TokSigned
           | TokSizeOf
           | TokStatic
           | TokStaticAssert
           | TokStaticCast
           | TokStruct
           | TokSwitch
           | TokTemplate
           | TokThis
           | TokThreadLocal
           | TokThrow
           | TokTrue
           | TokTry
           | TokTypeDef
           | TokTypeID
           | TokTypeName
           | TokUnion
           | TokUnsigned
           | TokUsing
           | TokVirtual
           | TokVoid
           | TokVolatile
           | TokWCharT
           | TokWhile

           | TokAnd
           | TokOr

           | TokXor
           | TokBitAnd
           | TokBitOr
           | TokAndEq
           | TokOrEq
           | TokXorEq

           | TokAddEq
           | TokSubtractEq
           | TokMultiplyEq
           | TokDivideEq
           | TokModuloEq

           | TokPound
           | TokPoundPound

           | TokLShiftEq
           | TokRShiftEq

           | TokVariadic

           | TokDerefMemberPointer

           | TokLBracket
           | TokRBracket
           | TokLBrace
           | TokRBrace
           | TokLParen
           | TokRParen

           | TokColonColon
           | TokMemberPointer
           | TokLShift
           | TokRShift
           | TokEqEq
           | TokNot
           | TokNotEq
           | TokLTEq
           | TokGTEq
           | TokIncrement
           | TokDecrement

           | TokSemicolon
           | TokColon
           | TokMember
           | TokAdd
           | TokSubtract
           | TokMultiply
           | TokDivide
           | TokModulo
           | TokCaret
           | TokBitNegate
           | TokEq
           | TokLT
           | TokComma

           | TokGT

           deriving (Eq, Ord, Show)

identifier :: Bool -> Bool -> Parser Token
identifier expectOverride expectFinal = do
    c <- letter <|> char '_'
    cs <- many (letter <|> digit <|> char '_')
    return $ case (c:cs) of
        "alignas" -> TokAlignAs
        "alignof" -> TokAlignOf
        "and" -> TokAnd
        "and_eq" -> TokAndEq
        "asm" -> TokAsm
        "auto" -> TokAuto
        "bitand" -> TokBitAnd
        "bitor" -> TokBitOr
        "bool" -> TokBool
        "break" -> TokBreak
        "case" -> TokCase
        "catch" -> TokCatch
        "char" -> TokChar
        "char16_t" -> TokChar16T
        "class" -> TokClass
        "compl" -> TokCompl
        "const" -> TokConst
        "constexpr" -> TokConstExpr
        "const_cast" -> TokConstCast
        "continue" -> TokContinue
        "decltype" -> TokDeclType
        "default" -> TokDefault
        "delete" -> TokDelete
        "do" -> TokDo
        "double" -> TokDouble
        "dynamic_cast" -> TokDynamicCast
        "else" -> TokElse
        "enum" -> TokEnum
        "explicit" -> TokExplicit
        "export" -> TokExport
        "false" -> TokFalse
        "final" -> if expectFinal then TokFinal else TokIdentifier "final"
        "float" -> TokFloat
        "for" -> TokFor
        "friend" -> TokFriend
        "goto" -> TokGoTo
        "if" -> TokIf
        "inline" -> TokInline
        "int" -> TokInt
        "long" -> TokLong
        "mutable" -> TokMutable
        "namespace" -> TokNamespace
        "new" -> TokNew
        "noexcept" -> TokNoExcept
        "not" -> TokNot
        "not_eq" -> TokNotEq
        "nullptr" -> TokNullPtr
        "operator" -> TokOperator
        "override" -> if expectOverride then TokOverride else TokIdentifier "override"
        "private" -> TokPrivate
        "protected" -> TokProtected
        "public" -> TokPublic
        "register" -> TokRegister
        "reinterpret_cast" -> TokReinterpretCast
        "return" -> TokReturn
        "short" -> TokShort
        "signed" -> TokSigned
        "sizeof" -> TokSizeOf
        "static" -> TokStatic
        "static_assert" -> TokStaticAssert
        "static_cast" -> TokStaticCast
        "struct" -> TokStruct
        "switch" -> TokSwitch
        "template" -> TokTemplate
        "this" -> TokThis
        "thread_local" -> TokThreadLocal
        "throw" -> TokThrow
        "true" -> TokTrue
        "try" -> TokTry
        "typedef" -> TokTypeDef
        "typeid" -> TokTypeID
        "typename" -> TokTypeName
        "union" -> TokUnion
        "unsigned" -> TokUnsigned
        "using" -> TokUsing
        "virtual" -> TokVirtual
        "void" -> TokVoid
        "volatile" -> TokVolatile
        "wchar_t" -> TokWCharT
        "while" -> TokWhile
        "xor" -> TokXor
        "xor_eq" -> TokXorEq
        s -> TokIdentifier s
    <?> "identifier"

punctuation :: Bool -> Parser Token
punctuation expectDoubleGT =
    try (string "%:%:" >> return TokPoundPound) <|>
    try (string "..." >> return TokVariadic) <|>
    try (string "<<=" >> return TokLShiftEq) <|>
    try (string ">>=" >> return TokRShiftEq) <|>
    try (string "->*" >> return TokDerefMemberPointer) <|>
    try (string "##" >> return TokPoundPound) <|>
    try (string "<:" >> return TokLBracket) <|>
    try (string ":>" >> return TokRBracket) <|>
    try (string "<%" >> return TokLBrace) <|>
    try (string "%>" >> return TokRBrace) <|>
    try (string "%:" >> return TokPound) <|>
    try (string "::" >> return TokColonColon) <|>
    try (string ".*" >> return TokMemberPointer) <|>
    try (string "+=" >> return TokAddEq) <|>
    try (string "-=" >> return TokSubtractEq) <|>
    try (string "*=" >> return TokMultiplyEq) <|>
    try (string "/=" >> return TokDivideEq) <|>
    try (string "%=" >> return TokModuloEq) <|>
    try (string "^=" >> return TokXorEq) <|>
    try (string "&=" >> return TokAndEq) <|>
    try (string "|=" >> return TokOrEq) <|>
    try (string "<<" >> return TokLShift) <|>
    try (string "==" >> return TokEqEq) <|>
    try (string "!=" >> return TokNotEq) <|>
    try (string "<=" >> return TokLTEq) <|>
    try (string ">=" >> return TokGTEq) <|>
    try (string "&&" >> return TokAnd) <|>
    try (string "||" >> return TokOr) <|>
    try (string "++" >> return TokIncrement) <|>
    try (string "--" >> return TokDecrement) <|>

    (char '{' >> return TokLBrace) <|>
    (char '}' >> return TokRBrace) <|>
    (char '[' >> return TokLBracket) <|>
    (char ']' >> return TokRBracket) <|>
    (char '#' >> return TokPound) <|>
    (char '(' >> return TokLParen) <|>
    (char ')' >> return TokRParen) <|>
    (char ';' >> return TokSemicolon) <|>
    (char ':' >> return TokColon) <|>
    (char '.' >> return TokMember) <|>
    (char '+' >> return TokAdd) <|>
    (char '-' >> return TokSubtract) <|>
    (char '*' >> return TokMultiply) <|>
    (char '/' >> return TokDivide) <|>
    (char '%' >> return TokModulo) <|>
    (char '^' >> return TokCaret) <|>
    (char '&' >> return TokBitAnd) <|>
    (char '|' >> return TokBitOr) <|>
    (char '~' >> return TokBitNegate) <|>
    (char '!' >> return TokNot) <|>
    (char '=' >> return TokEq) <|>
    (char '<' >> return TokLT) <|>
    (char '>' >> if expectDoubleGT then return TokGT else ((char '>' >> return TokRShift) <|> return TokGT)) <|>
    (char ',' >> return TokComma)