{- This module was generated from data in the Kate syntax
   highlighting file mips.xml, version 2, by Dominik Haumann (dhdev@gmx.de) -}

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

-- | Full name of language.
syntaxName :: String
syntaxName :: [Char]
syntaxName = [Char]
"MIPS Assembler"

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

-- | 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]
"MIPS Assembler",[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
False, 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]
"MIPS Assembler",[Char]
"normal") -> () -> ParsecT [Char] SyntaxState Identity ()
forall a. a -> ParsecT [Char] SyntaxState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"MIPS Assembler",[Char]
"string") -> () -> 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_type :: Set [Char]
list_type = [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> Set [Char]) -> [[Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
".align .ascii .asciiz .byte .double .extern .float .globl .half .sdata .set .space .word"
list_section :: Set [Char]
list_section = [[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]
".data .kdata .ktext .text"
list_hardware :: Set [Char]
list_hardware = [[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]
"abs.d abs.s add add.d add.s addi addiu addu and andi bc0f bc0t bc1f bc1t bc2f bc2t bc3f bc3t beq bgez bgezal bgtz blez bltz bltzal bne break c.eq.d c.eq.s c.seq.s c.seq.d c.ueq.s c.ueq.d c.olt.d c.olt.s c.ole.d c.ole.s c.ult.d c.ult.s c.ule.d c.ule.s c.le.d c.le.s c.lt.d c.lt.s c.un.s c.un.d cvt.d.s cvt.d.w cvt.s.d cvt.s.w cvt.w.d cvt.w.s div.d div.s j jal jalr jr lb lbu lh lhu lui lw lwc0 lwc1 lwc2 lwc3 lwl lwr mfc0 mfc1 mfc2 mfc3 mfhi mflo mtc0 mtc1 mtc2 mtc3 mthi mtlo mul.d mul.s mult multu nor or ori rfe sb sh sw swcl swl swr sll sllv slt slti sltiu sra srav srl srlv sub sub.d sub.s subu sw swc0 swc1 swc2 swc3 swl swr syscall xor xori"
list_pseudo :: Set [Char]
list_pseudo = [[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]
"abs b beqz bge bgeu bgt bgtu ble bleu blt bltu bnez div divu l.d l.s la ld li li.d li.s mfc0.d mfc1.d mfc2.d mfc3.d mov.d mov.s move mul mulo mulou neg neg.d neg.s negu nop not rem remu rol ror s.d s.s sd seq sge sgeu sgt sgtu sle sleu sne ulh ulhu ulw ush usw"
list_register1 :: Set [Char]
list_register1 = [[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]
"$0 $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15 $16 $17 $18 $19 $20 $21 $22 $23 $24 $25 $26 $27 $28 $29 $30 $31 $zero $t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 $t8 $t9"
list_register2 :: Set [Char]
list_register2 = [[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]
"$v0 $v1 $a0 $a1 $a2 $a3 $k0 $k1 $at $gp $sp $fp $s0 $s1 $s2 $s3 $s4 $s5 $s6 $s7 $ra"
list_fp :: Set [Char]
list_fp = [[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]
"$f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15 $f16 $f17 $f18 $f19 $f20 $f21 $f22 $f23 $f24 $f25 $f26 $f27 $f28 $f29 $f30 $f31"

regex_'23'5cs'2aBEGIN'2e'2a'24 :: Regex
regex_'23'5cs'2aBEGIN'2e'2a'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"#\\s*BEGIN.*$"
regex_'23'5cs'2aEND'2e'2a'24 :: Regex
regex_'23'5cs'2aEND'2e'2a'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"#\\s*END.*$"
regex_'23'2e'2a'24 :: Regex
regex_'23'2e'2a'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"#.*$"
regex_'5b'5cw'5f'5c'2e'5d'2b'3a :: Regex
regex_'5b'5cw'5f'5c'2e'5d'2b'3a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[\\w_\\.]+:"
regex_'5c'5c'2e :: Regex
regex_'5c'5c'2e = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\\\."

parseRules :: ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"MIPS Assembler",[Char]
"normal") =
  ((([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_hardware KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_pseudo KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_register1 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_register2 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_fp KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FloatTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_section KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_type KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
pFirstNonSpace ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'5cs'2aBEGIN'2e'2a'24 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
RegionMarkerTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
pFirstNonSpace ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall 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
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'5cs'2aEND'2e'2a'24 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
RegionMarkerTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'2e'2a'24 KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
pFirstNonSpace ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'5b'5cw'5f'5c'2e'5d'2b'3a KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'"' KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
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]
"MIPS Assembler",[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
<|>
   ((KateParser [Char]
pFloat KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FloatTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char]
pHlCOct KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
BaseNTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char]
pHlCHex KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
BaseNTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char]
pInt KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (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]
"MIPS Assembler",[Char]
"normal")) ParsecT [Char] SyntaxState Identity ()
-> KateParser [Char] -> KateParser [Char]
forall a b.
ParsecT [Char] SyntaxState Identity a
-> ParsecT [Char] SyntaxState Identity b
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault KateParser [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall a b.
ParsecT [Char] SyntaxState Identity a
-> (a -> ParsecT [Char] SyntaxState Identity b)
-> ParsecT [Char] SyntaxState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

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


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