{- This module was generated from data in the Kate syntax
   highlighting file haskell.xml, version 4, by Nicolas Wu (zenzike@gmail.com) -}

module Text.Highlighting.Kate.Syntax.Haskell
          (highlight, parseExpression, syntaxName, syntaxExtensions)
where
import Text.Highlighting.Kate.Types
import Text.Highlighting.Kate.Common
import Text.ParserCombinators.Parsec hiding (State)
import Control.Monad.State
import Data.Char (isSpace)
import qualified Data.Set as Set

-- | Full name of language.
syntaxName :: String
syntaxName = "Haskell"

-- | Filename extensions for this language.
syntaxExtensions :: String
syntaxExtensions = "*.hs;*.chs"

-- | Highlight source code using this syntax definition.
highlight :: String -> [SourceLine]
highlight input = evalState (mapM parseSourceLine $ lines input) startingState

parseSourceLine :: String -> State SyntaxState SourceLine
parseSourceLine = mkParseSourceLine (parseExpression Nothing)

-- | Parse an expression using appropriate local context.
parseExpression :: Maybe (String,String)
                -> KateParser Token
parseExpression mbcontext = do
  (lang,cont) <- maybe currentContext return mbcontext
  result <- parseRules (lang,cont)
  optional $ do eof
                updateState $ \st -> st{ synStPrevChar = '\n' }
                pEndLine
  return result

startingState = SyntaxState {synStContexts = [("Haskell","code")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}

pEndLine = do
  updateState $ \st -> st{ synStPrevNonspace = False }
  context <- currentContext
  contexts <- synStContexts `fmap` getState
  st <- getState
  if length contexts >= 2
    then case context of
      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }
      ("Haskell","code") -> return ()
      ("Haskell","QuasiQuote") -> return ()
      ("Haskell","comment") -> (popContext) >> pEndLine
      ("Haskell","comments") -> return ()
      ("Haskell","char") -> (popContext) >> pEndLine
      ("Haskell","string") -> return ()
      ("Haskell","infix") -> return ()
      ("Haskell","import") -> (popContext) >> pEndLine
      ("Haskell","Haddock") -> return ()
      ("Haskell","Start Haddock Emphasis") -> (popContext) >> pEndLine
      ("Haskell","Haddock Emphasis") -> (popContext) >> pEndLine
      ("Haskell","Start Haddock Bold") -> (popContext) >> pEndLine
      ("Haskell","Haddock Bold") -> (popContext) >> pEndLine
      ("Haskell","C Preprocessor") -> (popContext) >> pEndLine
      ("Haskell","c2hs directive") -> return ()
      ("Haskell","c2hs import") -> return ()
      ("Haskell","c2hs pointer") -> return ()
      ("Haskell","c2hs fun") -> return ()
      ("Haskell","c2hs enum") -> return ()
      _ -> return ()
    else return ()

withAttribute attr txt = do
  when (null txt) $ fail "Parser matched no text"
  updateState $ \st -> st { synStPrevChar = last txt
                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }
  return (attr, txt)

