{- This module was generated from data in the Kate syntax
   highlighting file fsharp.xml, version 2, by Bas Bossink (bas.bossink@gmail.com) -}

module Text.Highlighting.Kate.Syntax.Fsharp
          (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 :: [Char]
syntaxName = [Char]
"FSharp"

-- | Filename extensions for this language.
syntaxExtensions :: String
syntaxExtensions :: [Char]
syntaxExtensions = [Char]
"*.fs;*.fsi;*.fsx"

-- | Highlight source code using this syntax definition.
highlight :: String -> [SourceLine]
highlight :: [Char] -> [SourceLine]
highlight [Char]
input = State SyntaxState [SourceLine] -> SyntaxState -> [SourceLine]
forall s a. State s a -> s -> a
evalState (([Char] -> StateT SyntaxState Identity SourceLine)
-> [[Char]] -> State SyntaxState [SourceLine]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM [Char] -> StateT SyntaxState Identity SourceLine
parseSourceLine ([[Char]] -> State SyntaxState [SourceLine])
-> [[Char]] -> State SyntaxState [SourceLine]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
lines [Char]
input) SyntaxState
startingState

parseSourceLine :: String -> State SyntaxState SourceLine
parseSourceLine :: [Char] -> StateT SyntaxState Identity SourceLine
parseSourceLine = KateParser Token
-> [Char] -> StateT SyntaxState Identity SourceLine
mkParseSourceLine (Maybe ([Char], [Char]) -> KateParser Token
parseExpression Maybe ([Char], [Char])
forall a. Maybe a
Nothing)

-- | Parse an expression using appropriate local context.
parseExpression :: Maybe (String,String)
                -> KateParser Token
parseExpression :: Maybe ([Char], [Char]) -> KateParser Token
parseExpression Maybe ([Char], [Char])
mbcontext = do
  ([Char]
lang,[Char]
cont) <- KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser ([Char], [Char]))
-> Maybe ([Char], [Char])
-> KateParser ([Char], [Char])
forall b a. b -> (a -> b) -> Maybe a -> b
maybe KateParser ([Char], [Char])
currentContext ([Char], [Char]) -> KateParser ([Char], [Char])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ([Char], [Char])
mbcontext
  Token
