module Text.Highlighting.Kate.Syntax.Prolog
(highlight, parseExpression, syntaxName, syntaxExtensions)
where
import Text.Highlighting.Kate.Types
import Text.Highlighting.Kate.Common
import qualified Text.Highlighting.Kate.Syntax.Alert_indent
import Text.ParserCombinators.Parsec hiding (State)
import Control.Monad.State
import Data.Char (isSpace)
import qualified Data.Set as Set
syntaxName :: String
syntaxName :: [Char]
syntaxName = [Char]
"Prolog"
syntaxExtensions :: String
syntaxExtensions :: [Char]
syntaxExtensions = [Char]
"*.prolog;*.dcg;*.pro"
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)
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]
"Prolog",[Char]
"shebang")], 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]
"Prolog",[Char]
"shebang") -> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"clause") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"syntax_error") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"clause") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"term") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"nested") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"list") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"curly") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"arith_expr") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"nested_expr") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"list_functor") -> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"syntax_error") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"sq") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"dq") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"bq") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"single-quoted") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"double-quoted") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"back-quoted") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"syntax_error_sq") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"syntax_error_dq") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"syntax_error_bq") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"char_code") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Prolog",[Char]
"syntax_error_cc") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"esc_seq_q") -> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"syntax_error") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"esc_seq_cc") -> (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]
"Prolog",[Char]
"esc_seq_q2") -> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"syntax_error") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"id") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"var") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"graphic") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Prolog",[Char]
"bin") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Prolog",[Char]
"oct") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Prolog",[Char]
"hex") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Prolog",[Char]
"comment-iso") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"1-comment") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Prolog",[Char]
"region_marker") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Prolog",[Char]
"layout_fold") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"quoted_1st") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"quoted_last") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"layout") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"atomic") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"arith_expr_common") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Prolog",[Char]
"number") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Prolog",[Char]
"operator") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([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_error_term_ISO :: Set [Char]
list_error_term_ISO = 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]
"error"
list_guru_meditation_terms_ISO :: Set [Char]
list_guru_meditation_terms_ISO = 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]
"instantiation_error uninstantiation_error type_error domain_error existence_error permission_error representation_error evaluation_error resource_error syntax_error system_error"
list_bogus_ISO :: Set [Char]
list_bogus_ISO = 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]
"char_conversion current_char_conversion include ensure_loaded atan xor"
list_directives_non'2dISO :: Set [Char]
list_directives_non'2dISO = 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]
"consult built_in"
list_logic'2bcontrol_ISO :: Set [Char]
list_logic'2bcontrol_ISO = 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]
"initialization fail repeat call catch throw true false once"
list_dyn_clause_mgmt_ISO :: Set [Char]
list_dyn_clause_mgmt_ISO = 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]
"dynamic asserta assertz retractall retract abolish clause"
list_listing_non'2dISO :: Set [Char]
list_listing_non'2dISO = 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]
"listing"
list_terms_ISO :: Set [Char]
list_terms_ISO = 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]
"atom_concat atom_length atom_chars atom_codes arg subsumes_term acyclic_term char_code compare copy_term functor number_chars number_codes term_variables unify_with_occurs_check"
list_terms_non'2dISO :: Set [Char]
list_terms_non'2dISO = 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]
"number_atom expand_term term_expansion display print format portray_clause portray term_expansion"
list_DCG_non'2dISO :: Set [Char]
list_DCG_non'2dISO = 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]
"phrase"
list_lists_ISO :: Set [Char]
list_lists_ISO = 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]
"sort keysort"
list_lists_non'2dISO :: Set [Char]
list_lists_non'2dISO = 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]
"append delete length last map_list min_list maplist msort memberchk member nth permutation reverse select prefix suffix sublist sum_list"
list_streams_ISO :: Set [Char]
list_streams_ISO = 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]
"open set_stream_position get_char get_code peek_char peek_code get_byte peek_byte put_char put_code put_byte nl read_term read write_canonical writeq write"
list_streams_deprecated :: Set [Char]
list_streams_deprecated = 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]
"append seeing seen see telling tell told get0 get skip put tab"
list_arith_eval_ISO :: Set [Char]
list_arith_eval_ISO = 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]
"is"
list_arith_ops_int_ISO :: Set [Char]
list_arith_ops_int_ISO = 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]
"rem mod div"
list_arith_expr_mixed_ISO :: Set [Char]
list_arith_expr_mixed_ISO = 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]
"abs sign min max"
list_arith_expr_int_ISO :: Set [Char]
list_arith_expr_int_ISO = 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]
"ceiling floor round truncate"
list_arith_expr_float_ISO :: Set [Char]
list_arith_expr_float_ISO = 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]
"pi sqrt tan cos sin atan2 acos asin exp log float float_fractional_part float_integer_part"
list_prolog_state_ISO :: Set [Char]
list_prolog_state_ISO = 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]
"multifile discontigous op set_prolog_flag"
list_types_ISO :: Set [Char]
list_types_ISO = 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]
"var nonvar atom integer float number atomic compound callable ground"
list_list'2bis'5flist_non'2dISO :: Set [Char]
list_list'2bis'5flist_non'2dISO = 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]
"list is_list"
list_built'2dins_ISO :: Set [Char]
list_built'2dins_ISO = 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]
"current_op current_prolog_flag current_input current_output set_input set_output close flush_output at_end_of_stream stream_property"
regex_'2e :: Regex
regex_'2e = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"."
regex_'5c'2e'28'3f'21'28'5c'28'7c'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29'29 :: Regex
regex_'5c'2e'28'3f'21'28'5c'28'7c'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\.(?!(\\(|[#$&*+\\-./:<=>?@^~\\\\]))"
regex_'28'3b'7c'2d'3e'7c'5c'5c'5c'2b'7c'3a'2d'7c'3d'7c'5c'5c'3d'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 :: Regex
regex_'28'3b'7c'2d'3e'7c'5c'5c'5c'2b'7c'3a'2d'7c'3d'7c'5c'5c'3d'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(;|->|\\\\\\+|:-|=|\\\\=)(?![#$&*+\\-./:<=>?@^~\\\\])"
regex_'28'27'27'7c'5c'5c'5b0'2d7'5d'2b'5c'5c'7c'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c'7c'5c'5c'2e'7c'5b'5e'27'5c'5c'5d'2b'29'24 :: Regex
regex_'28'27'27'7c'5c'5c'5b0'2d7'5d'2b'5c'5c'7c'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c'7c'5c'5c'2e'7c'5b'5e'27'5c'5c'5d'2b'29'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(''|\\\\[0-7]+\\\\|\\\\x[a-fA-F0-9]+\\\\|\\\\.|[^'\\\\]+)$"
regex_'28'22'22'7c'5c'5c'5b0'2d7'5d'2b'5c'5c'7c'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c'7c'5c'5c'2e'7c'5b'5e'22'5c'5c'5d'2b'29'24 :: Regex
regex_'28'22'22'7c'5c'5c'5b0'2d7'5d'2b'5c'5c'7c'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c'7c'5c'5c'2e'7c'5b'5e'22'5c'5c'5d'2b'29'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(\"\"|\\\\[0-7]+\\\\|\\\\x[a-fA-F0-9]+\\\\|\\\\.|[^\"\\\\]+)$"
regex_'28'60'60'7c'5c'5c'5b0'2d7'5d'2b'5c'5c'7c'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c'7c'5c'5c'2e'7c'5b'5e'60'5c'5c'5d'2b'29'24 :: Regex
regex_'28'60'60'7c'5c'5c'5b0'2d7'5d'2b'5c'5c'7c'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c'7c'5c'5c'2e'7c'5b'5e'60'5c'5c'5d'2b'29'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(``|\\\\[0-7]+\\\\|\\\\x[a-fA-F0-9]+\\\\|\\\\.|[^`\\\\]+)$"
regex_'27'24 :: Regex
regex_'27'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"'$"
regex_'22'24 :: Regex
regex_'22'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\"$"
regex_'60'24 :: Regex
regex_'60'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"`$"
regex_'5c'5c'5b0'2d7'5d'2b'5c'5c :: Regex
regex_'5c'5c'5b0'2d7'5d'2b'5c'5c = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\\\[0-7]+\\\\"
regex_'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c :: Regex
regex_'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\\\x[a-fA-F0-9]+\\\\"
regex_'28'3d'3a'3d'7c'3d'5c'5c'3d'7c'3d'3c'7c'3c'7c'3e'3d'7c'3e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 :: Regex
regex_'28'3d'3a'3d'7c'3d'5c'5c'3d'7c'3d'3c'7c'3c'7c'3e'3d'7c'3e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(=:=|=\\\\=|=<|<|>=|>)(?![#$&*+\\-./:<=>?@^~\\\\])"
regex_'28'5c'2b'7c'2d'7c'5c'2a'7c'5c'5e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 :: Regex
regex_'28'5c'2b'7c'2d'7c'5c'2a'7c'5c'5e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(\\+|-|\\*|\\^)(?![#$&*+\\-./:<=>?@^~\\\\])"
regex_'2f'2f'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 :: Regex
regex_'2f'2f'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"//(?![#$&*+\\-./:<=>?@^~\\\\])"
regex_'28'2f'7c'5c'2a'5c'2a'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 :: Regex
regex_'28'2f'7c'5c'2a'5c'2a'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(/|\\*\\*)(?![#$&*+\\-./:<=>?@^~\\\\])"
regex_'28'2f'5c'5c'7c'5c'5c'2f'7c'5c'5c'7c'3c'3c'7c'3e'3e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 :: Regex
regex_'28'2f'5c'5c'7c'5c'5c'2f'7c'5c'5c'7c'3c'3c'7c'3e'3e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(/\\\\|\\\\/|\\\\|<<|>>)(?![#$&*+\\-./:<=>?@^~\\\\])"
regex_0'27'5c'5c'3f'24 :: Regex
regex_0'27'5c'5c'3f'24 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"0'\\\\?$"
regex_'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2bE'5b'2b'5c'2d'5d'3f'5b0'2d9'5d'2b :: Regex
regex_'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2bE'5b'2b'5c'2d'5d'3f'5b0'2d9'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[0-9]+\\.[0-9]+E[+\\-]?[0-9]+"
regex_'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2b :: Regex
regex_'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[0-9]+\\.[0-9]+"
regex_'5b0'2d9'5d'2bE'5b'2b'5c'2d'5d'3f'5b0'2d9'5d'2b :: Regex
regex_'5b0'2d9'5d'2bE'5b'2b'5c'2d'5d'3f'5b0'2d9'5d'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[0-9]+E[+\\-]?[0-9]+"
regex_'28'5c'3f'2d'7c'3d'3d'7c'5c'5c'3d'3d'7c'40'3d'3c'7c'40'3c'7c'40'3e'3d'7c'40'3e'7c'3d'5c'2e'5c'2e'7c'40'7c'3a'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 :: Regex
regex_'28'5c'3f'2d'7c'3d'3d'7c'5c'5c'3d'3d'7c'40'3d'3c'7c'40'3c'7c'40'3e'3d'7c'40'3e'7c'3d'5c'2e'5c'2e'7c'40'7c'3a'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"(\\?-|==|\\\\==|@=<|@<|@>=|@>|=\\.\\.|@|:)(?![#$&*+\\-./:<=>?@^~\\\\])"
regex_'2d'2d'3e'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 :: Regex
regex_'2d'2d'3e'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"-->(?![#$&*+\\-./:<=>?@^~\\\\])"
parseRules :: ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"shebang") =
(((forall tok st. Int -> GenParser tok st ()
pColumn Int
0 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [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
CommentTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"1-comment"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'2e) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"clause") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(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]
"Prolog",[Char]
"shebang")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"syntax_error") =
(((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok) 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 [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
ErrorTok) 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 -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'2e forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok) 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]
"Prolog",[Char]
"syntax_error")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"clause") =
(((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"layout")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5c'2e'28'3f'21'28'5c'28'7c'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29'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
AlertTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'2e) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"term") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(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]
"Prolog",[Char]
"clause")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"term") =
(((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"layout")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'(' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"nested"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'[' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"list"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'{' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"curly"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
',' forall (m :: * -> *) a b. Monad 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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'!' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'|' forall (m :: * -> *) a b. Monad 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 s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'.' Char
'(') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"list_functor") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5c'2e'28'3f'21'28'5c'28'7c'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29'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 (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]
"Prolog",[Char]
"atomic")))
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]
"Prolog",[Char]
"term")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"nested") =
(((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"layout")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
')' forall (m :: * -> *) a b. Monad 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 -> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"nested"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'[' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"list"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'{' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"curly"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'!' forall (m :: * -> *) a b. Monad 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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
',' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'|' forall (m :: * -> *) a b. Monad 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 s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'.' Char
'(') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"list_functor") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5c'2e'28'3f'21'28'5c'28'7c'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29'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
AlertTok))
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]
"Prolog",[Char]
"atomic")))
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]
"Prolog",[Char]
"nested")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"list") =
(((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"layout")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'(' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"nested"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
']' forall (m :: * -> *) a b. Monad 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 -> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"list"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'{' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"curly"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
',' forall (m :: * -> *) a b. Monad 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 -> ParsecT [Char] SyntaxState Identity [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 -> ParsecT [Char] SyntaxState Identity [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
FunctionTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'.' Char
'(') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"list_functor") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"atomic")))
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]
"Prolog",[Char]
"list")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"curly") =
(((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"layout")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'(' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"nested"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'[' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"list"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'}' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'{' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"curly"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
',' forall (m :: * -> *) a b. Monad 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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'!' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'|' forall (m :: * -> *) a b. Monad 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 s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'.' Char
'(') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"list_functor") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"atomic")))
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]
"Prolog",[Char]
"curly")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"arith_expr") =
(((Bool -> Char -> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"nested_expr"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
')') 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))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'}') 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))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
']') 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))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'!') 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))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
',') 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))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'|') 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))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5c'2e'28'3f'21'28'5c'28'7c'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29'29) 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))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'3b'7c'2d'3e'7c'5c'5c'5c'2b'7c'3a'2d'7c'3d'7c'5c'5c'3d'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29) 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))
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]
"Prolog",[Char]
"arith_expr_common")))
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]
"Prolog",[Char]
"arith_expr")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"nested_expr") =
(((Bool -> Char -> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"nested_expr"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
')' forall (m :: * -> *) a b. Monad 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 -> ParsecT [Char] SyntaxState Identity [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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
',' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [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
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'3b'7c'2d'3e'7c'5c'5c'5c'2b'7c'3a'2d'7c'3d'7c'5c'5c'3d'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
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]
"Prolog",[Char]
"arith_expr_common")))
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]
"Prolog",[Char]
"nested_expr")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"list_functor") =
(((Bool -> Char -> ParsecT [Char] SyntaxState Identity [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
FunctionTok) 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]
"Prolog",[Char]
"list_functor")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"sq") =
(((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"quoted_1st")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'27'27'7c'5c'5c'5b0'2d7'5d'2b'5c'5c'7c'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c'7c'5c'5c'2e'7c'5b'5e'27'5c'5c'5d'2b'29'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
ErrorTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"syntax_error_sq"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'\'' Char
'\'' forall (m :: * -> *) a b. Monad 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 s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'\'' forall (m :: * -> *) a b. Monad 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
<|>
((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"quoted_last")))
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]
"Prolog",[Char]
"sq")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"dq") =
(((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"quoted_1st")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'22'22'7c'5c'5c'5b0'2d7'5d'2b'5c'5c'7c'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c'7c'5c'5c'2e'7c'5b'5e'22'5c'5c'5d'2b'29'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
ErrorTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"syntax_error_dq"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'"' Char
'"' forall (m :: * -> *) a b. Monad 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 s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'"' forall (m :: * -> *) a b. Monad 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
<|>
((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"quoted_last")))
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]
"Prolog",[Char]
"dq")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"bq") =
(((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"quoted_1st")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'60'60'7c'5c'5c'5b0'2d7'5d'2b'5c'5c'7c'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c'7c'5c'5c'2e'7c'5b'5e'60'5c'5c'5d'2b'29'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
ErrorTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"syntax_error_bq"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'`' Char
'`' forall (m :: * -> *) a b. Monad 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 s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'`' forall (m :: * -> *) a b. Monad 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 (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]
"Prolog",[Char]
"quoted_last")))
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]
"Prolog",[Char]
"bq")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"single-quoted") =
(((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'27'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
ErrorTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"sq"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'\'' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"sq"))
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]
"Prolog",[Char]
"single-quoted")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"double-quoted") =
(((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'22'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
ErrorTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"dq"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'"' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"dq"))
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]
"Prolog",[Char]
"double-quoted")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"back-quoted") =
(((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'60'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
ErrorTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"bq"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'`' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"bq"))
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]
"Prolog",[Char]
"back-quoted")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"syntax_error_sq") =
(((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [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
ErrorTok) 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 -> Char -> ParsecT [Char] SyntaxState Identity [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
ErrorTok) 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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'\'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok) forall (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
<|>
((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"syntax_error")))
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]
"Prolog",[Char]
"syntax_error_sq")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"syntax_error_dq") =
(((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [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
ErrorTok) 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 -> Char -> ParsecT [Char] SyntaxState Identity [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
ErrorTok) 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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'"' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok) forall (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
<|>
((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"syntax_error")))
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]
"Prolog",[Char]
"syntax_error_dq")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"syntax_error_bq") =
(((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [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
ErrorTok) 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 -> Char -> ParsecT [Char] SyntaxState Identity [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
ErrorTok) 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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'`' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok) forall (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
<|>
((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"syntax_error")))
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]
"Prolog",[Char]
"syntax_error_bq")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"char_code") =
(((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [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
CharTok) 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 -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'\'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok) forall (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 -> ParsecT [Char] SyntaxState Identity [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
CharTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"esc_seq_cc"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
' ' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
AlertTok) 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 -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'2e forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
BaseNTok) 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]
"Prolog",[Char]
"char_code")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"syntax_error_cc") =
(((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok) 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]
"Prolog",[Char]
"esc_seq_q") =
(((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5c'5c'5b0'2d7'5d'2b'5c'5c forall (m :: * -> *) a b. Monad 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
>>~ (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 -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5c'5cx'5ba'2dfA'2dF0'2d9'5d'2b'5c'5c forall (m :: * -> *) a b. Monad 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
>>~ (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 -> ParsecT [Char] SyntaxState Identity [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
CharTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"esc_seq_q2"))
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]
"Prolog",[Char]
"esc_seq_q")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"esc_seq_cc") =
(((Bool -> Char -> ParsecT [Char] SyntaxState Identity [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
AlertTok) 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] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"abfnrtv\\'`\"]" forall (m :: * -> *) a b. Monad 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
>>~ (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
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
parseRules ([Char]
"Prolog",[Char]
"esc_seq_q2") =
(((Bool -> Char -> ParsecT [Char] SyntaxState Identity [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
AlertTok) 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] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"abfnrtv\\'`\"]" forall (m :: * -> *) a b. Monad 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
>>~ (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]
"Prolog",[Char]
"id") =
(((ParsecT [Char] SyntaxState Identity [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
>>~ (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]
"Prolog",[Char]
"id")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"var") =
(((ParsecT [Char] SyntaxState Identity [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
DataTypeTok) 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]
"Prolog",[Char]
"var")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"graphic") =
((([Char] -> ParsecT [Char] SyntaxState Identity [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 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]
"Prolog",[Char]
"bin") =
((([Char] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"01" forall (m :: * -> *) a b. Monad 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 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]
"Prolog",[Char]
"oct") =
((([Char] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"01234567" forall (m :: * -> *) a b. Monad 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 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]
"Prolog",[Char]
"hex") =
((([Char] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"0123456789abcdefABCDEF" forall (m :: * -> *) a b. Monad 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 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]
"Prolog",[Char]
"comment-iso") =
(((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [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
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
<|>
((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok))
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_indent.parseExpression (forall a. a -> Maybe a
Just ([Char]
"Alerts_indent",[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
<|>
((ParsecT [Char] SyntaxState Identity [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
CommentTok))
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]
"Prolog",[Char]
"comment-iso")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"1-comment") =
(((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok))
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_indent.parseExpression (forall a. a -> Maybe a
Just ([Char]
"Alerts_indent",[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
<|>
((ParsecT [Char] SyntaxState Identity [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
CommentTok))
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]
"Prolog",[Char]
"1-comment")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"region_marker") =
(((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"1-comment")))
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]
"Prolog",[Char]
"region_marker")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
RegionMarkerTok))
parseRules ([Char]
"Prolog",[Char]
"layout_fold") =
(((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((ParsecT [Char] SyntaxState Identity ()
pFirstNonSpace forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Bool -> [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pString Bool
False [Char]
"%BEGIN" forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
RegionMarkerTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"region_marker"))
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
>> Bool -> [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pString Bool
False [Char]
"%END" forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
RegionMarkerTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"region_marker"))
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
>> Bool -> Char -> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"1-comment"))
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]
"Prolog",[Char]
"quoted_1st") =
(((ParsecT [Char] SyntaxState Identity [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
CharTok))
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
>> ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CharTok))
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]
"Prolog",[Char]
"quoted_1st")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"quoted_last") =
(((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'\\') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"esc_seq_q") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [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
AlertTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((ParsecT [Char] SyntaxState Identity [Char]
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
ErrorTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"Prolog",[Char]
"quoted_last")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"layout") =
(((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [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
CommentTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"comment-iso"))
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
>> Bool -> [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pString Bool
False [Char]
"%BEGIN" forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
RegionMarkerTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"region_marker"))
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
>> Bool -> [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pString Bool
False [Char]
"%END" forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
RegionMarkerTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"region_marker"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((ParsecT [Char] SyntaxState Identity ()
pFirstNonSpace forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'%') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"layout_fold") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> ParsecT [Char] SyntaxState Identity [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]
"Prolog",[Char]
"1-comment"))
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]
"Prolog",[Char]
"layout")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"atomic") =
((([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_logic'2bcontrol_ISO forall (m :: * -> *) a b. Monad 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] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_types_ISO forall (m :: * -> *) a b. Monad 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
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_dyn_clause_mgmt_ISO forall (m :: * -> *) a b. Monad 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] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_streams_ISO forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_terms_ISO forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_prolog_state_ISO forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_DCG_non'2dISO forall (m :: * -> *) a b. Monad 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] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_arith_eval_ISO forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"arith_expr"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_built'2dins_ISO forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_error_term_ISO forall (m :: * -> *) a b. Monad 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] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_guru_meditation_terms_ISO forall (m :: * -> *) a b. Monad 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] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_bogus_ISO forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
AlertTok))
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]
"Prolog",[Char]
"number")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'\'') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"single-quoted") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'`') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"back-quoted") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'"') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"double-quoted") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"operator")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead ([Char] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"abcdefghijklmnopqrstuvwxyz") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"id") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead ([Char] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"ABCDEFGHIJKLMNOPQRSTUVWXYZ_") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"var") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> ParsecT [Char] SyntaxState Identity [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
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"graphic"))
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]
"Prolog",[Char]
"atomic")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"arith_expr_common") =
(((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"layout")))
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]
"Prolog",[Char]
"number")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_arith_eval_ISO forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok) forall (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] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_bogus_ISO forall (m :: * -> *) a b. Monad 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] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_arith_expr_mixed_ISO forall (m :: * -> *) a b. Monad 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
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_arith_expr_int_ISO forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_arith_expr_float_ISO forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FloatTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_arith_ops_int_ISO forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'3d'3a'3d'7c'3d'5c'5c'3d'7c'3d'3c'7c'3c'7c'3e'3d'7c'3e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok) 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 -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'5c'2b'7c'2d'7c'5c'2a'7c'5c'5e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'2f'2f'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'2f'7c'5c'2a'5c'2a'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FloatTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'2f'5c'5c'7c'5c'5c'2f'7c'5c'5c'7c'3c'3c'7c'3e'3e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
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]
"Prolog",[Char]
"operator")))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead ([Char] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"abcdefghijklmnopqrstuvwxyz") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"id") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead ([Char] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"ABCDEFGHIJKLMNOPQRSTUVWXYZ_") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"var") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> ParsecT [Char] SyntaxState Identity [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
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"graphic"))
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]
"Prolog",[Char]
"arith_expr_common")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"number") =
(((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_0'27'5c'5c'3f'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
ErrorTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"syntax_error_cc"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'0' 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
BaseNTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"char_code"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'0' Char
'b' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"bin"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'0' Char
'o' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"oct"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'0' Char
'x' forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"hex"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2bE'5b'2b'5c'2d'5d'3f'5b0'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
FloatTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5b0'2d9'5d'2b'5c'2e'5b0'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
FloatTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5b0'2d9'5d'2bE'5b'2b'5c'2d'5d'3f'5b0'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
FloatTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((ParsecT [Char] SyntaxState Identity [Char]
pInt forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(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]
"Prolog",[Char]
"number")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Prolog",[Char]
"operator") =
((([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_arith_eval_ISO forall (m :: * -> *) a b. Monad 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]
"Prolog",[Char]
"arith_expr"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\$#'\"`" Set [Char]
list_arith_ops_int_ISO forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'3b'7c'2d'3e'7c'5c'5c'5c'2b'7c'3a'2d'7c'3d'7c'5c'5c'3d'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'5c'3f'2d'7c'3d'3d'7c'5c'5c'3d'3d'7c'40'3d'3c'7c'40'3c'7c'40'3e'3d'7c'40'3e'7c'3d'5c'2e'5c'2e'7c'40'7c'3a'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'2d'2d'3e'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'3d'3a'3d'7c'3d'5c'5c'3d'7c'3d'3c'7c'3c'7c'3e'3d'7c'3e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Prolog",[Char]
"arith_expr"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'5c'2b'7c'2d'7c'5c'2a'7c'5c'5e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'2f'2f'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'2f'7c'5c'2a'5c'2a'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
FunctionTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'28'2f'5c'5c'7c'5c'5c'2f'7c'5c'5c'7c'3c'3c'7c'3e'3e'29'28'3f'21'5b'23'24'26'2a'2b'5c'2d'2e'2f'3a'3c'3d'3e'3f'40'5e'7e'5c'5c'5d'29 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
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]
"Prolog",[Char]
"operator")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [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
ErrorTok))
parseRules ([Char]
"Alerts_indent", [Char]
_) = Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Alert_indent.parseExpression forall a. Maybe a
Nothing
parseRules ([Char], [Char])
x = ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Prolog",[Char]
"shebang") 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)