{- This module was generated from data in the Kate syntax
   highlighting file rust.xml, version 2, by  -}

module Text.Highlighting.Kate.Syntax.Rust
          (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]
"Rust"

-- | Filename extensions for this language.
syntaxExtensions :: String
syntaxExtensions :: [Char]
syntaxExtensions = [Char]
"*.rs"

-- | 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)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [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) <- ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char])
    -> ParsecT [Char] SyntaxState Identity ([Char], [Char]))
-> Maybe ([Char], [Char])
-> ParsecT [Char] SyntaxState Identity ([Char], [Char])
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ParsecT [Char] SyntaxState Identity ([Char], [Char])
currentContext ([Char], [Char])
-> ParsecT [Char] SyntaxState Identity ([Char], [Char])
forall a. a -> ParsecT [Char] SyntaxState Identity a
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 a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Token
result

startingState :: SyntaxState
startingState = SyntaxState {synStContexts :: ContextStack
synStContexts = [([Char]
"Rust",[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 <- ParsecT [Char] SyntaxState Identity ([Char], [Char])
currentContext
  ContextStack
contexts <- SyntaxState -> ContextStack
synStContexts (SyntaxState -> ContextStack)
-> ParsecT [Char] SyntaxState Identity SyntaxState
-> ParsecT [Char] SyntaxState Identity ContextStack
forall a b.
(a -> b)
-> ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
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 a. [a] -> 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]
"Rust",[Char]
"Normal") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Rust",[Char]
"Attribute") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Rust",[Char]
"Function") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Rust",[Char]
"Type") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Rust",[Char]
"String") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Rust",[Char]
"RawString") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Rust",[Char]
"RawHashed1") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Rust",[Char]
"RawHashed2") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Rust",[Char]
"Character") -> (ParsecT [Char] SyntaxState Identity ()
popContext) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Rust",[Char]
"CharEscape") -> (ParsecT [Char] SyntaxState Identity ()
popContext) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Rust",[Char]
"Commentar 1") -> (ParsecT [Char] SyntaxState Identity ()
popContext) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Rust",[Char]
"Commentar 2") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char], [Char])
_ -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    else () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
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 a. [a] -> 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 a. [Char] -> ParsecT s SyntaxState m a
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. HasCallStack => [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 a. a -> ParsecT s SyntaxState m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
attr, [Char]
txt)