result <- ([Char], [Char]) -> KateParser Token
parseRules ([Char]
lang,[Char]
cont)
  ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (ParsecT [Char] SyntaxState Identity ()
 -> ParsecT [Char] SyntaxState Identity ())
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall a b. (a -> b) -> a -> b
$ do ParsecT [Char] SyntaxState Identity ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof
                (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState ((SyntaxState -> SyntaxState)
 -> ParsecT [Char] SyntaxState Identity ())
-> (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStPrevChar :: Char
synStPrevChar = Char
'\n' }
                ParsecT [Char] SyntaxState Identity ()
pEndLine
  Token -> KateParser Token
forall (m :: * -> *) a. Monad m => a -> m a
return Token
result

startingState :: SyntaxState
startingState = SyntaxState :: ContextStack
-> Int
-> Char
-> Bool
-> Bool
-> Bool
-> Bool
-> [[Char]]
-> SyntaxState
SyntaxState {synStContexts :: ContextStack
synStContexts = [([Char]
"FSharp",[Char]
"Normal")], synStLineNumber :: Int
synStLineNumber = Int
0, synStPrevChar :: Char
synStPrevChar = Char
'\n', synStPrevNonspace :: Bool
synStPrevNonspace = Bool
False, synStContinuation :: Bool
synStContinuation = Bool
False, synStCaseSensitive :: Bool
synStCaseSensitive = Bool
True, synStKeywordCaseSensitive :: Bool
synStKeywordCaseSensitive = Bool
True, synStCaptures :: [[Char]]
synStCaptures = []}

pEndLine :: ParsecT [Char] SyntaxState Identity ()
pEndLine = do
  (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState ((SyntaxState -> SyntaxState)
 -> ParsecT [Char] SyntaxState Identity ())
-> (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStPrevNonspace :: Bool
synStPrevNonspace = Bool
False }
  ([Char], [Char])
context <- KateParser ([Char], [Char])
currentContext
  ContextStack
contexts <- SyntaxState -> ContextStack
synStContexts (SyntaxState -> ContextStack)
-> ParsecT [Char] SyntaxState Identity SyntaxState
-> ParsecT [Char] SyntaxState Identity ContextStack
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` ParsecT [Char] SyntaxState Identity SyntaxState
forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
  SyntaxState
st <- ParsecT [Char] SyntaxState Identity SyntaxState
forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
  if ContextStack -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ContextStack
contexts Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
2
    then case ([Char], [Char])
context of
      ([Char], [Char])
_ | SyntaxState -> Bool
synStContinuation SyntaxState
st -> (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState ((SyntaxState -> SyntaxState)
 -> ParsecT [Char] SyntaxState Identity ())
-> (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStContinuation :: Bool
synStContinuation = Bool
False }
      ([Char]
"FSharp",[Char]
"Normal") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"FSharp",[Char]
"Singleline Comment") -> (ParsecT [Char] SyntaxState Identity ()
popContext) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"FSharp",[Char]
"Multiline Comment") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"FSharp",[Char]
"String Constant") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"FSharp",[Char]
"Block") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"FSharp",[Char]
"Sig") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"FSharp",[Char]
"Struct") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"FSharp",[Char]
"Object") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"FSharp",[Char]
"ModuleEnv") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"FSharp",[Char]
"ModuleEnv2") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"FSharp",[Char]
"Camlp4 Quotation Constant") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char], [Char])
_ -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    else () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

withAttribute :: a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute a
attr [Char]
txt = do
  Bool -> ParsecT s SyntaxState m () -> ParsecT s SyntaxState m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ([Char] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
txt) (ParsecT s SyntaxState m () -> ParsecT s SyntaxState m ())
-> ParsecT s SyntaxState m () -> ParsecT s SyntaxState m ()
forall a b. (a -> b) -> a -> b
$ [Char] -> ParsecT s SyntaxState m ()
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Parser matched no text"
  (SyntaxState -> SyntaxState) -> ParsecT s SyntaxState m ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState ((SyntaxState -> SyntaxState) -> ParsecT s SyntaxState m ())
-> (SyntaxState -> SyntaxState) -> ParsecT s SyntaxState m ()
forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st { synStPrevChar :: Char
synStPrevChar = [Char] -> Char
forall a. [a] -> a
last [Char]
txt
                          , synStPrevNonspace :: Bool
synStPrevNonspace = SyntaxState -> Bool
synStPrevNonspace SyntaxState
st Bool -> Bool -> Bool
|| Bool -> Bool
not ((Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isSpace [Char]
txt) }
  (a, [Char]) -> ParsecT s SyntaxState m (a, [Char])
forall (m :: * -> *) a. Monad m => a -> m a
return (a
attr, [Char]
txt)

list_keywords :: Set [Char]
list_keywords = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"abstract and as assert base class delegate dowcast downto elif else exception extern false for fun function functor global if in inherit inline interfaece internal lazy let match member mutable namespace new not null of or override private public rec ref return static then to true try type upcast use val void when while with yield"
list_core_types :: Set [Char]
list_core_types = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"bool byte sbyte int16 uint16 int uint32 int64 uint64 nativeint unativeint char string decimal unit void float32 single float double bigint option seq"
list_symbols :: Set [Char]
list_symbols = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"?"
list_end :: Set [Char]
list_end = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"end"
list_sig :: Set [Char]
list_sig = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"sig"
list_struct :: Set [Char]
list_struct = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"struct"
list_object :: Set [Char]
list_object = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"object"
list_begin :: Set [Char]
list_begin = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"begin"
list_do :: Set [Char]
list_do = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"do"
list_done :: Set [Char]
list_done = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"done"
list_module'5fenvironment :: Set [Char]
list_module'5fenvironment = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
"module open"

regex_'60'5cs'2a'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a :: Regex
regex_'60'5cs'2a'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"`\\s*[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*"
regex_'5bA'2dZ'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'5cs'2a'5c'2e :: Regex
regex_'5bA'2dZ'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'5cs'2a'5c'2e = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*\\s*\\."
regex_'5bA'2dZ'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a :: Regex
regex_'5bA'2dZ'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*"
regex_'23'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'2e'2a'24 :: Regex
regex_'23'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'2e'2a'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"#[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*.*$"
regex_'27'28'28'5c'5c'5bntbr'27'22'5c'5c'5d'7c'5c'5c'5b0'2d9'5d'7b3'7d'7c'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b2'7d'29'7c'5b'5e'27'5d'29'27 :: Regex
regex_'27'28'28'5c'5c'5bntbr'27'22'5c'5c'5d'7c'5c'5c'5b0'2d9'5d'7b3'7d'7c'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b2'7d'29'7c'5b'5e'27'5d'29'27 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"'((\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})|[^'])'"
regex_'3c'3a'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'3c :: Regex
regex_'3c'3a'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'3c = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<:[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*<"
regex_'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a :: Regex
regex_'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*"
regex_'2d'3f0'5bxX'5d'5b0'2d9A'2dFa'2df'5f'5d'2b :: Regex
regex_'2d'3f0'5bxX'5d'5b0'2d9A'2dFa'2df'5f'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"-?0[xX][0-9A-Fa-f_]+"
regex_'2d'3f0'5boO'5d'5b0'2d7'5f'5d'2b :: Regex
regex_'2d'3f0'5boO'5d'5b0'2d7'5f'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"-?0[oO][0-7_]+"
regex_'2d'3f0'5bbB'5d'5b01'5f'5d'2b :: Regex
regex_'2d'3f0'5bbB'5d'5b01'5f'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"-?0[bB][01_]+"
regex_'2d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'28'28'5c'2e'28'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'3f'28'5beE'5d'5b'2d'2b'5d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'3f'29'7c'28'5beE'5d'5b'2d'2b'5d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'29 :: Regex
regex_'2d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'28'28'5c'2e'28'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'3f'28'5beE'5d'5b'2d'2b'5d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'3f'29'7c'28'5beE'5d'5b'2d'2b'5d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"-?[0-9][0-9_]*((\\.([0-9][0-9_]*)?([eE][-+]?[0-9][0-9_]*)?)|([eE][-+]?[0-9][0-9_]*))"
regex_'2d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a :: Regex
regex_'2d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"-?[0-9][0-9_]*"
regex_'28'5c'5c'5bntbr'27'22'5c'5c'5d'7c'5c'5c'5b0'2d9'5d'7b3'7d'7c'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b2'7d'29 :: Regex
regex_'28'5c'5c'5bntbr'27'22'5c'5c'5d'7c'5c'5c'5b0'2d9'5d'7b3'7d'7c'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b2'7d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})"
regex_'5c'5c'24 :: Regex
regex_'5c'5c'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\\\$"
regex_'5c'5c'28'5c'5c'7c'3e'3e'7c'3c'3c'29 :: Regex
regex_'5c'5c'28'5c'5c'7c'3e'3e'7c'3c'3c'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\\\(\\\\|>>|<<)"
regex_'5c'5c'3c'3a'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'3c :: Regex
regex_'5c'5c'3c'3a'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'3c = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\\\<:[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*<"

parseRules :: ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"FSharp",[Char]
"Normal") =
  (((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'(' Char
'*' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Multiline Comment"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'/' Char
'/' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Singleline Comment"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'(' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
')' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'{' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'}' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'[' Char
'<' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'>' Char
']' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'[' Char
'|' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'|' Char
']' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'[' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
']' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_do KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_done KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_module'5fenvironment KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"ModuleEnv"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_begin KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Block"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_object KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Object"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_sig KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Sig"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_struct KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Struct"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'60'5cs'2a'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char] -> KateParser [Char]
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Regex -> KateParser [Char]
pRegExpr Regex
regex_'5bA'2dZ'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'5cs'2a'5c'2e) KateParser [Char]
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"ModuleEnv2") ParsecT [Char] SyntaxState Identity ()
-> KateParser ([Char], [Char]) -> KateParser ([Char], [Char])
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5bA'2dZ'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
pFirstNonSpace ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'2e'2a'24 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'"' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"String Constant"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'27'28'28'5c'5c'5bntbr'27'22'5c'5c'5d'7c'5c'5c'5b0'2d9'5d'7b3'7d'7c'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b2'7d'29'7c'5b'5e'27'5d'29'27 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CharTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'<' Char
'<' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Camlp4 Quotation Constant"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'3c'3a'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'3c KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Camlp4 Quotation Constant"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_keywords KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_core_types KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'2d'3f0'5bxX'5d'5b0'2d9A'2dFa'2df'5f'5d'2b KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
BaseNTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'2d'3f0'5boO'5d'5b0'2d7'5f'5d'2b KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
BaseNTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'2d'3f0'5bbB'5d'5b01'5f'5d'2b KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
BaseNTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'2d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'28'28'5c'2e'28'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'3f'28'5beE'5d'5b'2d'2b'5d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'3f'29'7c'28'5beE'5d'5b'2d'2b'5d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'29 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FloatTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'2d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"FSharp",[Char]
"Normal")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"FSharp",[Char]
"Singleline Comment") =
  (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"FSharp",[Char]
"Singleline Comment")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok)

parseRules ([Char]
"FSharp",[Char]
"Multiline Comment") =
  (((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'*' Char
')' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'(' Char
'*' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Multiline Comment"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"FSharp",[Char]
"Multiline Comment")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok))

parseRules ([Char]
"FSharp",[Char]
"String Constant") =
  (((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'"' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'28'5c'5c'5bntbr'27'22'5c'5c'5d'7c'5c'5c'5b0'2d9'5d'7b3'7d'7c'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b2'7d'29 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialCharTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'5c'24 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialCharTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"FSharp",[Char]
"String Constant")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))

parseRules ([Char]
"FSharp",[Char]
"Block") =
  ((([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_end KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"FSharp",[Char]
"Normal")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"FSharp",[Char]
"Block")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"FSharp",[Char]
"Sig") =
  ((([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_end KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"FSharp",[Char]
"Normal")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"FSharp",[Char]
"Sig")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"FSharp",[Char]
"Struct") =
  ((([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_end KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"FSharp",[Char]
"Normal")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"FSharp",[Char]
"Struct")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"FSharp",[Char]
"Object") =
  ((([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_end KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"FSharp",[Char]
"Normal")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"FSharp",[Char]
"Object")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"FSharp",[Char]
"ModuleEnv") =
  (((KateParser [Char]
pDetectSpaces KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char] -> KateParser [Char]
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Regex -> KateParser [Char]
pRegExpr Regex
regex_'5bA'2dZ'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'5cs'2a'5c'2e) KateParser [Char]
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"ModuleEnv2") ParsecT [Char] SyntaxState Identity ()
-> KateParser ([Char], [Char]) -> KateParser ([Char], [Char])
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5bA'2dZ'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
popContext) ParsecT [Char] SyntaxState Identity ()
-> KateParser ([Char], [Char]) -> KateParser ([Char], [Char])
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))

parseRules ([Char]
"FSharp",[Char]
"ModuleEnv2") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5bA'2dZ'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char]
pDetectSpaces KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> [Char] -> KateParser [Char]
pString Bool
False [Char]
"." KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"FSharp",[Char]
"ModuleEnv2")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"FSharp",[Char]
"Camlp4 Quotation Constant") =
  (((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'>' Char
'>' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'<' Char
'<' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Camlp4 Quotation Constant"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'3c'3a'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'3c KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"FSharp",[Char]
"Camlp4 Quotation Constant"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'5c'28'5c'5c'7c'3e'3e'7c'3c'3c'29 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialCharTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'5c'3c'3a'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c377'5f'5d'5bA'2dZa'2dz'5c300'2d'5c326'5c330'2d'5c366'5c370'2d'5c3770'2d9'5f'27'5d'2a'3c KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialCharTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"FSharp",[Char]
"Camlp4 Quotation Constant")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))


parseRules ([Char], [Char])
x = ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"FSharp",[Char]
"Normal") KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> [Char] -> KateParser Token
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char]
"Unknown context" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ([Char], [Char]) -> [Char]
forall a. Show a => a -> [Char]
show ([Char], [Char])
x)