module Text.Highlighting.Kate.Syntax.Modula2
(highlight, parseExpression, syntaxName, syntaxExtensions)
where
import Text.Highlighting.Kate.Types
import Text.Highlighting.Kate.Common
import Text.ParserCombinators.Parsec hiding (State)
import Control.Monad.State
import Data.Char (isSpace)
import qualified Data.Set as Set
syntaxName :: String
syntaxName :: [Char]
syntaxName = [Char]
"Modula-2"
syntaxExtensions :: String
syntaxExtensions :: [Char]
syntaxExtensions = [Char]
"*.mod;*.def;*.mi;*.md"
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]
"Modula-2",[Char]
"Normal")], synStLineNumber :: Int
synStLineNumber = Int
0, synStPrevChar :: Char
synStPrevChar = Char
'\n', synStPrevNonspace :: Bool
synStPrevNonspace = Bool
False, synStContinuation :: Bool
synStContinuation = Bool
False, synStCaseSensitive :: Bool
synStCaseSensitive = Bool
True, synStKeywordCaseSensitive :: Bool
synStKeywordCaseSensitive = Bool
True, synStCaptures :: [[Char]]
synStCaptures = []}
pEndLine :: ParsecT [Char] SyntaxState Identity ()
pEndLine = do
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStPrevNonspace :: Bool
synStPrevNonspace = Bool
False }
([Char], [Char])
context <- KateParser ([Char], [Char])
currentContext
ContextStack
contexts <- SyntaxState -> ContextStack
synStContexts forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
SyntaxState
st <- forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
if forall (t :: * -> *) a. Foldable t => t a -> Int
length ContextStack
contexts forall a. Ord a => a -> a -> Bool
>= Int
2
then case ([Char], [Char])
context of
([Char], [Char])
_ | SyntaxState -> Bool
synStContinuation SyntaxState
st -> forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStContinuation :: Bool
synStContinuation = Bool
False }
([Char]
"Modula-2",[Char]
"Normal") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Modula-2",[Char]
"String1") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Modula-2",[Char]
"String2") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Modula-2",[Char]
"Comment2") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char]
"Modula-2",[Char]
"Comment3") -> (ParsecT [Char] SyntaxState Identity ()
popContext) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
([Char]
"Modula-2",[Char]
"Prep1") -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
([Char], [Char])
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
else forall (m :: * -> *) a. Monad m => a -> m a
return ()
withAttribute :: a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute a
attr [Char]
txt = do
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
txt) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Parser matched no text"
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st { synStPrevChar :: Char
synStPrevChar = forall a. [a] -> a
last [Char]
txt
, synStPrevNonspace :: Bool
synStPrevNonspace = SyntaxState -> Bool
synStPrevNonspace SyntaxState
st Bool -> Bool -> Bool
|| Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isSpace [Char]
txt) }
forall (m :: * -> *) a. Monad m => a -> m a
return (a
attr, [Char]
txt)
list_directives :: Set [Char]
list_directives = 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]
"ASSEMBLER ALLOCATE DEALLOCATE SIZE Write WriteString WriteCard WriteLn WriteBf WriteInt WriteReal WriteLongReal Read ReadString ReadCard ReadInt ReadReal ReadLongReal Open Close OpenInput OpenOutput Accessible Erase EOF Done EmptyString Assign Append Length StrEq Copy Concat pos Delete Insert compare CAPS PutBf GetArgs GetEnv ResetClock UserTime SystemTime GetChar GetInt GetCard GetString GetReal GetLongReal PutChar PutInt PutCard PutString PutReal PutLongReal PutLn"
list_keywords :: Set [Char]
list_keywords = forall a. Ord a => [a] -> Set a
Set.fromList forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
words forall a b. (a -> b) -> a -> b
$ [Char]
"AND ARRAY ASM BEGIN CASE CONST DIV DO ELSE ELSIF END FOR IF IMPLEMENTATION IN SET INCL EXCL ABS BITSET CAP CHR DEC HALT HIGH INC MAX MIN ODD ORD PROC TRUNC VAL MOD NIL NOT OF OR PROCEDURE MODULE DEFINITION RECORD REPEAT THEN TO TYPE UNTIL LOOP VAR WHILE WITH EXIT FALSE TRUE BY FROM IMPORT EXPORT QUALIFIED RETURN NEWPROCESS TRANSFER IOTRANSFER FOREIGN"
list_types :: Set [Char]
list_types = 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]
"INTEGER CARDINAL SHORTINT SHORTCARD LONGINT LONGREAL CHAR BOOLEAN POINTER ADDRESS ADR REAL File"
parseRules :: ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Modula-2",[Char]
"Normal") =
((([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_keywords forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_directives forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(([Char] -> Set [Char] -> KateParser [Char]
pKeyword [Char]
" \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set [Char]
list_types forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((KateParser [Char]
pFloat forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((KateParser [Char]
pInt forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'"' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Modula-2",[Char]
"String1"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'\'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Modula-2",[Char]
"String2"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> [Char] -> KateParser [Char]
pString Bool
False [Char]
"(*$" forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Modula-2",[Char]
"Prep1"))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'(' Char
'*' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Modula-2",[Char]
"Comment2"))
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]
"Modula-2",[Char]
"Normal")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
parseRules ([Char]
"Modula-2",[Char]
"String1") =
(((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'"' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"Modula-2",[Char]
"String1")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))
parseRules ([Char]
"Modula-2",[Char]
"String2") =
(((Bool -> Char -> KateParser [Char]
pDetectChar Bool
False Char
'\'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(KateParser ([Char], [Char])
currentContext forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x forall a. Eq a => a -> a -> Bool
== ([Char]
"Modula-2",[Char]
"String2")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))
parseRules ([Char]
"Modula-2",[Char]
"Comment2") =
(((Bool -> Char -> Char -> KateParser [Char]
pDetect2Chars Bool
False Char
'*' Char
')' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
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
<|>
(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]
"Modula-2",[Char]
"Comment2")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok))
parseRules ([Char]
"Modula-2",[Char]
"Comment3") =
(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]
"Modula-2",[Char]
"Comment3")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok)
parseRules ([Char]
"Modula-2",[Char]
"Prep1") =
(((Bool -> [Char] -> KateParser [Char]
pString Bool
False [Char]
"$*)" forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"Modula-2",[Char]
"Prep1"))
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]
"Modula-2",[Char]
"Prep1")) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser [Char]
pDefault forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok))
parseRules ([Char], [Char])
x = ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"Modula-2",[Char]
"Normal") forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char]
"Unknown context" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show ([Char], [Char])
x)