{- This module was generated from data in the Kate syntax
   highlighting file ruby.xml, version 2, by Stefan Lang (langstefan@gmx.at), Sebastian Vuorinen (sebastian.vuorinen@helsinki.fi), Robin Pedersen (robinpeder@gmail.com), Miquel Sabaté (mikisabate@gmail.com) -}

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

-- | Filename extensions for this language.
syntaxExtensions :: String
syntaxExtensions :: [Char]
syntaxExtensions = [Char]
"*.rb;*.rjs;*.rxml;*.xml.erb;*.js.erb;*.rake;Rakefile;Gemfile;*.gemspec;Vagrantfile"

-- | 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]
"Ruby",[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
  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]
"Ruby",[Char]
"Normal") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"check_div_1") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"check_div_1_pop") -> (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]
"Ruby",[Char]
"check_div_2") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"check_div_2_internal") -> (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]
"Ruby",[Char]
"check_div_2_pop") -> (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]
"Ruby",[Char]
"check_div_2_pop_internal") -> (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]
"Ruby",[Char]
"Line Continue") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"Find closing block brace") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"Quoted String") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"Apostrophed String") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"Command String") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"Embedded documentation") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"RegEx 1") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"Subst") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"Short Subst") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"Member Access") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"Comment Line") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"General Comment") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"RDoc Label") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"find_heredoc") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"find_indented_heredoc") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"indented_heredoc") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"apostrophed_indented_heredoc") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"normal_heredoc") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"apostrophed_normal_heredoc") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"heredoc_rules") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"find_gdl_input") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"Ruby",[Char]
"gdl_dq_string_1") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_dq_string_1_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_dq_string_2") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_dq_string_2_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_dq_string_3") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_dq_string_3_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_dq_string_4") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_dq_string_4_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_dq_string_5") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"dq_string_rules") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_token_array_1") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_token_array_1_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_token_array_2") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_token_array_2_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_token_array_3") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_token_array_3_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_token_array_4") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_token_array_4_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_token_array_5") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"token_array_rules") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_apostrophed_1") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_apostrophed_1_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_apostrophed_2") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_apostrophed_2_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_apostrophed_3") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_apostrophed_3_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_apostrophed_4") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_apostrophed_4_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_apostrophed_5") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"apostrophed_rules") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_shell_command_1") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_shell_command_1_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_shell_command_2") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_shell_command_2_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_shell_command_3") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_shell_command_3_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_shell_command_4") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_shell_command_4_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_shell_command_5") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"shell_command_rules") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_regexpr_1") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_regexpr_1_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_regexpr_2") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_regexpr_2_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_regexpr_3") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_regexpr_3_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_regexpr_4") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_regexpr_4_nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"gdl_regexpr_5") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"regexpr_rules") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"Ruby",[Char]
"DATA") -> 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]
"BEGIN END and begin break case defined? do else elsif end ensure for if in next not or redo rescue retry return then unless until when yield"
list_access'2dcontrol :: Set [Char]
list_access'2dcontrol = 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]
"private_class_method private protected public_class_method public"
list_attribute'2ddefinitions :: Set [Char]
list_attribute'2ddefinitions = 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]
"attr_reader attr_writer attr_accessor"
list_definitions :: Set [Char]
list_definitions = 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]
"alias module class def undef"
list_pseudo'2dvariables :: Set [Char]
list_pseudo'2dvariables = 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]
"self super nil false true caller __FILE__ __LINE__"
list_default'2dglobals :: Set [Char]
list_default'2dglobals = 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]
"$stdout $defout $stderr $deferr $stdin"
list_kernel'2dmethods :: Set [Char]
list_kernel'2dmethods = 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]
"abort at_exit autoload autoload? binding block_given? callcc caller catch chomp chomp! chop chop! eval exec exit exit! fail fork format getc gets global_variables gsub gsub! iterator? lambda load local_variables loop method_missing open p print printf proc putc puts raise rand readline readlines require require_relative scan select set_trace_func sleep split sprintf srand sub sub! syscall system test throw trace_var trap untrace_var warn"
list_mixin'2dmethods :: Set [Char]
list_mixin'2dmethods = 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]
"extend include prepend"

