{- This module was generated from data in the Kate syntax
   highlighting file dot.xml, version 2, by Postula Loïs (lois.postula@live.be) -}

module Text.Highlighting.Kate.Syntax.Dot
          (highlight, parseExpression, syntaxName, syntaxExtensions)
where
import Text.Highlighting.Kate.Types
import Text.Highlighting.Kate.Common
import qualified Text.Highlighting.Kate.Syntax.Alert
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]
"dot"

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

-- | 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]
"dot",[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]
"dot",[Char]
"Normal") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"dot",[Char]
"DetectAll") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"dot",[Char]
"DetectComments") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"dot",[Char]
"RegionCurly") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"dot",[Char]
"RegionSquare") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"dot",[Char]
"RegionParen") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"dot",[Char]
"String") -> (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]
"dot",[Char]
"CommentSL") -> (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]
"dot",[Char]
"CommentML") -> () -> 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_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]
"digraph node edge subgraph"
list_attributes :: Set [Char]
list_attributes = [[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]
"center layers margin mclimit name nodesep nslimit ordering page pagedir rank rankdir ranksep ratio rotate size distortion fillcolor fontcolor fontname fontsize height layer orientation peripheries regular shape shapefile sides skew width arrowhead arrowsize arrowtail constraint decorateP dir headclip headlabel labelangle labeldistance labelfontcolor labelfontname labelfontsize minlen port_label_distance samehead sametail tailclip taillabel weight color bgcolor label URL fontcolor fontname fontsize layer style"

regex_'5cb'5cw'2b'5cb :: Regex
regex_'5cb'5cw'2b'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\b\\w+\\b"

parseRules :: ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"dot",[Char]
"Normal") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"dot",[Char]
"DetectAll")))
   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]
"dot",[Char]
"Normal")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [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
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"DetectAll") =
  ((([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_keywords ParsecT [Char] SyntaxState Identity [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] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_attributes ParsecT [Char] SyntaxState Identity [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 -> 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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'"' ParsecT [Char] SyntaxState Identity [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]
"dot",[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
<|>
   (([Char] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
";=" ParsecT [Char] SyntaxState Identity [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 -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'-' Char
'>' ParsecT [Char] SyntaxState Identity [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
<|>
   ((ParsecT [Char] SyntaxState Identity [Char]
pFloat ParsecT [Char] SyntaxState Identity [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
<|>
   ((ParsecT [Char] SyntaxState Identity [Char]
pInt ParsecT [Char] SyntaxState Identity [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 -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5cb'5cw'2b'5cb ParsecT [Char] SyntaxState Identity [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
VariableTok))
   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]
"dot",[Char]
"DetectComments")))
   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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'{' ParsecT [Char] SyntaxState Identity [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
-> 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]
"dot",[Char]
"RegionCurly"))
   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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'[' ParsecT [Char] SyntaxState Identity [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
-> 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]
"dot",[Char]
"RegionSquare"))
   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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'(' ParsecT [Char] SyntaxState Identity [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
-> 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]
"dot",[Char]
"RegionParen"))
   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] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
")]}" ParsecT [Char] SyntaxState Identity [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 -> 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]
"dot",[Char]
"DetectAll")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [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
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"DetectComments") =
  (((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'/' Char
'/' ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"CommentSL"))
   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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'/' Char
'*' ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"CommentML"))
   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]
"dot",[Char]
"DetectComments")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [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
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"RegionCurly") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'}' ParsecT [Char] SyntaxState Identity [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
-> 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]
"dot",[Char]
"DetectAll")))
   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]
"dot",[Char]
"RegionCurly")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [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
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"RegionSquare") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
']' ParsecT [Char] SyntaxState Identity [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
-> 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]
"dot",[Char]
"DetectAll")))
   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]
"dot",[Char]
"RegionSquare")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [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
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"RegionParen") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
')' ParsecT [Char] SyntaxState Identity [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
-> 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]
"dot",[Char]
"DetectAll")))
   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]
"dot",[Char]
"RegionParen")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [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
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"String") =
  (((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'\\' Char
'\\' ParsecT [Char] SyntaxState Identity [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 -> 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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'\\' Char
'"' ParsecT [Char] SyntaxState Identity [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 -> 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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'"' ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"String")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [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
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"CommentSL") =
  (((Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Alert.parseExpression (([Char], [Char]) -> Maybe ([Char], [Char])
forall a. a -> Maybe a
Just ([Char]
"Alerts",[Char]
"")) KateParser Token -> (Token -> 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) ([Char] -> KateParser Token)
-> (Token -> [Char]) -> Token -> KateParser Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Token -> [Char]
forall a b. (a, b) -> b
snd)))
   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]
"dot",[Char]
"CommentSL")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [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
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [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]
"dot",[Char]
"CommentML") =
  (((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'*' Char
'/' ParsecT [Char] SyntaxState Identity [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
<|>
   ((Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Alert.parseExpression (([Char], [Char]) -> Maybe ([Char], [Char])
forall a. a -> Maybe a
Just ([Char]
"Alerts",[Char]
"")) KateParser Token -> (Token -> 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) ([Char] -> KateParser Token)
-> (Token -> [Char]) -> Token -> KateParser Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Token -> [Char]
forall a b. (a, b) -> b
snd)))
   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]
"dot",[Char]
"CommentML")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [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
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [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]
"Alerts", [Char]
_) = Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Alert.parseExpression Maybe ([Char], [Char])
forall a. Maybe a
Nothing

parseRules ([Char], [Char])
x = ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"dot",[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)