list_keywords = Set.fromList $ words $ "case class data deriving do else if in infixl infixr instance let module newtype of primitive then type where"
list_prelude_function = Set.fromList $ words $ "FilePath IOError abs acos acosh all and any appendFile approxRational asTypeOf asin asinh atan atan2 atanh basicIORun break catch ceiling chr compare concat concatMap const cos cosh curry cycle decodeFloat denominator digitToInt div divMod drop dropWhile either elem encodeFloat enumFrom enumFromThen enumFromThenTo enumFromTo error even exp exponent fail filter flip floatDigits floatRadix floatRange floor fmap foldl foldl1 foldMap foldr foldr1 fromDouble fromEnum fromInt fromInteger fromIntegral fromRational fst gcd getChar getContents getLine group head id inRange index init intToDigit interact ioError isAlpha isAlphaNum isAscii isControl isDenormalized isDigit isHexDigit isIEEE isInfinite isLower isNaN isNegativeZero isOctDigit isPrint isSpace isUpper iterate last lcm length lex lexDigits lexLitChar lines log logBase lookup map mappend mapM mapM_ max maxBound maximum maybe mconcat mempty min minBound minimum mod negate not notElem null numerator odd or ord otherwise pack pi pred primExitWith print product properFraction pure putChar putStr putStrLn quot quotRem range rangeSize read readDec readFile readFloat readHex readIO readInt readList readLitChar readLn readOct readParen readSigned reads readsPrec realToFrac recip rem repeat replicate return reverse round scaleFloat scanl scanl1 scanr scanr1 seq sequence sequenceA sequence_ show showChar showInt showList showLitChar showParen showSigned showString shows showsPrec significand signum sin sinh snd sort span splitAt sqrt subtract succ sum tail take takeWhile tan tanh threadToIOResult toEnum toInt toInteger toLower toRational toUpper traverse truncate uncurry undefined unlines until unwords unzip unzip3 userError words writeFile zip zip3 zipWith zipWith3"
list_prelude_class = Set.fromList $ words $ "Applicative Bounded Enum Eq Floating Foldable Fractional Functor Integral Ix Monad Monoid Num Ord Read Real RealFloat RealFrac Show Traversable"
list_prelude_type = Set.fromList $ words $ "Bool ByteString Char Double Either FilePath Float Int Integer IO IOError Maybe Ordering Ratio Rational ReadS ShowS String Word"
list_prelude_data = Set.fromList $ words $ "False True Left Right Just Nothing EQ LT GT"
list_cpp'5fkeywords = Set.fromList $ words $ "defined if ifdef ifndef include undef"
list_c2hs'5fkeywords = Set.fromList $ words $ "qualified lib prefix as with call pure unsafe get set foreign stable nocode"
list_import'5fkeywords = Set.fromList $ words $ "as qualified hiding"