list_fn :: Set [Char]
list_fn = [[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]
"fn"
list_type :: Set [Char]
list_type = [[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]
"type"
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 alignof as become box break const continue crate do else enum extern final for if impl in let loop macro match mod move mut offsetof override priv proc pub pure ref return Self self sizeof static struct super trait type typeof unsafe unsized use virtual where while yield"
list_traits :: Set [Char]
list_traits = [[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]
"AsSlice CharExt Clone Copy Debug Decodable Default Display DoubleEndedIterator Drop Encodable Eq Default Extend Fn FnMut FnOnce FromPrimitive Hash Iterator IteratorExt MutPtrExt Ord PartialEq PartialOrd PtrExt Rand Send Sized SliceConcatExt SliceExt Str StrExt Sync ToString"
list_types :: Set [Char]
list_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 int isize uint usize i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 float char str Option Result Self Box Vec String"
list_ctypes :: Set [Char]
list_ctypes = [[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]
"c_float c_double c_void FILE fpos_t DIR dirent c_char c_schar c_uchar c_short c_ushort c_int c_uint c_long c_ulong size_t ptrdiff_t clock_t time_t c_longlong c_ulonglong intptr_t uintptr_t off_t dev_t ino_t pid_t mode_t ssize_t"
list_self :: Set [Char]
list_self = [[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]
"self"
list_constants :: Set [Char]
list_constants = [[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]
"true false Some None Ok Err Success Failure Cons Nil"
list_cconstants :: Set [Char]
list_cconstants = [[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]
"EXIT_FAILURE EXIT_SUCCESS RAND_MAX EOF SEEK_SET SEEK_CUR SEEK_END _IOFBF _IONBF _IOLBF BUFSIZ FOPEN_MAX FILENAME_MAX L_tmpnam TMP_MAX O_RDONLY O_WRONLY O_RDWR O_APPEND O_CREAT O_EXCL O_TRUNC S_IFIFO S_IFCHR S_IFBLK S_IFDIR S_IFREG S_IFMT S_IEXEC S_IWRITE S_IREAD S_IRWXU S_IXUSR S_IWUSR S_IRUSR F_OK R_OK W_OK X_OK STDIN_FILENO STDOUT_FILENO STDERR_FILENO"

regex_0x'5b0'2d9a'2dfA'2dF'5f'5d'2b'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f :: Regex
regex_0x'5b0'2d9a'2dfA'2dF'5f'5d'2b'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"0x[0-9a-fA-F_]+([iu](8|16|32|64)?)?"
regex_0o'5b0'2d7'5f'5d'2b'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f :: Regex
regex_0o'5b0'2d7'5f'5d'2b'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"0o[0-7_]+([iu](8|16|32|64)?)?"
regex_0b'5b0'2d1'5f'5d'2b'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f :: Regex
regex_0b'5b0'2d1'5f'5d'2b'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"0b[0-1_]+([iu](8|16|32|64)?)?"
regex_'5b0'2d9'5d'5b0'2d9'5f'5d'2a'5c'2e'5b0'2d9'5f'5d'2a'28'5beE'5d'5b'2b'2d'5d'3f'5b0'2d9'5f'5d'2b'29'3f'28f32'7cf64'7cf'29'3f :: Regex
regex_'5b0'2d9'5d'5b0'2d9'5f'5d'2a'5c'2e'5b0'2d9'5f'5d'2a'28'5beE'5d'5b'2b'2d'5d'3f'5b0'2d9'5f'5d'2b'29'3f'28f32'7cf64'7cf'29'3f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[0-9][0-9_]*\\.[0-9_]*([eE][+-]?[0-9_]+)?(f32|f64|f)?"
regex_'5b0'2d9'5d'5b0'2d9'5f'5d'2a'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f :: Regex
regex_'5b0'2d9'5d'5b0'2d9'5f'5d'2a'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[0-9][0-9_]*([iu](8|16|32|64)?)?"
regex_'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2a'3a'3a :: Regex
regex_'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2a'3a'3a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[a-zA-Z_][a-zA-Z_0-9]*::"
regex_'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2a'21 :: Regex
regex_'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2a'21 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[a-zA-Z_][a-zA-Z_0-9]*!"
regex_'27'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2a'28'3f'21'27'29 :: Regex
regex_'27'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2a'28'3f'21'27'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"'[a-zA-Z_][a-zA-Z_0-9]*(?!')"
regex_x'5b0'2d9a'2dfA'2dF'5d'7b2'7d :: Regex
regex_x'5b0'2d9a'2dfA'2dF'5d'7b2'7d = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"x[0-9a-fA-F]{2}"
regex_u'5c'7b'5b0'2d9a'2dfA'2dF'5d'7b1'2c6'7d'5c'7d :: Regex
regex_u'5c'7b'5b0'2d9a'2dfA'2dF'5d'7b1'2c6'7d'5c'7d = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"u\\{[0-9a-fA-F]{1,6}\\}"
regex_u'5b0'2d9a'2dfA'2dF'5d'7b4'7d :: Regex
regex_u'5b0'2d9a'2dfA'2dF'5d'7b4'7d = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"u[0-9a-fA-F]{4}"
regex_U'5b0'2d9a'2dfA'2dF'5d'7b8'7d :: Regex
regex_U'5b0'2d9a'2dfA'2dF'5d'7b8'7d = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"U[0-9a-fA-F]{8}"
regex_'2e :: Regex
regex_'2e = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"."

parseRules :: ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Rust",[Char]
"Normal") =
  (((KateParser [Char]
pDetectSpaces KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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_fn KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Function"))
   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_type KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Type"))
   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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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_types KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_traits KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
BuiltInTok))
   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_ctypes KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_self KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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_constants KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
ConstantTok))
   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_cconstants KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
ConstantTok))
   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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Commentar 1"))
   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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Commentar 2"))
   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_0x'5b0'2d9a'2dfA'2dF'5f'5d'2b'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_0o'5b0'2d7'5f'5d'2b'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_0b'5b0'2d1'5f'5d'2b'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5b0'2d9'5d'5b0'2d9'5f'5d'2a'5c'2e'5b0'2d9'5f'5d'2a'28'5beE'5d'5b'2b'2d'5d'3f'5b0'2d9'5f'5d'2b'29'3f'28f32'7cf64'7cf'29'3f KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5b0'2d9'5d'5b0'2d9'5f'5d'2a'28'5biu'5d'288'7c16'7c32'7c64'29'3f'29'3f KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   ((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'#' Char
'[' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
AttributeTok) 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]
"Rust",[Char]
"Attribute"))
   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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
AttributeTok) 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]
"Rust",[Char]
"Attribute"))
   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'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2a'3a'3a KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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_'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2a'21 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
