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

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

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

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

parseSourceLine :: String -> State SyntaxState SourceLine
parseSourceLine :: [Char] -> State SyntaxState SourceLine
parseSourceLine = KateParser Token -> [Char] -> State SyntaxState SourceLine
mkParseSourceLine (Maybe ([Char], [Char]) -> KateParser Token
parseExpression 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) <- forall b a. b -> (a -> b) -> Maybe a -> b
maybe KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ([Char], [Char])
mbcontext
  Token
result <- ([Char], [Char]) -> KateParser Token
parseRules ([Char]
lang,[Char]
cont)
  forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional forall a b. (a -> b) -> a -> b
$ do forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof
                forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStPrevChar :: Char
synStPrevChar = Char
'\n' }
                ParsecT [Char] SyntaxState Identity ()
pEndLine
  forall (m :: * -> *) a. Monad m => a -> m a
return Token
result

startingState :: SyntaxState
startingState = SyntaxState {synStContexts :: ContextStack
synStContexts = [([Char]
"AWK",[Char]
"Pattern")], 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
  forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStPrevNonspace :: Bool
synStPrevNonspace = Bool
False }
  ([Char], [Char])
context <- KateParser ([Char], [Char])
currentContext
  ContextStack
contexts <- SyntaxState -> ContextStack
synStContexts forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
  SyntaxState
st <- forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
  if forall (t :: * -> *) a. Foldable t => t a -> Int
length ContextStack
contexts forall a. Ord a => a -> a -> Bool
>= Int
2
    then case ([Char], [Char])
context of
      ([Char], [Char])
_ | SyntaxState -> Bool
synStContinuation SyntaxState
st -> forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStContinuation :: Bool
synStContinuation = Bool
False }
      ([Char]
"AWK",[Char]
"Pattern") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"AWK",[Char]
"Block") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"AWK",[Char]
"base") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"AWK",[Char]
"String") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"AWK",[Char]
"Comment") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"AWK",[Char]
"Escape") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"AWK",[Char]
"Match") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"AWK",[Char]
"Regex") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"AWK",[Char]
"regex") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"AWK",[Char]
"Regex Escape") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"AWK",[Char]
"RegexChar") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"AWK",[Char]
"InChar") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"AWK",[Char]
"CharClass") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"AWK",[Char]
"MatchPattern") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"AWK",[Char]
"RegexPattern") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"AWK",[Char]
"CheckRange") -> (ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"AWK",[Char]
"RangePattern") -> (ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"AWK",[Char]
"Pattern2") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char], [Char])
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
    else forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

list_keywords :: Set [Char]
list_keywords = forall a. Ord a => [a] -> Set a
Set.fromList forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words forall a b. (a -> b) -> a -> b
$ [Char]
"if else while do for in continue break print printf getline function return next exit"
list_builtins :: Set [Char]
list_builtins = forall a. Ord a => [a] -> Set a
Set.fromList forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words forall a b. (a -> b) -> a -> b
$ [Char]
"ARGC ARGV CONVFMT ENVIRON FILENAME FNR FS NF NR OFMT OFS ORS RS RSTART RLENGTH SUBSEP"
list_functions :: Set [Char]
list_functions = forall a. Ord a => [a] -> Set a
Set.fromList forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words forall a b. (a -> b) -> a -> b
$ [Char]
"gsub gensub index length match split sprintf sub substr tolower toupper atan2 cos exp int log rand sin sqrt srand close fflush system"
list_special :: Set [Char]
list_special = forall a. Ord a => [a] -> Set a
Set.fromList forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words forall a b. (a -> b) -> a -> b
$ [Char]
"BEGIN END"

regex_'5c'24'5bA'2dZa'2dz0'2d9'5f'5d'2b :: Regex
regex_'5c'24'5bA'2dZa'2dz0'2d9'5f'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\$[A-Za-z0-9_]+"
regex_'2e :: Regex
regex_'2e = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"."
regex_'5c'5b'3a'28'3f'3d'5b'5f'5cw'5d'5b'5f'5cd'5cw'5d'2a'3a'5c'5d'29 :: Regex
regex_'5c'5b'3a'28'3f'3d'5b'5f'5cw'5d'5b'5f'5cd'5cw'5d'2a'3a'5c'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\[:(?=[_\\w][_\\d\\w]*:\\])"
regex_'28alpha'7calnum'7cblank'7ccntrl'7cdigit'7cgraph'7clower'7cpunct'7cspace'7cupper'7cxdigit'29'28'3f'3d'3a'5c'5d'29 :: Regex
regex_'28alpha'7calnum'7cblank'7ccntrl'7cdigit'7cgraph'7clower'7cpunct'7cspace'7cupper'7cxdigit'29'28'3f'3d'3a'5c'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(alpha|alnum|blank|cntrl|digit|graph|lower|punct|space|upper|xdigit)(?=:\\])"
regex_'5cs'2a'2c'5cs'2a'28'3f'3d'2f'29 :: Regex
regex_'5cs'2a'2c'5cs'2a'28'3f'3d'2f'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\s*,\\s*(?=/)"