regex_'5c'7b'2d'23'2e'2a'23'2d'5c'7d = compileRegex True "\\{-#.*#-\\}"
regex_'5c'7b'2d'5b'5e'23'5d'3f = compileRegex True "\\{-[^#]?"
regex_'2d'2d'5b'5c'2d'5d'2a'28'5b'5e'21'23'5c'24'25'26'5c'2a'5c'2b'5c'2e'2f'3c'3d'3e'5c'3f'40'5c'5c'5e'5c'7c'5c'2d'7e'3a'5d'7c'24'29 = compileRegex True "--[\\-]*([^!#\\$%&\\*\\+\\./<=>\\?@\\\\^\\|\\-~:]|$)"
regex_import'5cs'2b = compileRegex True "import\\s+"
regex_'28'3a'3a'7c'3d'3e'7c'5c'2d'3e'7c'3c'5c'2d'29 = compileRegex True "(::|=>|\\->|<\\-)"
regex_'5cs'2a'5ba'2dz'5f'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5cs'2a'28'3f'3d'3a'3a'28'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'7c'24'29'29 = compileRegex True "\\s*[a-z_][a-zA-Z0-9_']*\\s*(?=::([^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]|$))"
regex_'5cs'2a'28'5c'28'5b'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2a'5c'29'29'2a'5cs'2a'28'3f'3d'3a'3a'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'29 = compileRegex True "\\s*(\\([\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]*\\))*\\s*(?=::[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:])"
regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5ba'2dz'5f'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a = compileRegex True "([A-Z][a-zA-Z0-9_']*\\.)*[a-z_][a-zA-Z0-9_']*"
regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d0'5f'27'5d'2a'5c'2e'29'2a'5b'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2b = compileRegex True "([A-Z][a-zA-Z0-0_']*\\.)*[\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]+"
regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a = compileRegex True "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*"
regex_'5cd'2b'5c'2e'5cd'2b'28'5bEe'5d'5b'2b'2d'5d'3f'5cd'2b'29'3f'7c'5cd'2b'5bEe'5d'5b'2b'2d'5d'3f'5cd'2b = compileRegex True "\\d+\\.\\d+([Ee][+-]?\\d+)?|\\d+[Ee][+-]?\\d+"
regex_0'5bOo'5d'5b0'2d7'5d'2b = compileRegex True "0[Oo][0-7]+"
regex_0'5bXx'5d'5b0'2d9A'2dFa'2df'5d'2b = compileRegex True "0[Xx][0-9A-Fa-f]+"
regex_'5c'5b'5ba'2dzA'2dZ'5f'27'5d'28'5cw'7c'5b'5f'27'5d'29'2a'5c'7c = compileRegex True "\\[[a-zA-Z_'](\\w|[_'])*\\|"
regex_'5c'5c'2e = compileRegex True "\\\\."
regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5ba'2dz'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a = compileRegex True "([A-Z][a-zA-Z0-9_']*\\.)*[a-z][a-zA-Z0-9_']*"
regex_'2d'2d'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2e'2a'24 = compileRegex True "--[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:].*$"
regex_'27'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5ba'2dz'5f'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'27 = compileRegex True "'([A-Z][a-zA-Z0-9_']*\\.)*[a-z_][a-zA-Z0-9_']*'"
regex_'22'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'22 = compileRegex True "\"([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*\""
regex_'2f'2e'2a'2f = compileRegex True "/.*/"
regex_'5f'5f'2e'2a'5f'5f = compileRegex True "__.*__"
regex_'2e'2a'3e'24 = compileRegex True ".*>$"
regex_context = compileRegex True "context"
regex_call = compileRegex True "call"
regex_sizeof = compileRegex True "sizeof"
regex_alignof = compileRegex True "alignof"
regex_fun = compileRegex True "fun"
regex_pointer = compileRegex True "pointer"
regex_enum = compileRegex True "enum"
regex_import = compileRegex True "import"
regex_newtype = compileRegex True "newtype"
regex_'60'5b'5e'27'5d'2a'27 = compileRegex True "`[^']*'"

parseRules ("Haskell","code") =
  (((pRegExpr regex_'5c'7b'2d'23'2e'2a'23'2d'5c'7d >>= withAttribute OtherTok))
   <|>
   ((pString False "{--}" >>= withAttribute CommentTok))
   <|>
   ((pRegExpr regex_'5c'7b'2d'5b'5e'23'5d'3f >>= withAttribute CommentTok) >>~ pushContext ("Haskell","comments"))
   <|>
   ((pRegExpr regex_'2d'2d'5b'5c'2d'5d'2a'28'5b'5e'21'23'5c'24'25'26'5c'2a'5c'2b'5c'2e'2f'3c'3d'3e'5c'3f'40'5c'5c'5e'5c'7c'5c'2d'7e'3a'5d'7c'24'29 >>= withAttribute CommentTok) >>~ pushContext ("Haskell","comment"))
   <|>
   ((pRegExpr regex_import'5cs'2b >>= withAttribute KeywordTok) >>~ pushContext ("Haskell","import"))
   <|>
   ((pDetect2Chars False '{' '#' >>= withAttribute StringTok) >>~ pushContext ("Haskell","c2hs directive"))
   <|>
   ((pColumn 0 >> pDetectChar False '#' >>= withAttribute OtherTok) >>~ pushContext ("Haskell","C Preprocessor"))
   <|>
   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok))
   <|>
   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_prelude_function >>= withAttribute NormalTok))
   <|>
   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_prelude_type >>= withAttribute DataTypeTok))
   <|>
   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_prelude_data >>= withAttribute DataTypeTok))
   <|>
   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_prelude_class >>= withAttribute DataTypeTok))
   <|>
   ((pRegExpr regex_'28'3a'3a'7c'3d'3e'7c'5c'2d'3e'7c'3c'5c'2d'29 >>= withAttribute OtherTok))
   <|>
   ((pAnyChar "\8759\8658\8594\8592\8704\8707" >>= withAttribute OtherTok))
   <|>
   ((pRegExpr regex_'5cs'2a'5ba'2dz'5f'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5cs'2a'28'3f'3d'3a'3a'28'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'7c'24'29'29 >>= withAttribute OtherTok))
   <|>
   ((pRegExpr regex_'5cs'2a'28'5c'28'5b'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2a'5c'29'29'2a'5cs'2a'28'3f'3d'3a'3a'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'29 >>= withAttribute OtherTok))
   <|>
   ((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5ba'2dz'5f'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a >>= withAttribute NormalTok))
   <|>
   ((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d0'5f'27'5d'2a'5c'2e'29'2a'5b'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2b >>= withAttribute FunctionTok))
   <|>
   ((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a >>= withAttribute DataTypeTok))
   <|>
   ((pRegExpr regex_'5cd'2b'5c'2e'5cd'2b'28'5bEe'5d'5b'2b'2d'5d'3f'5cd'2b'29'3f'7c'5cd'2b'5bEe'5d'5b'2b'2d'5d'3f'5cd'2b >>= withAttribute FloatTok))
   <|>
   ((pRegExpr regex_0'5bOo'5d'5b0'2d7'5d'2b >>= withAttribute BaseNTok))
   <|>
   ((pRegExpr regex_0'5bXx'5d'5b0'2d9A'2dFa'2df'5d'2b >>= withAttribute BaseNTok))
   <|>
   ((pInt >>= withAttribute DecValTok))
   <|>
   ((pDetectChar False '\'' >>= withAttribute CharTok) >>~ pushContext ("Haskell","char"))
   <|>
   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext ("Haskell","string"))
   <|>
   ((pDetectChar False '`' >>= withAttribute OtherTok) >>~ pushContext ("Haskell","infix"))
   <|>
   ((pDetect2Chars False '.' '.' >>= withAttribute OtherTok))
   <|>
   ((pAnyChar "\8229" >>= withAttribute OtherTok))
   <|>
   ((pRegExpr regex_'5c'5b'5ba'2dzA'2dZ'5f'27'5d'28'5cw'7c'5b'5f'27'5d'29'2a'5c'7c >>= withAttribute NormalTok) >>~ pushContext ("Haskell","QuasiQuote"))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","code")) >> pDefault >>= withAttribute NormalTok))

parseRules ("Haskell","QuasiQuote") =
  (((pDetect2Chars False '|' ']' >>= withAttribute NormalTok) >>~ (popContext))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","QuasiQuote")) >> pDefault >>= withAttribute NormalTok))

parseRules ("Haskell","comment") =
  (((parseRules ("Haskell","Haddock")))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","comment")) >> pDefault >>= withAttribute CommentTok))

parseRules ("Haskell","comments") =
  (((pDetect2Chars False '{' '-' >>= withAttribute CommentTok) >>~ pushContext ("Haskell","comment"))
   <|>
   ((pDetect2Chars False '-' '}' >>= withAttribute CommentTok) >>~ (popContext))
   <|>
   ((parseRules ("Haskell","Haddock")))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","comments")) >> pDefault >>= withAttribute CommentTok))

parseRules ("Haskell","char") =
  (((pRegExpr regex_'5c'5c'2e >>= withAttribute CharTok))
   <|>
   ((pDetectChar False '\'' >>= withAttribute CharTok) >>~ (popContext))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","char")) >> pDefault >>= withAttribute CharTok))

parseRules ("Haskell","string") =
  (((pRegExpr regex_'5c'5c'2e >>= withAttribute StringTok))
   <|>
   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","string")) >> pDefault >>= withAttribute StringTok))

parseRules ("Haskell","infix") =
  (((pDetectChar False '`' >>= withAttribute OtherTok) >>~ (popContext))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","infix")) >> pDefault >>= withAttribute OtherTok))

parseRules ("Haskell","import") =
  (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_import'5fkeywords >>= withAttribute KeywordTok))
   <|>
   ((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5ba'2dz'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a >>= withAttribute NormalTok))
   <|>
   ((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a >>= withAttribute DataTypeTok))
   <|>
   ((pRegExpr regex_'5c'7b'2d'23'2e'2a'23'2d'5c'7d >>= withAttribute OtherTok))
   <|>
   ((pRegExpr regex_'5c'7b'2d'5b'5e'23'5d'3f >>= withAttribute CommentTok) >>~ pushContext ("Haskell","comments"))
   <|>
   ((pRegExpr regex_'2d'2d'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2e'2a'24 >>= withAttribute CommentTok) >>~ pushContext ("Haskell","comment"))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","import")) >> pDefault >>= withAttribute NormalTok))

parseRules ("Haskell","Haddock") =
  (((pRegExpr regex_'27'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5ba'2dz'5f'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'27 >>= withAttribute CommentTok))
   <|>
   ((pRegExpr regex_'22'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'22 >>= withAttribute CommentTok))
   <|>
   ((lookAhead (pRegExpr regex_'2f'2e'2a'2f) >> pushContext ("Haskell","Start Haddock Emphasis") >> currentContext >>= parseRules))
   <|>
   ((lookAhead (pRegExpr regex_'5f'5f'2e'2a'5f'5f) >> pushContext ("Haskell","Start Haddock Bold") >> currentContext >>= parseRules))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","Haddock")) >> pDefault >>= withAttribute CommentTok))

parseRules ("Haskell","Start Haddock Emphasis") =
  (((pDetectChar False '/' >>= withAttribute CommentTok) >>~ pushContext ("Haskell","Haddock Emphasis"))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","Start Haddock Emphasis")) >> pDefault >>= withAttribute CommentTok))

parseRules ("Haskell","Haddock Emphasis") =
  (((pDetectChar False '/' >>= withAttribute CommentTok) >>~ (popContext >> popContext))
   <|>
   ((parseRules ("Haskell","Haddock")))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","Haddock Emphasis")) >> pDefault >>= withAttribute CommentTok))

parseRules ("Haskell","Start Haddock Bold") =
  (((pDetect2Chars False '_' '_' >>= withAttribute CommentTok) >>~ pushContext ("Haskell","Haddock Bold"))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","Start Haddock Bold")) >> pDefault >>= withAttribute CommentTok))

parseRules ("Haskell","Haddock Bold") =
  (((pDetect2Chars False '_' '_' >>= withAttribute CommentTok) >>~ (popContext >> popContext))
   <|>
   ((parseRules ("Haskell","Haddock")))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","Haddock Bold")) >> pDefault >>= withAttribute CommentTok))

parseRules ("Haskell","C Preprocessor") =
  (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_cpp'5fkeywords >>= withAttribute OtherTok))
   <|>
   ((pRegExpr regex_'2e'2a'3e'24 >>= withAttribute OtherTok))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","C Preprocessor")) >> pDefault >>= withAttribute OtherTok))

parseRules ("Haskell","c2hs directive") =
  (((pDetect2Chars False '#' '}' >>= withAttribute StringTok) >>~ (popContext))
   <|>
   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_c2hs'5fkeywords >>= withAttribute KeywordTok))
   <|>
   ((pRegExpr regex_context >>= withAttribute KeywordTok))
   <|>
   ((pRegExpr regex_call >>= withAttribute KeywordTok))
   <|>
   ((pRegExpr regex_sizeof >>= withAttribute KeywordTok))
   <|>
   ((pRegExpr regex_alignof >>= withAttribute KeywordTok))
   <|>
   ((pRegExpr regex_fun >>= withAttribute KeywordTok) >>~ pushContext ("Haskell","c2hs fun"))
   <|>
   ((pRegExpr regex_pointer >>= withAttribute KeywordTok) >>~ pushContext ("Haskell","c2hs pointer"))
   <|>
   ((pRegExpr regex_enum >>= withAttribute KeywordTok) >>~ pushContext ("Haskell","c2hs enum"))
   <|>
   ((pRegExpr regex_import >>= withAttribute KeywordTok) >>~ pushContext ("Haskell","c2hs import"))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","c2hs directive")) >> pDefault >>= withAttribute StringTok))

parseRules ("Haskell","c2hs import") =
  (((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a >>= withAttribute DataTypeTok))
   <|>
   ((pDetect2Chars False '#' '}' >>= withAttribute StringTok) >>~ (popContext >> popContext))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","c2hs import")) >> pDefault >>= withAttribute StringTok))

parseRules ("Haskell","c2hs pointer") =
  (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_c2hs'5fkeywords >>= withAttribute KeywordTok))
   <|>
   ((pRegExpr regex_newtype >>= withAttribute KeywordTok))
   <|>
   ((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a >>= withAttribute DataTypeTok))
   <|>
   ((pDetect2Chars False '#' '}' >>= withAttribute StringTok) >>~ (popContext >> popContext))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","c2hs pointer")) >> pDefault >>= withAttribute StringTok))

parseRules ("Haskell","c2hs fun") =
  (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_c2hs'5fkeywords >>= withAttribute KeywordTok))
   <|>
   ((pRegExpr regex_'60'5b'5e'27'5d'2a'27 >>= withAttribute DataTypeTok))
   <|>
   ((pDetect2Chars False '#' '}' >>= withAttribute StringTok) >>~ (popContext >> popContext))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","c2hs fun")) >> pDefault >>= withAttribute StringTok))

parseRules ("Haskell","c2hs enum") =
  (((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a >>= withAttribute DataTypeTok))
   <|>
   ((pDetect2Chars False '#' '}' >>= withAttribute StringTok) >>~ (popContext >> popContext))
   <|>
   (currentContext >>= \x -> guard (x == ("Haskell","c2hs enum")) >> pDefault >>= withAttribute StringTok))


parseRules x = parseRules ("Haskell","code") <|> fail ("Unknown context" ++ show x)