PreprocessorTok))
   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'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2a'28'3f'21'27'29 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
'r' Char
'"' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"RawString"))
   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]
"r##\"" KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"RawHashed2"))
   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]
"r#\"" KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"RawHashed1"))
   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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"String"))
   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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
-> 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]
"Rust",[Char]
"Character"))
   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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
pDetectIdentifier KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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 ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Normal")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Attribute") =
  (((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
']' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
AttributeTok) 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]
"Rust",[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
<|>
   (ParsecT [Char] SyntaxState Identity ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Attribute")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
AttributeTok))

parseRules ([Char]
"Rust",[Char]
"Function") =
  (((KateParser [Char]
pDetectSpaces KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'<' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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 ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Function")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Type") =
  (((KateParser [Char]
pDetectSpaces KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'<' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
';' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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 ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Type")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"String") =
  (((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'\\' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
-> 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]
"Rust",[Char]
"CharEscape"))
   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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   (ParsecT [Char] SyntaxState Identity ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"String")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"RawString") =
  (((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'"' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   (ParsecT [Char] SyntaxState Identity ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"RawString")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"RawHashed1") =
  (((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'"' Char
'#' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   (ParsecT [Char] SyntaxState Identity ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"RawHashed1")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"RawHashed2") =
  (((Bool -> [Char] -> KateParser [Char]
pString Bool
False [Char]
"\"##" KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   (ParsecT [Char] SyntaxState Identity ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"RawHashed2")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Character") =
  (((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'\\' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
-> 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]
"Rust",[Char]
"CharEscape"))
   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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
-> 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 ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Character")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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))

parseRules ([Char]
"Rust",[Char]
"CharEscape") =
  ((([Char] -> KateParser [Char]
pAnyChar [Char]
"nrt\\'\"" KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
-> 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_x'5b0'2d9a'2dfA'2dF'5d'7b2'7d KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
-> 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_u'5c'7b'5b0'2d9a'2dfA'2dF'5d'7b1'2c6'7d'5c'7d KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
-> 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_u'5b0'2d9a'2dfA'2dF'5d'7b4'7d KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
-> 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_U'5b0'2d9a'2dfA'2dF'5d'7b8'7d KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
-> 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_'2e KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
ErrorTok) 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 ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"CharEscape")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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))

parseRules ([Char]
"Rust",[Char]
"Commentar 1") =
  (ParsecT [Char] SyntaxState Identity ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Commentar 1")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Commentar 2") =
  (((KateParser [Char]
pDetectSpaces KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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 -> 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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Commentar 2"))
   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 a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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
<|>
   (ParsecT [Char] SyntaxState Identity ([Char], [Char])
currentContext ParsecT [Char] SyntaxState Identity ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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]
"Rust",[Char]
"Commentar 2")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
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], [Char])
x = ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Rust",[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 a. [Char] -> ParsecT [Char] SyntaxState Identity a
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)