regex_'5f'5fEND'5f'5f'24 :: Regex
regex_'5f'5fEND'5f'5f'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"__END__$"
regex_'23'21'5c'2f'2e'2a :: Regex
regex_'23'21'5c'2f'2e'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"#!\\/.*"
regex_'28'5c'3d'7c'5c'28'7c'5c'5b'7c'5c'7b'29'5cs'2a'28if'7cunless'7cwhile'7cuntil'29'5cb :: Regex
regex_'28'5c'3d'7c'5c'28'7c'5c'5b'7c'5c'7b'29'5cs'2a'28if'7cunless'7cwhile'7cuntil'29'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(\\=|\\(|\\[|\\{)\\s*(if|unless|while|until)\\b"
regex_'28while'7cuntil'29'5cb'28'3f'21'2e'2a'5cbdo'5cb'29 :: Regex
regex_'28while'7cuntil'29'5cb'28'3f'21'2e'2a'5cbdo'5cb'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(while|until)\\b(?!.*\\bdo\\b)"
regex_'5c'3b'5cs'2a'28while'7cuntil'29'5cb'28'3f'21'2e'2a'5cbdo'5cb'29 :: Regex
regex_'5c'3b'5cs'2a'28while'7cuntil'29'5cb'28'3f'21'2e'2a'5cbdo'5cb'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\;\\s*(while|until)\\b(?!.*\\bdo\\b)"
regex_'28if'7cunless'29'5cb :: Regex
regex_'28if'7cunless'29'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(if|unless)\\b"
regex_'5c'3b'5cs'2a'28if'7cunless'29'5cb :: Regex
regex_'5c'3b'5cs'2a'28if'7cunless'29'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\;\\s*(if|unless)\\b"
regex_'5cbclass'5cb :: Regex
regex_'5cbclass'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\bclass\\b"
regex_'5cbmodule'5cb :: Regex
regex_'5cbmodule'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\bmodule\\b"
regex_'5cbbegin'5cb :: Regex
regex_'5cbbegin'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\bbegin\\b"
regex_'5cbfor'5cb'28'3f'21'2e'2a'5cbdo'5cb'29 :: Regex
regex_'5cbfor'5cb'28'3f'21'2e'2a'5cbdo'5cb'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\bfor\\b(?!.*\\bdo\\b)"
regex_'5cbcase'5cb :: Regex
regex_'5cbcase'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\bcase\\b"
regex_'5cbdo'5cb :: Regex
regex_'5cbdo'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\bdo\\b"
regex_'5cbdef'5cb :: Regex
regex_'5cbdef'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\bdef\\b"
regex_'5cbend'5cb :: Regex
regex_'5cbend'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\bend\\b"
regex_'5cb'28else'7celsif'7crescue'7censure'29'5cb :: Regex
regex_'5cb'28else'7celsif'7crescue'7censure'29'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\b(else|elsif|rescue|ensure)\\b"
regex_'5c'2e'5b'5fa'2dz'5d'5b'5fa'2dzA'2dZ0'2d9'5d'2a'28'5c'3f'7c'5c'21'7c'5cb'29 :: Regex
regex_'5c'2e'5b'5fa'2dz'5d'5b'5fa'2dzA'2dZ0'2d9'5d'2a'28'5c'3f'7c'5c'21'7c'5cb'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\.[_a-z][_a-zA-Z0-9]*(\\?|\\!|\\b)"
regex_'5cs'5c'3f'28'5c'5cM'5c'2d'29'3f'28'5c'5cC'5c'2d'29'3f'5c'5c'3f'5cS :: Regex
regex_'5cs'5c'3f'28'5c'5cM'5c'2d'29'3f'28'5c'5cC'5c'2d'29'3f'5c'5c'3f'5cS = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\s\\?(\\\\M\\-)?(\\\\C\\-)?\\\\?\\S"
regex_'5c'24'5ba'2dzA'2dZ'5f0'2d9'5d'2b :: Regex
regex_'5c'24'5ba'2dzA'2dZ'5f0'2d9'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\$[a-zA-Z_0-9]+"
regex_'5c'24'5c'2d'5ba'2dzA'2dz'5f'5d'5cb :: Regex
regex_'5c'24'5c'2d'5ba'2dzA'2dz'5f'5d'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\$\\-[a-zA-z_]\\b"
regex_'5c'24'5b'5cd'5f'2a'60'2b'40'3b'2c'2e'7e'3d'5c'21'5c'24'3a'3f'27'2f'5c'5c'5c'2d'5c'26'22'3e'3c'5d :: Regex
regex_'5c'24'5b'5cd'5f'2a'60'2b'40'3b'2c'2e'7e'3d'5c'21'5c'24'3a'3f'27'2f'5c'5c'5c'2d'5c'26'22'3e'3c'5d = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\$[\\d_*`+@;,.~=\\!\\$:?'/\\\\\\-\\&\"><]"
regex_'5cb'5b'5fA'2dZ'5d'2b'5bA'2dZ'5f0'2d9'5d'2b'5cb :: Regex
regex_'5cb'5b'5fA'2dZ'5d'2b'5bA'2dZ'5f0'2d9'5d'2b'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\b[_A-Z]+[A-Z_0-9]+\\b"
regex_'5cb'5bA'2dZ'5d'2b'5f'2a'28'5b0'2d9'5d'7c'5ba'2dz'5d'29'5b'5fa'2dzA'2dZ0'2d9'5d'2a'5cb :: Regex
regex_'5cb'5bA'2dZ'5d'2b'5f'2a'28'5b0'2d9'5d'7c'5ba'2dz'5d'29'5b'5fa'2dzA'2dZ0'2d9'5d'2a'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\\b"
regex_'5cb'5c'2d'3f0'5bxX'5d'28'5b0'2d9a'2dfA'2dF'5d'7c'5f'5b0'2d9a'2dfA'2dF'5d'29'2b :: Regex
regex_'5cb'5c'2d'3f0'5bxX'5d'28'5b0'2d9a'2dfA'2dF'5d'7c'5f'5b0'2d9a'2dfA'2dF'5d'29'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\b\\-?0[xX]([0-9a-fA-F]|_[0-9a-fA-F])+"
regex_'5cb'5c'2d'3f0'5bbB'5d'28'5b01'5d'7c'5f'5b01'5d'29'2b :: Regex
regex_'5cb'5c'2d'3f0'5bbB'5d'28'5b01'5d'7c'5f'5b01'5d'29'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\b\\-?0[bB]([01]|_[01])+"
regex_'5cb'5c'2d'3f0'5b1'2d7'5d'28'5b0'2d7'5d'7c'5f'5b0'2d7'5d'29'2a :: Regex
regex_'5cb'5c'2d'3f0'5b1'2d7'5d'28'5b0'2d7'5d'7c'5f'5b0'2d7'5d'29'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\b\\-?0[1-7]([0-7]|_[0-7])*"
regex_'5cb'5c'2d'3f'5b0'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'5c'2e'5b0'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'28'5beE'5d'5c'2d'3f'5b1'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'28'5c'2e'5b0'2d9'5d'2a'29'3f'29'3f :: Regex
regex_'5cb'5c'2d'3f'5b0'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'5c'2e'5b0'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'28'5beE'5d'5c'2d'3f'5b1'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'28'5c'2e'5b0'2d9'5d'2a'29'3f'29'3f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\b\\-?[0-9]([0-9]|_[0-9])*\\.[0-9]([0-9]|_[0-9])*([eE]\\-?[1-9]([0-9]|_[0-9])*(\\.[0-9]*)?)?"
regex_'5cb'5c'2d'3f'5b1'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'5cb :: Regex
regex_'5cb'5c'2d'3f'5b1'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\b\\-?[1-9]([0-9]|_[0-9])*\\b"
regex_'3dbegin'28'3f'3a'5cs'7c'24'29 :: Regex
regex_'3dbegin'28'3f'3a'5cs'7c'24'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"=begin(?:\\s|$)"
regex_'5cs'2a'3c'3c'2d'28'3f'3d'5cw'2b'7c'5b'22'27'5d'29 :: Regex
regex_'5cs'2a'3c'3c'2d'28'3f'3d'5cw'2b'7c'5b'22'27'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\s*<<-(?=\\w+|[\"'])"
regex_'5cs'2a'3c'3c'28'3f'3d'5cw'2b'7c'5b'22'27'5d'29 :: Regex
regex_'5cs'2a'3c'3c'28'3f'3d'5cw'2b'7c'5b'22'27'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\s*<<(?=\\w+|[\"'])"
regex_'5cs'5b'5c'3f'5c'3a'5c'25'5d'5cs :: Regex
regex_'5cs'5b'5c'3f'5c'3a'5c'25'5d'5cs = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\s[\\?\\:\\%]\\s"
regex_'5b'7c'26'3c'3e'5c'5e'5c'2b'2a'7e'5c'2d'3d'5d'2b :: Regex
regex_'5b'7c'26'3c'3e'5c'5e'5c'2b'2a'7e'5c'2d'3d'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[|&<>\\^\\+*~\\-=]+"
regex_'5cs'21 :: Regex
regex_'5cs'21 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\s!"
regex_'2f'3d'5cs :: Regex
regex_'2f'3d'5cs = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"/=\\s"
regex_'3a'28'40'7b1'2c2'7d'7c'5c'24'29'3f'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'5f'5d'2a'5b'3d'3f'21'5d'3f :: Regex
regex_'3a'28'40'7b1'2c2'7d'7c'5c'24'29'3f'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'5f'5d'2a'5b'3d'3f'21'5d'3f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
":(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?"
regex_'3a'5c'5b'5c'5d'3d'3f :: Regex
regex_'3a'5c'5b'5c'5d'3d'3f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
":\\[\\]=?"
regex_'28'40'7b1'2c2'7d'7c'5c'24'29'3f'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'5f'5d'2a'5b'3d'3f'21'5d'3f'3a_ :: Regex
regex_'28'40'7b1'2c2'7d'7c'5c'24'29'3f'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'5f'5d'2a'5b'3d'3f'21'5d'3f'3a_ = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?: "
regex_'5c'5b'5c'5d'3d'3f'3a_ :: Regex
regex_'5c'5b'5c'5d'3d'3f'3a_ = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\[\\]=?: "
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_'40'5ba'2dzA'2dZ'5f0'2d9'5d'2b :: Regex
regex_'40'5ba'2dzA'2dZ'5f0'2d9'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"@[a-zA-Z_0-9]+"
regex_'40'40'5ba'2dzA'2dZ'5f0'2d9'5d'2b :: Regex
regex_'40'40'5ba'2dzA'2dZ'5f0'2d9'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"@@[a-zA-Z_0-9]+"
regex_'5cs'2a'5b'25'5d'28'3f'3d'5bQqxwW'5d'3f'5b'5e'5cs'5d'29 :: Regex
regex_'5cs'2a'5b'25'5d'28'3f'3d'5bQqxwW'5d'3f'5b'5e'5cs'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\s*[%](?=[QqxwW]?[^\\s])"
regex_'5cs'2a :: Regex
regex_'5cs'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\s*"
regex_'5cs'2b :: Regex
regex_'5cs'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\s+"
regex_'5b'2f'25'5d'28'3f'3d'5cs'29 :: Regex
regex_'5b'2f'25'5d'28'3f'3d'5cs'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[/%](?=\\s)"
regex_'2f'28'3f'3d'5cs'29 :: Regex
regex_'2f'28'3f'3d'5cs'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"/(?=\\s)"
regex_'5c'5c'5c'22 :: Regex
regex_'5c'5c'5c'22 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\\\\\\""
regex_'23'40'7b1'2c2'7d :: Regex
regex_'23'40'7b1'2c2'7d = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"#@{1,2}"
regex_'5c'5c'5c'27 :: Regex
regex_'5c'5c'5c'27 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\\\\\'"
regex_'5c'5c'5c'60 :: Regex
regex_'5c'5c'5c'60 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\\\\\`"
regex_'3dend'28'3f'3a'5cs'2e'2a'7c'24'29 :: Regex
regex_'3dend'28'3f'3a'5cs'2e'2a'7c'24'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"=end(?:\\s.*|$)"
regex_'5c'5c'5c'2f :: Regex
regex_'5c'5c'5c'2f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\\\\\/"
regex_'2f'5buiomxn'5d'2a :: Regex
regex_'2f'5buiomxn'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"/[uiomxn]*"
regex_'5cw'28'3f'21'5cw'29 :: Regex
regex_'5cw'28'3f'21'5cw'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\w(?!\\w)"
regex_'5c'2e'3f'5b'5fa'2dz'5d'5cw'2a'28'5c'3f'7c'5c'21'29'3f'28'3f'3d'5b'5e'5cw'5cd'5c'2e'5c'3a'5d'29 :: Regex
regex_'5c'2e'3f'5b'5fa'2dz'5d'5cw'2a'28'5c'3f'7c'5c'21'29'3f'28'3f'3d'5b'5e'5cw'5cd'5c'2e'5c'3a'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\.?[_a-z]\\w*(\\?|\\!)?(?=[^\\w\\d\\.\\:])"
regex_'5c'2e'3f'5b'5fa'2dz'5d'5cw'2a'28'5c'3f'7c'5c'21'29'3f :: Regex
regex_'5c'2e'3f'5b'5fa'2dz'5d'5cw'2a'28'5c'3f'7c'5c'21'29'3f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\.?[_a-z]\\w*(\\?|\\!)?"
regex_'5bA'2dZ'5d'2b'5f'2a'28'5cd'7c'5ba'2dz'5d'29'5cw'2a'28'3f'3d'5b'5e'5cw'5cd'5c'2e'5c'3a'5d'29 :: Regex
regex_'5bA'2dZ'5d'2b'5f'2a'28'5cd'7c'5ba'2dz'5d'29'5cw'2a'28'3f'3d'5b'5e'5cw'5cd'5c'2e'5c'3a'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[A-Z]+_*(\\d|[a-z])\\w*(?=[^\\w\\d\\.\\:])"
regex_'5bA'2dZ'5d'2b'5f'2a'28'5b0'2d9'5d'7c'5ba'2dz'5d'29'5cw'2a :: Regex
regex_'5bA'2dZ'5d'2b'5f'2a'28'5b0'2d9'5d'7c'5ba'2dz'5d'29'5cw'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[A-Z]+_*([0-9]|[a-z])\\w*"
regex_'5b'5fA'2dZ'5d'5b'5fA'2dZ0'2d9'5d'2a'28'3f'3d'5b'5e'5cw'5cd'5c'2e'5c'3a'5d'29 :: Regex
regex_'5b'5fA'2dZ'5d'5b'5fA'2dZ0'2d9'5d'2a'28'3f'3d'5b'5e'5cw'5cd'5c'2e'5c'3a'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[_A-Z][_A-Z0-9]*(?=[^\\w\\d\\.\\:])"
regex_'5b'5fA'2dZ'5d'5b'5fA'2dZ0'2d9'5d'2a :: Regex
regex_'5b'5fA'2dZ'5d'5b'5fA'2dZ0'2d9'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[_A-Z][_A-Z0-9]*"
regex_'5cW :: Regex
regex_'5cW = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\W"
regex_'5cw'5c'3a'5c'3a'5cs :: Regex
regex_'5cw'5c'3a'5c'3a'5cs = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\w\\:\\:\\s"
regex_'27'28'5cw'2b'29'27 :: Regex
regex_'27'28'5cw'2b'29'27 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"'(\\w+)'"
regex_'22'3f'28'5cw'2b'29'22'3f :: Regex
regex_'22'3f'28'5cw'2b'29'22'3f = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\"?(\\w+)\"?"
regex_w'5c'28 :: Regex
regex_w'5c'28 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"w\\("
regex_w'5c'7b :: Regex
regex_w'5c'7b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"w\\{"
regex_w'5c'5b :: Regex
regex_w'5c'5b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"w\\["
regex_w'3c :: Regex
regex_w'3c = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"w<"
regex_w'28'5b'5e'5cs'5cw'5d'29 :: Regex
regex_w'28'5b'5e'5cs'5cw'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"w([^\\s\\w])"
regex_W'5c'28 :: Regex
regex_W'5c'28 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"W\\("
regex_W'5c'7b :: Regex
regex_W'5c'7b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"W\\{"
regex_W'5c'5b :: Regex
regex_W'5c'5b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"W\\["
regex_W'3c :: Regex
regex_W'3c = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"W<"
regex_W'28'5b'5e'5cs'5cw'5d'29 :: Regex
regex_W'28'5b'5e'5cs'5cw'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"W([^\\s\\w])"
regex_q'5c'28 :: Regex
regex_q'5c'28 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"q\\("
regex_q'5c'7b :: Regex
regex_q'5c'7b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"q\\{"
regex_q'5c'5b :: Regex
regex_q'5c'5b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"q\\["
regex_q'3c :: Regex
regex_q'3c = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"q<"
regex_q'28'5b'5e'5cs'5cw'5d'29 :: Regex
regex_q'28'5b'5e'5cs'5cw'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"q([^\\s\\w])"
regex_x'5c'28 :: Regex
regex_x'5c'28 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"x\\("
regex_x'5c'7b :: Regex
regex_x'5c'7b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"x\\{"
regex_x'5c'5b :: Regex
regex_x'5c'5b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"x\\["
regex_x'3c :: Regex
regex_x'3c = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"x<"
regex_x'28'5b'5e'5cs'5cw'5d'29 :: Regex
regex_x'28'5b'5e'5cs'5cw'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"x([^\\s\\w])"
regex_r'5c'28 :: Regex
regex_r'5c'28 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"r\\("
regex_r'5c'7b :: Regex
regex_r'5c'7b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"r\\{"
regex_r'5c'5b :: Regex
regex_r'5c'5b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"r\\["
regex_r'3c :: Regex
regex_r'3c = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"r<"
regex_r'28'5b'5e'5cs'5cw'5d'29 :: Regex
regex_r'28'5b'5e'5cs'5cw'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"r([^\\s\\w])"
regex_Q'3f'5c'28 :: Regex
regex_Q'3f'5c'28 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"Q?\\("
regex_Q'3f'5c'7b :: Regex
regex_Q'3f'5c'7b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"Q?\\{"
regex_Q'3f'5c'5b :: Regex
regex_Q'3f'5c'5b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"Q?\\["
regex_Q'3f'3c :: Regex
regex_Q'3f'3c = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"Q?<"
regex_Q'3f'28'5b'5e'5cs'5cw'5d'29 :: Regex
regex_Q'3f'28'5b'5e'5cs'5cw'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"Q?([^\\s\\w])"
regex_'5c'29'5buiomxn'5d'2a :: Regex
regex_'5c'29'5buiomxn'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\)[uiomxn]*"
regex_'5c'7d'5buiomxn'5d'2a :: Regex
regex_'5c'7d'5buiomxn'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\}[uiomxn]*"
regex_'5c'5d'5buiomxn'5d'2a :: Regex
regex_'5c'5d'5buiomxn'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\][uiomxn]*"
regex_'3e'5buiomxn'5d'2a :: Regex
regex_'3e'5buiomxn'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
">[uiomxn]*"

parseRules :: ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"Normal") =
  (((KateParser [Char]
pLineContinue 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"Line Continue"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((forall tok st. Int -> GenParser tok st ()
pColumn Int
0 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'5f'5fEND'5f'5f'24 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]
"Ruby",[Char]
"DATA"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((forall tok st. Int -> GenParser tok st ()
pColumn Int
0 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'21'5c'2f'2e'2a 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
<|>
   ((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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"Find closing block brace"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'28'5c'3d'7c'5c'28'7c'5c'5b'7c'5c'7b'29'5cs'2a'28if'7cunless'7cwhile'7cuntil'29'5cb 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'28while'7cuntil'29'5cb'28'3f'21'2e'2a'5cbdo'5cb'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
KeywordTok))
   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'3b'5cs'2a'28while'7cuntil'29'5cb'28'3f'21'2e'2a'5cbdo'5cb'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
KeywordTok))
   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
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'28if'7cunless'29'5cb 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'3b'5cs'2a'28if'7cunless'29'5cb 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cbclass'5cb 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cbmodule'5cb 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cbbegin'5cb 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cbfor'5cb'28'3f'21'2e'2a'5cbdo'5cb'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
KeywordTok))
   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_'5cbcase'5cb 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cbdo'5cb 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cbdef'5cb 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cbend'5cb 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cb'28else'7celsif'7crescue'7censure'29'5cb 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
<|>
   ((Bool -> [Char] -> KateParser [Char]
pString 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
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
NormalTok))
   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'2e'5b'5fa'2dz'5d'5b'5fa'2dzA'2dZ0'2d9'5d'2a'28'5c'3f'7c'5c'21'7c'5cb'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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2"))
   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_'5cs'5c'3f'28'5c'5cM'5c'2d'29'3f'28'5c'5cC'5c'2d'29'3f'5c'5c'3f'5cS 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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_attribute'2ddefinitions 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]
"Ruby",[Char]
"check_div_2"))
   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_access'2dcontrol 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]
"Ruby",[Char]
"check_div_2"))
   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_definitions 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_pseudo'2dvariables 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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_default'2dglobals 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2"))
   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_kernel'2dmethods 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2"))
   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_mixin'2dmethods 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2"))
   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'2dZ'5f0'2d9'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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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'5c'2d'5ba'2dzA'2dz'5f'5d'5cb 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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'5b'5cd'5f'2a'60'2b'40'3b'2c'2e'7e'3d'5c'21'5c'24'3a'3f'27'2f'5c'5c'5c'2d'5c'26'22'3e'3c'5d 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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_'5cb'5b'5fA'2dZ'5d'2b'5bA'2dZ'5f0'2d9'5d'2b'5cb 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2"))
   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_'5cb'5bA'2dZ'5d'2b'5f'2a'28'5b0'2d9'5d'7c'5ba'2dz'5d'29'5b'5fa'2dzA'2dZ0'2d9'5d'2a'5cb 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2"))
   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_'5cb'5c'2d'3f0'5bxX'5d'28'5b0'2d9a'2dfA'2dF'5d'7c'5f'5b0'2d9a'2dfA'2dF'5d'29'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
BaseNTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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_'5cb'5c'2d'3f0'5bbB'5d'28'5b01'5d'7c'5f'5b01'5d'29'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
BaseNTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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_'5cb'5c'2d'3f0'5b1'2d7'5d'28'5b0'2d7'5d'7c'5f'5b0'2d7'5d'29'2a 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
BaseNTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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_'5cb'5c'2d'3f'5b0'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'5c'2e'5b0'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'28'5beE'5d'5c'2d'3f'5b1'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'28'5c'2e'5b0'2d9'5d'2a'29'3f'29'3f 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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_'5cb'5c'2d'3f'5b1'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'5cb 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char]
pHlCChar 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
CharTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((forall tok st. Int -> GenParser tok st ()
pColumn Int
0 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'3dbegin'28'3f'3a'5cs'7c'24'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
CommentTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"Embedded documentation"))
   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_'5cs'2a'3c'3c'2d'28'3f'3d'5cw'2b'7c'5b'22'27'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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"find_indented_heredoc"))
   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_'5cs'2a'3c'3c'28'3f'3d'5cw'2b'7c'5b'22'27'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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"find_heredoc"))
   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
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
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
NormalTok))
   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_'5cs'5b'5c'3f'5c'3a'5c'25'5d'5cs 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5b'7c'26'3c'3e'5c'5e'5c'2b'2a'7e'5c'2d'3d'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
NormalTok))
   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_'5cs'21 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'2f'3d'5cs 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]
pString 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
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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"Member Access"))
   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_'3a'28'40'7b1'2c2'7d'7c'5c'24'29'3f'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'5f'5d'2a'5b'3d'3f'21'5d'3f 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]
"Ruby",[Char]
"check_div_1"))
   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_'3a'5c'5b'5c'5d'3d'3f 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]
"Ruby",[Char]
"check_div_1"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'28'40'7b1'2c2'7d'7c'5c'24'29'3f'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'5f'5d'2a'5b'3d'3f'21'5d'3f'3a_ 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]
"Ruby",[Char]
"check_div_1"))
   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'5c'5d'3d'3f'3a_ 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]
"Ruby",[Char]
"check_div_1"))
   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]
"Ruby",[Char]
"Quoted String"))
   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]
"Ruby",[Char]
"Apostrophed String"))
   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]
"Ruby",[Char]
"Command String"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> [Char] -> KateParser [Char]
pString Bool
False [Char]
"?#" 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
<|>
   ((forall tok st. Int -> GenParser tok st ()
pColumn Int
0 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'5cs'2aBEGIN'2e'2a'24 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 s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((forall tok st. Int -> GenParser tok st ()
pColumn Int
0 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'5cs'2aEND'2e'2a'24 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 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]
"Ruby",[Char]
"General 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
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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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
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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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_'40'5ba'2dzA'2dZ'5f0'2d9'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
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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_'40'40'5ba'2dzA'2dZ'5f0'2d9'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
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   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]
"Ruby",[Char]
"RegEx 1"))
   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_'5cs'2a'5b'25'5d'28'3f'3d'5bQqxwW'5d'3f'5b'5e'5cs'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]
"Ruby",[Char]
"find_gdl_input"))
   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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((KateParser [Char]
pDetectIdentifier 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2"))
   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]
"Ruby",[Char]
"Normal")) 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]
"Ruby",[Char]
"check_div_1") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cs'2a 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
<|>
   (([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
NormalTok) 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
<|>
   ((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]
"Ruby",[Char]
"check_div_1_pop") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cs'2a 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
<|>
   (([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
NormalTok) 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
<|>
   ((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]
"Ruby",[Char]
"check_div_2") =
  ((([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
NormalTok) 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cs'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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2_internal"))
   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]
"Ruby",[Char]
"check_div_2_internal") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5b'2f'25'5d'28'3f'3d'5cs'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
NormalTok) 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
<|>
   ((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]
"Ruby",[Char]
"check_div_2_pop") =
  ((([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
NormalTok) 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cs'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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2_pop_internal"))
   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
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))

parseRules ([Char]
"Ruby",[Char]
"check_div_2_pop_internal") =
  (((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
NormalTok) 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 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_'2f'28'3f'3d'5cs'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
NormalTok) 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 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]
"Ruby",[Char]
"Line Continue") =
  (((ParsecT [Char] SyntaxState Identity ()
pFirstNonSpace forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'28while'7cuntil'29'5cb'28'3f'21'2e'2a'5cbdo'5cb'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
KeywordTok))
   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
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'28if'7cunless'29'5cb 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], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"Normal")))
   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]
"Ruby",[Char]
"Line Continue")) 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]
"Ruby",[Char]
"Find closing block brace") =
  (((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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1_pop"))
   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]
"Ruby",[Char]
"Normal")))
   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]
"Ruby",[Char]
"Find closing block brace")) 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]
"Ruby",[Char]
"Quoted String") =
  (((Bool -> [Char] -> KateParser [Char]
pString 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 s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'5c'5c'22 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'40'7b1'2c2'7d 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]
"Ruby",[Char]
"Short Subst"))
   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]
"Ruby",[Char]
"Subst"))
   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]
"Ruby",[Char]
"check_div_1_pop"))
   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]
"Ruby",[Char]
"Quoted 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]
"Ruby",[Char]
"Apostrophed String") =
  (((Bool -> [Char] -> KateParser [Char]
pString 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 s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'5c'5c'27 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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_1_pop"))
   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]
"Ruby",[Char]
"Apostrophed 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]
"Ruby",[Char]
"Command String") =
  (((Bool -> [Char] -> KateParser [Char]
pString 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 s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'5c'5c'60 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'40'7b1'2c2'7d 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]
"Ruby",[Char]
"Short Subst"))
   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]
"Ruby",[Char]
"Subst"))
   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]
"Ruby",[Char]
"check_div_1_pop"))
   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]
"Ruby",[Char]
"Command 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]
"Ruby",[Char]
"Embedded documentation") =
  (((forall tok st. Int -> GenParser tok st ()
pColumn Int
0 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> KateParser [Char]
pRegExpr Regex
regex_'3dend'28'3f'3a'5cs'2e'2a'7c'24'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
CommentTok) 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
<|>
   ((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]
"Ruby",[Char]
"Embedded documentation")) 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]
"Ruby",[Char]
"RegEx 1") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'5c'5c'2f 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_'23'40'7b1'2c2'7d 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]
"Ruby",[Char]
"Short Subst"))
   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]
"Ruby",[Char]
"Subst"))
   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_'2f'5buiomxn'5d'2a 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]
"Ruby",[Char]
"check_div_1_pop"))
   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]
"Ruby",[Char]
"RegEx 1")) 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]
"Ruby",[Char]
"Subst") =
  (((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 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]
"Ruby",[Char]
"Normal")))
   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]
"Ruby",[Char]
"Subst")) 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]
"Ruby",[Char]
"Short Subst") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'40'7b1'2c2'7d 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_'5cw'28'3f'21'5cw'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
>>~ (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]
"Ruby",[Char]
"Short Subst")) 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]
"Ruby",[Char]
"Member Access") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5c'2e'3f'5b'5fa'2dz'5d'5cw'2a'28'5c'3f'7c'5c'21'29'3f'28'3f'3d'5b'5e'5cw'5cd'5c'2e'5c'3a'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
NormalTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2_pop"))
   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'2e'3f'5b'5fa'2dz'5d'5cw'2a'28'5c'3f'7c'5c'21'29'3f 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5bA'2dZ'5d'2b'5f'2a'28'5cd'7c'5ba'2dz'5d'29'5cw'2a'28'3f'3d'5b'5e'5cw'5cd'5c'2e'5c'3a'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
DataTypeTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2_pop"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5bA'2dZ'5d'2b'5f'2a'28'5b0'2d9'5d'7c'5ba'2dz'5d'29'5cw'2a 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5b'5fA'2dZ'5d'5b'5fA'2dZ0'2d9'5d'2a'28'3f'3d'5b'5e'5cw'5cd'5c'2e'5c'3a'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
DataTypeTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"check_div_2_pop"))
   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_'5b'5fA'2dZ'5d'5b'5fA'2dZ0'2d9'5d'2a 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
<|>
   ((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
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
NormalTok))
   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
NormalTok) 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
CommentTok) 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
<|>
   (([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
NormalTok) 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
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cW 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 (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]
"Ruby",[Char]
"Member Access")) 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]
"Ruby",[Char]
"Comment Line") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'5cw'5c'3a'5c'3a'5cs 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]
"Ruby",[Char]
"RDoc Label"))
   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 (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]
"Ruby",[Char]
"Comment Line")) 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]
"Ruby",[Char]
"General 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]
"Ruby",[Char]
"General 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]
"Ruby",[Char]
"RDoc Label") =
  (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]
"Ruby",[Char]
"RDoc Label")) 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]
"Ruby",[Char]
"find_heredoc") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'27'28'5cw'2b'29'27 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]
"Ruby",[Char]
"apostrophed_normal_heredoc"))
   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_'22'3f'28'5cw'2b'29'22'3f 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]
"Ruby",[Char]
"normal_heredoc"))
   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]
"Ruby",[Char]
"find_heredoc")) 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]
"Ruby",[Char]
"find_indented_heredoc") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'27'28'5cw'2b'29'27 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]
"Ruby",[Char]
"apostrophed_indented_heredoc"))
   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_'22'3f'28'5cw'2b'29'22'3f 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]
"Ruby",[Char]
"indented_heredoc"))
   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]
"Ruby",[Char]
"find_indented_heredoc")) 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]
"Ruby",[Char]
"indented_heredoc") =
  (((ParsecT [Char] SyntaxState Identity ()
pFirstNonSpace forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> KateParser [Char]
pRegExprDynamic [Char]
"%1$" 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 (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
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"heredoc_rules")))
   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]
"Ruby",[Char]
"indented_heredoc")) 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]
"Ruby",[Char]
"apostrophed_indented_heredoc") =
  (((ParsecT [Char] SyntaxState Identity ()
pFirstNonSpace forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> KateParser [Char]
pRegExprDynamic [Char]
"%1$" 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 (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]
"Ruby",[Char]
"apostrophed_indented_heredoc")) 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]
"Ruby",[Char]
"normal_heredoc") =
  (((forall tok st. Int -> GenParser tok st ()
pColumn Int
0 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> KateParser [Char]
pRegExprDynamic [Char]
"%1$" 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 (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
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"heredoc_rules")))
   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]
"Ruby",[Char]
"normal_heredoc")) 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]
"Ruby",[Char]
"apostrophed_normal_heredoc") =
  (((forall tok st. Int -> GenParser tok st ()
pColumn Int
0 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> KateParser [Char]
pRegExprDynamic [Char]
"%1$" 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 (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]
"Ruby",[Char]
"apostrophed_normal_heredoc")) 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]
"Ruby",[Char]
"heredoc_rules") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_'23'40'7b1'2c2'7d 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]
"Ruby",[Char]
"Short Subst"))
   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]
"Ruby",[Char]
"Subst"))
   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]
"Ruby",[Char]
"heredoc_rules")) 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]
"Ruby",[Char]
"find_gdl_input") =
  (((Regex -> KateParser [Char]
pRegExpr Regex
regex_w'5c'28 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]
"Ruby",[Char]
"gdl_token_array_1"))
   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_w'5c'7b 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]
"Ruby",[Char]
"gdl_token_array_2"))
   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_w'5c'5b 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]
"Ruby",[Char]
"gdl_token_array_3"))
   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_w'3c 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]
"Ruby",[Char]
"gdl_token_array_4"))
   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_w'28'5b'5e'5cs'5cw'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]
"Ruby",[Char]
"gdl_token_array_5"))
   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_W'5c'28 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]
"Ruby",[Char]
"gdl_token_array_1"))
   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_W'5c'7b 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]
"Ruby",[Char]
"gdl_token_array_2"))
   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_W'5c'5b 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]
"Ruby",[Char]
"gdl_token_array_3"))
   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_W'3c 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]
"Ruby",[Char]
"gdl_token_array_4"))
   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_W'28'5b'5e'5cs'5cw'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]
"Ruby",[Char]
"gdl_token_array_5"))
   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_q'5c'28 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]
"Ruby",[Char]
"gdl_apostrophed_1"))
   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_q'5c'7b 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]
"Ruby",[Char]
"gdl_apostrophed_2"))
   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_q'5c'5b 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]
"Ruby",[Char]
"gdl_apostrophed_3"))
   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_q'3c 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]
"Ruby",[Char]
"gdl_apostrophed_4"))
   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_q'28'5b'5e'5cs'5cw'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]
"Ruby",[Char]
"gdl_apostrophed_5"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_x'5c'28 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]
"Ruby",[Char]
"gdl_shell_command_1"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_x'5c'7b 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]
"Ruby",[Char]
"gdl_shell_command_2"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_x'5c'5b 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]
"Ruby",[Char]
"gdl_shell_command_3"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_x'3c 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]
"Ruby",[Char]
"gdl_shell_command_4"))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> KateParser [Char]
pRegExpr Regex
regex_x'28'5b'5e'5cs'5cw'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]
"Ruby",[Char]
"gdl_shell_command_5"))
   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_r'5c'28 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]
"Ruby",[Char]
"gdl_regexpr_1"))
   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_r'5c'7b 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]
"Ruby",[Char]
"gdl_regexpr_2"))
   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_r'5c'5b 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]
"Ruby",[Char]
"gdl_regexpr_3"))
   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_r'3c 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]
"Ruby",[Char]
"gdl_regexpr_4"))
   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_r'28'5b'5e'5cs'5cw'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]
"Ruby",[Char]
"gdl_regexpr_5"))
   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_Q'3f'5c'28 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]
"Ruby",[Char]
"gdl_dq_string_1"))
   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_Q'3f'5c'7b 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]
"Ruby",[Char]
"gdl_dq_string_2"))
   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_Q'3f'5c'5b 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]
"Ruby",[Char]
"gdl_dq_string_3"))
   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_Q'3f'3c 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]
"Ruby",[Char]
"gdl_dq_string_4"))
   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_Q'3f'28'5b'5e'5cs'5cw'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]
"Ruby",[Char]
"gdl_dq_string_5"))
   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]
"Ruby",[Char]
"find_gdl_input")) 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]
"Ruby",[Char]
"gdl_dq_string_1") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"dq_string_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_dq_string_1_nested"))
   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]
"Ruby",[Char]
"gdl_dq_string_1")) 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]
"Ruby",[Char]
"gdl_dq_string_1_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"dq_string_rules")))
   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]
"Ruby",[Char]
"gdl_dq_string_1_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_dq_string_1_nested")) 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]
"Ruby",[Char]
"gdl_dq_string_2") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"dq_string_rules")))
   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
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
>>~ (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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_dq_string_2_nested"))
   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]
"Ruby",[Char]
"gdl_dq_string_2")) 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]
"Ruby",[Char]
"gdl_dq_string_2_nested") =
  (((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]
"Ruby",[Char]
"gdl_dq_string_2_nested"))
   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
>>~ (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
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"dq_string_rules")))
   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]
"Ruby",[Char]
"gdl_dq_string_2_nested")) 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]
"Ruby",[Char]
"gdl_dq_string_3") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"dq_string_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_dq_string_3_nested"))
   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]
"Ruby",[Char]
"gdl_dq_string_3")) 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]
"Ruby",[Char]
"gdl_dq_string_3_nested") =
  (((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]
"Ruby",[Char]
"gdl_dq_string_3_nested"))
   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
>>~ (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
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"dq_string_rules")))
   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]
"Ruby",[Char]
"gdl_dq_string_3_nested")) 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]
"Ruby",[Char]
"gdl_dq_string_4") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"dq_string_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_dq_string_4_nested"))
   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]
"Ruby",[Char]
"gdl_dq_string_4")) 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]
"Ruby",[Char]
"gdl_dq_string_4_nested") =
  (((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]
"Ruby",[Char]
"gdl_dq_string_4_nested"))
   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
>>~ (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
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"dq_string_rules")))
   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]
"Ruby",[Char]
"gdl_dq_string_4_nested")) 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]
"Ruby",[Char]
"gdl_dq_string_5") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"dq_string_rules")))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> KateParser [Char]
pRegExprDynamic [Char]
"\\\\%1" 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
<|>
   (([Char] -> KateParser [Char]
pRegExprDynamic [Char]
"\\s*%1" 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]
"Ruby",[Char]
"gdl_dq_string_5")) 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]
"Ruby",[Char]
"dq_string_rules") =
  (((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
StringTok))
   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'40'7b1'2c2'7d 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]
"Ruby",[Char]
"Short Subst"))
   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]
"Ruby",[Char]
"Subst"))
   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]
"Ruby",[Char]
"dq_string_rules")) 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]
"Ruby",[Char]
"gdl_token_array_1") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"token_array_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_token_array_1_nested"))
   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]
"Ruby",[Char]
"gdl_token_array_1")) 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]
"Ruby",[Char]
"gdl_token_array_1_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"token_array_rules")))
   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]
"Ruby",[Char]
"gdl_token_array_1_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_token_array_1_nested")) 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]
"Ruby",[Char]
"gdl_token_array_2") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"token_array_rules")))
   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
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
>>~ (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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_token_array_2_nested"))
   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]
"Ruby",[Char]
"gdl_token_array_2")) 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]
"Ruby",[Char]
"gdl_token_array_2_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"token_array_rules")))
   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]
"Ruby",[Char]
"gdl_token_array_2_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_token_array_2_nested")) 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]
"Ruby",[Char]
"gdl_token_array_3") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"token_array_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_token_array_3_nested"))
   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]
"Ruby",[Char]
"gdl_token_array_3")) 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]
"Ruby",[Char]
"gdl_token_array_3_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"token_array_rules")))
   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]
"Ruby",[Char]
"gdl_token_array_3_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_token_array_3_nested")) 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]
"Ruby",[Char]
"gdl_token_array_4") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"token_array_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_token_array_4_nested"))
   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]
"Ruby",[Char]
"gdl_token_array_4")) 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]
"Ruby",[Char]
"gdl_token_array_4_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"token_array_rules")))
   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]
"Ruby",[Char]
"gdl_token_array_4_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_token_array_4_nested")) 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]
"Ruby",[Char]
"gdl_token_array_5") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"token_array_rules")))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> KateParser [Char]
pRegExprDynamic [Char]
"\\\\%1" 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
<|>
   (([Char] -> KateParser [Char]
pRegExprDynamic [Char]
"\\s*%1" 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]
"Ruby",[Char]
"gdl_token_array_5")) 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]
"Ruby",[Char]
"token_array_rules") =
  (((Bool -> [Char] -> KateParser [Char]
pString 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 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]
"Ruby",[Char]
"token_array_rules")) 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]
"Ruby",[Char]
"gdl_apostrophed_1") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"apostrophed_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_apostrophed_1_nested"))
   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]
"Ruby",[Char]
"gdl_apostrophed_1")) 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]
"Ruby",[Char]
"gdl_apostrophed_1_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"apostrophed_rules")))
   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]
"Ruby",[Char]
"gdl_apostrophed_1_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_apostrophed_1_nested")) 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]
"Ruby",[Char]
"gdl_apostrophed_2") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"apostrophed_rules")))
   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
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
>>~ (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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_apostrophed_2_nested"))
   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]
"Ruby",[Char]
"gdl_apostrophed_2")) 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]
"Ruby",[Char]
"gdl_apostrophed_2_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"apostrophed_rules")))
   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]
"Ruby",[Char]
"gdl_apostrophed_2_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_apostrophed_2_nested")) 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]
"Ruby",[Char]
"gdl_apostrophed_3") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"apostrophed_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_apostrophed_3_nested"))
   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]
"Ruby",[Char]
"gdl_apostrophed_3")) 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]
"Ruby",[Char]
"gdl_apostrophed_3_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"apostrophed_rules")))
   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]
"Ruby",[Char]
"gdl_apostrophed_3_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_apostrophed_3_nested")) 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]
"Ruby",[Char]
"gdl_apostrophed_4") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"apostrophed_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_apostrophed_4_nested"))
   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]
"Ruby",[Char]
"gdl_apostrophed_4")) 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]
"Ruby",[Char]
"gdl_apostrophed_4_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"apostrophed_rules")))
   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]
"Ruby",[Char]
"gdl_apostrophed_4_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_apostrophed_4_nested")) 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]
"Ruby",[Char]
"gdl_apostrophed_5") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"apostrophed_rules")))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> KateParser [Char]
pRegExprDynamic [Char]
"\\\\%1" 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
<|>
   (([Char] -> KateParser [Char]
pRegExprDynamic [Char]
"\\s*%1" 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]
"Ruby",[Char]
"gdl_apostrophed_5")) 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]
"Ruby",[Char]
"apostrophed_rules") =
  (((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
StringTok))
   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]
"Ruby",[Char]
"apostrophed_rules")) 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]
"Ruby",[Char]
"gdl_shell_command_1") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"shell_command_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_shell_command_1_nested"))
   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]
"Ruby",[Char]
"gdl_shell_command_1")) 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]
"Ruby",[Char]
"gdl_shell_command_1_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"shell_command_rules")))
   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]
"Ruby",[Char]
"gdl_shell_command_1_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_shell_command_1_nested")) 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]
"Ruby",[Char]
"gdl_shell_command_2") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"shell_command_rules")))
   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
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
>>~ (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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_shell_command_2_nested"))
   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]
"Ruby",[Char]
"gdl_shell_command_2")) 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]
"Ruby",[Char]
"gdl_shell_command_2_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"shell_command_rules")))
   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]
"Ruby",[Char]
"gdl_shell_command_2_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_shell_command_2_nested")) 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]
"Ruby",[Char]
"gdl_shell_command_3") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"shell_command_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_shell_command_3_nested"))
   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]
"Ruby",[Char]
"gdl_shell_command_3")) 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]
"Ruby",[Char]
"gdl_shell_command_3_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"shell_command_rules")))
   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]
"Ruby",[Char]
"gdl_shell_command_3_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_shell_command_3_nested")) 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]
"Ruby",[Char]
"gdl_shell_command_4") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"shell_command_rules")))
   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
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
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_shell_command_4_nested"))
   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]
"Ruby",[Char]
"gdl_shell_command_4")) 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]
"Ruby",[Char]
"gdl_shell_command_4_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"shell_command_rules")))
   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]
"Ruby",[Char]
"gdl_shell_command_4_nested"))
   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
>>~ (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]
"Ruby",[Char]
"gdl_shell_command_4_nested")) 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]
"Ruby",[Char]
"gdl_shell_command_5") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"shell_command_rules")))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> KateParser [Char]
pRegExprDynamic [Char]
"\\\\%1" 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
<|>
   (([Char] -> KateParser [Char]
pRegExprDynamic [Char]
"\\s*%1" 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]
"Ruby",[Char]
"gdl_shell_command_5")) 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]
"Ruby",[Char]
"shell_command_rules") =
  (((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
StringTok))
   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'40'7b1'2c2'7d 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]
"Ruby",[Char]
"Short Subst"))
   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]
"Ruby",[Char]
"Subst"))
   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]
"Ruby",[Char]
"shell_command_rules")) 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]
"Ruby",[Char]
"gdl_regexpr_1") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"regexpr_rules")))
   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 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]
"Ruby",[Char]
"gdl_regexpr_1_nested"))
   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'29'5buiomxn'5d'2a 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]
"Ruby",[Char]
"gdl_regexpr_1")) 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]
"Ruby",[Char]
"gdl_regexpr_1_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"regexpr_rules")))
   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]
"Ruby",[Char]
"gdl_regexpr_1_nested"))
   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 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]
"Ruby",[Char]
"gdl_regexpr_1_nested")) 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]
"Ruby",[Char]
"gdl_regexpr_2") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"regexpr_rules")))
   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 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'7d'5buiomxn'5d'2a 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 (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Ruby",[Char]
"gdl_regexpr_2_nested"))
   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]
"Ruby",[Char]
"gdl_regexpr_2")) 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]
"Ruby",[Char]
"gdl_regexpr_2_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"regexpr_rules")))
   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]
"Ruby",[Char]
"gdl_regexpr_2_nested"))
   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 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]
"Ruby",[Char]
"gdl_regexpr_2_nested")) 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]
"Ruby",[Char]
"gdl_regexpr_3") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"regexpr_rules")))
   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 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]
"Ruby",[Char]
"gdl_regexpr_3_nested"))
   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'5d'5buiomxn'5d'2a 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]
"Ruby",[Char]
"gdl_regexpr_3")) 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]
"Ruby",[Char]
"gdl_regexpr_3_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"regexpr_rules")))
   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]
"Ruby",[Char]
"gdl_regexpr_3_nested"))
   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 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]
"Ruby",[Char]
"gdl_regexpr_3_nested")) 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]
"Ruby",[Char]
"gdl_regexpr_4") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"regexpr_rules")))
   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 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]
"Ruby",[Char]
"gdl_regexpr_4_nested"))
   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_'3e'5buiomxn'5d'2a 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]
"Ruby",[Char]
"gdl_regexpr_4")) 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]
"Ruby",[Char]
"gdl_regexpr_4_nested") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"regexpr_rules")))
   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]
"Ruby",[Char]
"gdl_regexpr_4_nested"))
   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 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]
"Ruby",[Char]
"gdl_regexpr_4_nested")) 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]
"Ruby",[Char]
"gdl_regexpr_5") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Ruby",[Char]
"regexpr_rules")))
   forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> KateParser [Char]
pRegExprDynamic [Char]
"\\\\%1" 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
<|>
   (([Char] -> KateParser [Char]
pRegExprDynamic [Char]
"\\s*%1[uiomxn]*" 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]
"Ruby",[Char]
"gdl_regexpr_5")) 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]
"Ruby",[Char]
"regexpr_rules") =
  (((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 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'40'7b1'2c2'7d 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]
"Ruby",[Char]
"Short Subst"))
   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]
"Ruby",[Char]
"Subst"))
   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]
"Ruby",[Char]
"regexpr_rules")) 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]
"Ruby",[Char]
"DATA") =
  (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]
"Ruby",[Char]
"DATA")) 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]
"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]
"Ruby",[Char]
"Normal") 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)