parseRules :: ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"AWK",[Char]
"Pattern") =
  (((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'{' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Block"))
   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
'}' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
pFirstNonSpace forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'/') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"MatchPattern") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
   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]
"AWK",[Char]
"base")))
   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_special forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ControlFlowTok))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"Pattern")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"AWK",[Char]
"Block") =
  (((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'}' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   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
'{' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Block"))
   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]
"AWK",[Char]
"base")))
   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_special forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"Block")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"AWK",[Char]
"base") =
  (((KateParser [Char]
pDetectSpaces forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   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
'#' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Comment"))
   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
'~' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OperatorTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Match"))
   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
'"' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"String"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> KateParser [Char]
pAnyChar [Char]
"!%&*+,-./:;<=>?^|" forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OperatorTok))
   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 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
   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_builtins forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
BuiltInTok))
   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_functions forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char]
pFloat forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FloatTok))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char]
pInt forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'24'5bA'2dZa'2dz0'2d9'5f'5d'2b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"base")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"AWK",[Char]
"String") =
  (((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'"' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char]
pHlCStringChar forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialCharTok))
   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
'\\' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OperatorTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Escape"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"String")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))

parseRules ([Char]
"AWK",[Char]
"Comment") =
  (((Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Alert.parseExpression (forall a. a -> Maybe a
Just ([Char]
"Alerts",[Char]
"")) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd)))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"Comment")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok))

parseRules ([Char]
"AWK",[Char]
"Escape") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'2e forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"Escape")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"AWK",[Char]
"Match") =
  (((KateParser [Char]
pDetectSpaces forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   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
'^' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Regex"))
   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
'/' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Regex"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))

parseRules ([Char]
"AWK",[Char]
"Regex") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"AWK",[Char]
"regex")))
   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
'/' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"Regex")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialStringTok))

parseRules ([Char]
"AWK",[Char]
"regex") =
  (((KateParser [Char]
pHlCStringChar forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialCharTok))
   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
'\\' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Regex Escape"))
   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
'^' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"RegexChar"))
   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
'[' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"RegexChar"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> KateParser [Char]
pAnyChar [Char]
"$.+?*()|" forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"regex")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"AWK",[Char]
"Regex Escape") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'2e forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialStringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"Regex Escape")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"AWK",[Char]
"RegexChar") =
  (((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'-' Char
']' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialStringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"InChar"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> KateParser [Char]
pAnyChar [Char]
"-]" forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialStringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"InChar"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"InChar") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))

parseRules ([Char]
"AWK",[Char]
"InChar") =
  (((KateParser [Char]
pHlCStringChar forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))
   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
'\\' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Regex Escape"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'-' Char
']') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Regex Escape") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
   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
']' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext))
   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
'-' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'5b'3a'28'3f'3d'5b'5f'5cw'5d'5b'5f'5cd'5cw'5d'2a'3a'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"CharClass"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"InChar")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialStringTok))

parseRules ([Char]
"AWK",[Char]
"CharClass") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'28alpha'7calnum'7cblank'7ccntrl'7cdigit'7cgraph'7clower'7cpunct'7cspace'7cupper'7cxdigit'29'28'3f'3d'3a'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ExtensionTok))
   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
']' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"CharClass")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok))

parseRules ([Char]
"AWK",[Char]
"MatchPattern") =
  (((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'/' Char
'^' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"RegexPattern"))
   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
'/' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"RegexPattern"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))

parseRules ([Char]
"AWK",[Char]
"RegexPattern") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"AWK",[Char]
"regex")))
   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
'/' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"CheckRange"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"RegexPattern")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialStringTok))

parseRules ([Char]
"AWK",[Char]
"CheckRange") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cs'2a'2c'5cs'2a'28'3f'3d'2f'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OperatorTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"RangePattern"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))

parseRules ([Char]
"AWK",[Char]
"RangePattern") =
  (((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'/' Char
'^' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Pattern2"))
   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
'/' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"AWK",[Char]
"Pattern2"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))

parseRules ([Char]
"AWK",[Char]
"Pattern2") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"AWK",[Char]
"regex")))
   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
'/' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"AWK",[Char]
"Pattern2")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
SpecialStringTok))

parseRules ([Char]
"Alerts", [Char]
_) = Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Alert.parseExpression forall a. Maybe a
Nothing

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