module Data.GI.CodeGen.GtkDoc
( parseGtkDoc
, GtkDoc(..)
, Token(..)
, Language(..)
, Link(..)
, ListItem(..)
, CRef(..)
) where
import Prelude hiding (takeWhile)
#if !MIN_VERSION_base(4,8,0)
import Control.Applicative ((<$>), (<*))
#endif
#if !MIN_VERSION_base(4,13,0)
import Data.Monoid ((<>))
#endif
import Control.Applicative ((<|>))
import Data.GI.GIR.BasicTypes (Name(Name))
import Data.Attoparsec.Text
import Data.Char (isAlphaNum, isAlpha, isAscii)
import qualified Data.Text as T
import Data.Text (Text)
data Token = Literal Text
| Text
| Verbatim Text
| CodeBlock (Maybe Language) Text
| ExternalLink Link
| Image Link
| List [ListItem]
| Int GtkDoc
| SymbolRef CRef
deriving (Int -> Token -> ShowS
[Token] -> ShowS
Token -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Token] -> ShowS
$cshowList :: [Token] -> ShowS
show :: Token -> [Char]
$cshow :: Token -> [Char]
showsPrec :: Int -> Token -> ShowS
$cshowsPrec :: Int -> Token -> ShowS
Show, Token -> Token -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c== :: Token -> Token -> Bool
Eq)
data Link = Link { Link -> Text
linkName :: Text
, Link -> Text
linkAddress :: Text }
deriving (Int -> Link -> ShowS
[Link] -> ShowS
Link -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Link] -> ShowS
$cshowList :: [Link] -> ShowS
show :: Link -> [Char]
$cshow :: Link -> [Char]
showsPrec :: Int -> Link -> ShowS
$cshowsPrec :: Int -> Link -> ShowS
Show, Link -> Link -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Link -> Link -> Bool
$c/= :: Link -> Link -> Bool
== :: Link -> Link -> Bool
$c== :: Link -> Link -> Bool
Eq)
data ListItem = ListItem GtkDoc [GtkDoc]
deriving (Int -> ListItem -> ShowS
[ListItem] -> ShowS
ListItem -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [ListItem] -> ShowS
$cshowList :: [ListItem] -> ShowS
show :: ListItem -> [Char]
$cshow :: ListItem -> [Char]
showsPrec :: Int -> ListItem -> ShowS
$cshowsPrec :: Int -> ListItem -> ShowS
Show, ListItem -> ListItem -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListItem -> ListItem -> Bool
$c/= :: ListItem -> ListItem -> Bool
== :: ListItem -> ListItem -> Bool
$c== :: ListItem -> ListItem -> Bool
Eq)
newtype Language = Language Text
deriving (Int -> Language -> ShowS
[Language] -> ShowS
Language -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Language] -> ShowS
$cshowList :: [Language] -> ShowS
show :: Language -> [Char]
$cshow :: Language -> [Char]
showsPrec :: Int -> Language -> ShowS
$cshowsPrec :: Int -> Language -> ShowS
Show, Language -> Language -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Language -> Language -> Bool
$c/= :: Language -> Language -> Bool
== :: Language -> Language -> Bool
$c== :: Language -> Language -> Bool
Eq)
data CRef = FunctionRef Name
| OldFunctionRef Text
| MethodRef Name Text
| ParamRef Text
| ConstantRef Text
| SignalRef Name Text
| OldSignalRef Text Text
| LocalSignalRef Text
| PropertyRef Name Text
| OldPropertyRef Text Text
| VMethodRef Text Text
| VFuncRef Name Text
| StructFieldRef Text Text
| CTypeRef Text
| TypeRef Name
deriving (Int -> CRef -> ShowS
[CRef] -> ShowS
CRef -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [CRef] -> ShowS
$cshowList :: [CRef] -> ShowS
show :: CRef -> [Char]
$cshow :: CRef -> [Char]
showsPrec :: Int -> CRef -> ShowS
$cshowsPrec :: Int -> CRef -> ShowS
Show, CRef -> CRef -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CRef -> CRef -> Bool
$c/= :: CRef -> CRef -> Bool
== :: CRef -> CRef -> Bool
$c== :: CRef -> CRef -> Bool
Eq, Eq CRef
CRef -> CRef -> Bool
CRef -> CRef -> Ordering
CRef -> CRef -> CRef
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CRef -> CRef -> CRef
$cmin :: CRef -> CRef -> CRef
max :: CRef -> CRef -> CRef
$cmax :: CRef -> CRef -> CRef
>= :: CRef -> CRef -> Bool
$c>= :: CRef -> CRef -> Bool
> :: CRef -> CRef -> Bool
$c> :: CRef -> CRef -> Bool
<= :: CRef -> CRef -> Bool
$c<= :: CRef -> CRef -> Bool
< :: CRef -> CRef -> Bool
$c< :: CRef -> CRef -> Bool
compare :: CRef -> CRef -> Ordering
$ccompare :: CRef -> CRef -> Ordering
Ord)
newtype GtkDoc = GtkDoc [Token]
deriving (Int -> GtkDoc -> ShowS
[GtkDoc] -> ShowS
GtkDoc -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [GtkDoc] -> ShowS
$cshowList :: [GtkDoc] -> ShowS
show :: GtkDoc -> [Char]
$cshow :: GtkDoc -> [Char]
showsPrec :: Int -> GtkDoc -> ShowS
$cshowsPrec :: Int -> GtkDoc -> ShowS
Show, GtkDoc -> GtkDoc -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GtkDoc -> GtkDoc -> Bool
$c/= :: GtkDoc -> GtkDoc -> Bool
== :: GtkDoc -> GtkDoc -> Bool
$c== :: GtkDoc -> GtkDoc -> Bool
Eq)
parseGtkDoc :: Text -> GtkDoc
parseGtkDoc :: Text -> GtkDoc
parseGtkDoc Text
raw =
case forall a. Parser a -> Text -> Either [Char] a
parseOnly (Parser Text [Token]
parseTokens forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall t. Chunk t => Parser t ()
endOfInput) Text
raw of
Left [Char]
e ->
forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"gtk-doc parsing failed with error \"" forall a. Semigroup a => a -> a -> a
<> [Char]
e
forall a. Semigroup a => a -> a -> a
<> [Char]
"\" on the input \"" forall a. Semigroup a => a -> a -> a
<> Text -> [Char]
T.unpack Text
raw forall a. Semigroup a => a -> a -> a
<> [Char]
"\""
Right [Token]
tks -> [Token] -> GtkDoc
GtkDoc forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Token] -> [Token]
coalesceLiterals
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Token] -> [Token]
restoreSHPreNewlines forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Token] -> [Token]
restoreListPreNewline forall a b. (a -> b) -> a -> b
$ [Token]
tks
restoreSHPreNewlines :: [Token] -> [Token]
restoreSHPreNewlines :: [Token] -> [Token]
restoreSHPreNewlines [] = []
restoreSHPreNewlines (Token
i : [Token]
rest) = Token
i forall a. a -> [a] -> [a]
: [Token] -> [Token]
restoreNewlines [Token]
rest
where restoreNewlines :: [Token] -> [Token]
restoreNewlines :: [Token] -> [Token]
restoreNewlines [] = []
restoreNewlines (s :: Token
s@(SectionHeader Int
_ GtkDoc
_) : [Token]
rest) =
Text -> Token
Literal Text
"\n" forall a. a -> [a] -> [a]
: Token
s forall a. a -> [a] -> [a]
: [Token] -> [Token]
restoreNewlines [Token]
rest
restoreNewlines (Token
x : [Token]
rest) = Token
x forall a. a -> [a] -> [a]
: [Token] -> [Token]
restoreNewlines [Token]
rest
restoreListPreNewline :: [Token] -> [Token]
restoreListPreNewline :: [Token] -> [Token]
restoreListPreNewline [] = []
restoreListPreNewline (l :: Token
l@(List [ListItem]
_) : [Token]
rest) =
Text -> Token
Literal Text
"\n" forall a. a -> [a] -> [a]
: Token
l forall a. a -> [a] -> [a]
: [Token] -> [Token]
restoreListPreNewline [Token]
rest
restoreListPreNewline (Token
x : [Token]
rest) = Token
x forall a. a -> [a] -> [a]
: [Token] -> [Token]
restoreListPreNewline [Token]
rest
coalesceLiterals :: [Token] -> [Token]
coalesceLiterals :: [Token] -> [Token]
coalesceLiterals [Token]
tks = Maybe Text -> [Token] -> [Token]
go forall a. Maybe a
Nothing [Token]
tks
where
go :: Maybe Text -> [Token] -> [Token]
go :: Maybe Text -> [Token] -> [Token]
go Maybe Text
Nothing [] = []
go (Just Text
l) [] = [Text -> Token
Literal Text
l]
go Maybe Text
Nothing (Literal Text
l : [Token]
rest) = Maybe Text -> [Token] -> [Token]
go (forall a. a -> Maybe a
Just Text
l) [Token]
rest
go (Just Text
l) (Literal Text
l' : [Token]
rest) = Maybe Text -> [Token] -> [Token]
go (forall a. a -> Maybe a
Just (Text
l forall a. Semigroup a => a -> a -> a
<> Text
l')) [Token]
rest
go Maybe Text
Nothing (Token
tk : [Token]
rest) = Token
tk forall a. a -> [a] -> [a]
: Maybe Text -> [Token] -> [Token]
go forall a. Maybe a
Nothing [Token]
rest
go (Just Text
l) (Token
tk : [Token]
rest) = Text -> Token
Literal Text
l forall a. a -> [a] -> [a]
: Token
tk forall a. a -> [a] -> [a]
: Maybe Text -> [Token] -> [Token]
go forall a. Maybe a
Nothing [Token]
rest
parseTokens :: Parser [Token]
parseTokens :: Parser Text [Token]
parseTokens = Parser Text [Token]
headerAndTokens forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Text [Token]
justTokens
where
headerAndTokens :: Parser [Token]
headerAndTokens :: Parser Text [Token]
headerAndTokens = do
Token
header <- Parser Token
parseInitialSectionHeader
[Token]
tokens <- Parser Text [Token]
justTokens
forall (m :: * -> *) a. Monad m => a -> m a
return (Token
header forall a. a -> [a] -> [a]
: [Token]
tokens)
justTokens :: Parser [Token]
justTokens :: Parser Text [Token]
justTokens = forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many' Parser Token
parseToken
parseToken :: Parser Token
parseToken :: Parser Token
parseToken =
Parser Token
parseFunctionRef
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseMethod
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseConstructor
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseSignal
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseId
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseLocalSignal
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseProperty
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseVMethod
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseStructField
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseClass
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseCType
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseConstant
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseParam
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseEscaped
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseCodeBlock
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseVerbatim
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseUrl
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseImage
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseSectionHeader
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseList
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseComment
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseBoringLiteral
isCIdent :: Char -> Bool
isCIdent :: Char -> Bool
isCIdent Char
'_' = Bool
True
isCIdent Char
c = Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlphaNum Char
c
parseCIdent :: Parser Text
parseCIdent :: Parser Text
parseCIdent = (Char -> Bool) -> Parser Text
takeWhile1 Char -> Bool
isCIdent
parseFunctionRef :: Parser Token
parseFunctionRef :: Parser Token
parseFunctionRef = Parser Token
parseOldFunctionRef forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseNewFunctionRef
parseId :: Parser Token
parseId :: Parser Token
parseId = do
Text
_ <- Text -> Parser Text
string Text
"[id@"
Text
ident <- Parser Text
parseCIdent
Char
_ <- Char -> Parser Char
char Char
']'
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Text -> CRef
OldFunctionRef Text
ident))
parseOldFunctionRef :: Parser Token
parseOldFunctionRef :: Parser Token
parseOldFunctionRef = do
Text
ident <- Parser Text
parseCIdent
forall (f :: * -> *) a. Alternative f => a -> f a -> f a
option (Text -> Token
Literal Text
ident) (Text -> Parser Text
string Text
"()" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Text -> CRef
OldFunctionRef Text
ident)))
parseNewFunctionRef :: Parser Token
parseNewFunctionRef :: Parser Token
parseNewFunctionRef = do
Text
_ <- Text -> Parser Text
string Text
"[func@"
Text
ns <- (Char -> Bool) -> Parser Text
takeWhile1 (\Char
c -> Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
c)
Char
_ <- Char -> Parser Char
char Char
'.'
Text
n <- (Char -> Bool) -> Parser Text
takeWhile1 Char -> Bool
isCIdent
Char
_ <- Char -> Parser Char
char Char
']'
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ CRef -> Token
SymbolRef forall a b. (a -> b) -> a -> b
$ Name -> CRef
FunctionRef (Text -> Text -> Name
Name Text
ns Text
n)
parseMethod :: Parser Token
parseMethod :: Parser Token
parseMethod = do
Text
_ <- Text -> Parser Text
string Text
"[method@"
Text
ns <- (Char -> Bool) -> Parser Text
takeWhile1 (\Char
c -> Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
c)
Char
_ <- Char -> Parser Char
char Char
'.'
Text
n <- (Char -> Bool) -> Parser Text
takeWhile1 Char -> Bool
isCIdent
Char
_ <- Char -> Parser Char
char Char
'.'
Text
method <- (Char -> Bool) -> Parser Text
takeWhile1 Char -> Bool
isCIdent
Char
_ <- Char -> Parser Char
char Char
']'
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ CRef -> Token
SymbolRef forall a b. (a -> b) -> a -> b
$ Name -> Text -> CRef
MethodRef (Text -> Text -> Name
Name Text
ns Text
n) Text
method
parseConstructor :: Parser Token
parseConstructor :: Parser Token
parseConstructor = do
Text
_ <- Text -> Parser Text
string Text
"[ctor@"
Text
ns <- (Char -> Bool) -> Parser Text
takeWhile1 (\Char
c -> Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
c)
Char
_ <- Char -> Parser Char
char Char
'.'
Text
n <- (Char -> Bool) -> Parser Text
takeWhile1 Char -> Bool
isCIdent
Char
_ <- Char -> Parser Char
char Char
'.'
Text
method <- (Char -> Bool) -> Parser Text
takeWhile1 Char -> Bool
isCIdent
Char
_ <- Char -> Parser Char
char Char
']'
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ CRef -> Token
SymbolRef forall a b. (a -> b) -> a -> b
$ Name -> Text -> CRef
MethodRef (Text -> Text -> Name
Name Text
ns Text
n) Text
method
parseClass :: Parser Token
parseClass :: Parser Token
parseClass = do
Text
_ <- Text -> Parser Text
string Text
"[class@" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Text -> Parser Text
string Text
"[iface@" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Text -> Parser Text
string Text
"[enum@"
Text
ns <- (Char -> Bool) -> Parser Text
takeWhile1 (\Char
c -> Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
c)
Char
_ <- Char -> Parser Char
char Char
'.'
Text
n <- (Char -> Bool) -> Parser Text
takeWhile1 Char -> Bool
isCIdent
Char
_ <- Char -> Parser Char
char Char
']'
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ CRef -> Token
SymbolRef forall a b. (a -> b) -> a -> b
$ Name -> CRef
TypeRef (Text -> Text -> Name
Name Text
ns Text
n)
parseSignal :: Parser Token
parseSignal :: Parser Token
parseSignal = Parser Token
parseOldSignal forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseNewSignal
parseOldSignal :: Parser Token
parseOldSignal :: Parser Token
parseOldSignal = do
Char
_ <- Char -> Parser Char
char Char
'#'
Text
obj <- Parser Text
parseCIdent
Text
_ <- Text -> Parser Text
string Text
"::"
Text
signal <- Parser Text
signalOrPropName
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Text -> Text -> CRef
OldSignalRef Text
obj Text
signal))
parseNewSignal :: Parser Token
parseNewSignal :: Parser Token
parseNewSignal = do
Text
_ <- Text -> Parser Text
string Text
"[signal@"
Text
ns <- (Char -> Bool) -> Parser Text
takeWhile1 (\Char
c -> Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
c)
Char
_ <- Char -> Parser Char
char Char
'.'
Text
n <- Parser Text
parseCIdent
Text
_ <- Text -> Parser Text
string Text
"::"
Text
signal <- (Char -> Bool) -> Parser Text
takeWhile1 (\Char
c -> (Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
c) Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'-')
Char
_ <- Char -> Parser Char
char Char
']'
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Name -> Text -> CRef
SignalRef (Text -> Text -> Name
Name Text
ns Text
n) Text
signal))
parseLocalSignal :: Parser Token
parseLocalSignal :: Parser Token
parseLocalSignal = do
Text
_ <- Text -> Parser Text
string Text
"::"
Text
signal <- Parser Text
signalOrPropName
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Text -> CRef
LocalSignalRef Text
signal))
parseOldProperty :: Parser Token
parseOldProperty :: Parser Token
parseOldProperty = do
Char
_ <- Char -> Parser Char
char Char
'#'
Text
obj <- Parser Text
parseCIdent
Char
_ <- Char -> Parser Char
char Char
':'
Text
property <- Parser Text
signalOrPropName
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Text -> Text -> CRef
OldPropertyRef Text
obj Text
property))
parseNewProperty :: Parser Token
parseNewProperty :: Parser Token
parseNewProperty = do
Text
_ <- Text -> Parser Text
string Text
"[property@"
Text
ns <- (Char -> Bool) -> Parser Text
takeWhile1 (\Char
c -> Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
c)
Char
_ <- Char -> Parser Char
char Char
'.'
Text
n <- Parser Text
parseCIdent
Char
_ <- Char -> Parser Char
char Char
':'
Text
property <- (Char -> Bool) -> Parser Text
takeWhile1 (\Char
c -> (Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
c) Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'-')
Char
_ <- Char -> Parser Char
char Char
']'
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Name -> Text -> CRef
PropertyRef (Text -> Text -> Name
Name Text
ns Text
n) Text
property))
parseProperty :: Parser Token
parseProperty :: Parser Token
parseProperty = Parser Token
parseOldProperty forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseNewProperty
parseComment :: Parser Token
= do
[Char]
comment <- Text -> Parser Text
string Text
"<!--" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a b. Alternative f => f a -> f b -> f [a]
manyTill Parser Char
anyChar (Text -> Parser Text
string Text
"-->")
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Token
Comment forall a b. (a -> b) -> a -> b
$ [Char] -> Text
T.pack [Char]
comment)
parseOldVMethod :: Parser Token
parseOldVMethod :: Parser Token
parseOldVMethod = do
Char
_ <- Char -> Parser Char
char Char
'#'
Text
obj <- Parser Text
parseCIdent
Char
_ <- Char -> Parser Char
char Char
'.'
Text
method <- Parser Text
parseCIdent
Text
_ <- Text -> Parser Text
string Text
"()"
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Text -> Text -> CRef
VMethodRef Text
obj Text
method))
parseVFunc :: Parser Token
parseVFunc :: Parser Token
parseVFunc = do
Text
_ <- Text -> Parser Text
string Text
"[vfunc@"
Text
ns <- (Char -> Bool) -> Parser Text
takeWhile1 (\Char
c -> Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
c)
Char
_ <- Char -> Parser Char
char Char
'.'
Text
n <- Parser Text
parseCIdent
Char
_ <- Char -> Parser Char
char Char
'.'
Text
vfunc <- Parser Text
parseCIdent
Char
_ <- Char -> Parser Char
char Char
']'
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Name -> Text -> CRef
VFuncRef (Text -> Text -> Name
Name Text
ns Text
n) Text
vfunc))
parseVMethod :: Parser Token
parseVMethod :: Parser Token
parseVMethod = Parser Token
parseOldVMethod forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseVFunc
parseStructField :: Parser Token
parseStructField :: Parser Token
parseStructField = do
Char
_ <- Char -> Parser Char
char Char
'#'
Text
obj <- Parser Text
parseCIdent
Char
_ <- Char -> Parser Char
char Char
'.'
Text
field <- Parser Text
parseCIdent
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Text -> Text -> CRef
StructFieldRef Text
obj Text
field))
parseCType :: Parser Token
parseCType :: Parser Token
parseCType = do
Char
_ <- Char -> Parser Char
char Char
'#'
Text
obj <- Parser Text
parseCIdent
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Text -> CRef
CTypeRef Text
obj))
parseConstant :: Parser Token
parseConstant :: Parser Token
parseConstant = do
Char
_ <- Char -> Parser Char
char Char
'%'
Text
c <- Parser Text
parseCIdent
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Text -> CRef
ConstantRef Text
c))
parseParam :: Parser Token
parseParam :: Parser Token
parseParam = do
Char
_ <- Char -> Parser Char
char Char
'@'
Text
param <- Parser Text
parseCIdent
forall (m :: * -> *) a. Monad m => a -> m a
return (CRef -> Token
SymbolRef (Text -> CRef
ParamRef Text
param))
signalOrPropName :: Parser Text
signalOrPropName :: Parser Text
signalOrPropName = (Char -> Bool) -> Parser Text
takeWhile1 Char -> Bool
isSignalOrPropIdent
where isSignalOrPropIdent :: Char -> Bool
isSignalOrPropIdent :: Char -> Bool
isSignalOrPropIdent Char
'-' = Bool
True
isSignalOrPropIdent Char
c = Char -> Bool
isCIdent Char
c
parseEscaped :: Parser Token
parseEscaped :: Parser Token
parseEscaped = do
Char
_ <- Char -> Parser Char
char Char
'\\'
Char
c <- (Char -> Bool) -> Parser Char
satisfy (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ([Char]
"#@%\\`" :: [Char]))
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> Token
Literal (Char -> Text
T.singleton Char
c)
parseBoringLiteral :: Parser Token
parseBoringLiteral :: Parser Token
parseBoringLiteral = do
Char
c <- Parser Char
anyChar
Text
boring <- (Char -> Bool) -> Parser Text
takeWhile (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
special)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> Token
Literal (Char -> Text -> Text
T.cons Char
c Text
boring)
special :: Char -> Bool
special :: Char -> Bool
special Char
'#' = Bool
True
special Char
'@' = Bool
True
special Char
'%' = Bool
True
special Char
'\\' = Bool
True
special Char
'`' = Bool
True
special Char
'|' = Bool
True
special Char
'[' = Bool
True
special Char
'!' = Bool
True
special Char
'\n' = Bool
True
special Char
':' = Bool
True
special Char
c = Char -> Bool
isCIdent Char
c
parseVerbatim :: Parser Token
parseVerbatim :: Parser Token
parseVerbatim = do
Char
_ <- Char -> Parser Char
char Char
'`'
Text
v <- (Char -> Bool) -> Parser Text
takeWhile1 (forall a. Eq a => a -> a -> Bool
/= Char
'`')
Char
_ <- Char -> Parser Char
char Char
'`'
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> Token
Verbatim Text
v
parseUrl :: Parser Token
parseUrl :: Parser Token
parseUrl = do
Char
_ <- Char -> Parser Char
char Char
'['
Text
name <- (Char -> Bool) -> Parser Text
takeWhile1 (forall a. Eq a => a -> a -> Bool
/= Char
']')
Text
_ <- Text -> Parser Text
string Text
"]("
Text
address <- (Char -> Bool) -> Parser Text
takeWhile1 (forall a. Eq a => a -> a -> Bool
/= Char
')')
Char
_ <- Char -> Parser Char
char Char
')'
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Link -> Token
ExternalLink forall a b. (a -> b) -> a -> b
$ Link {linkName :: Text
linkName = Text
name, linkAddress :: Text
linkAddress = Text
address}
parseImage :: Parser Token
parseImage :: Parser Token
parseImage = do
Text
_ <- Text -> Parser Text
string Text
"!["
Text
name <- (Char -> Bool) -> Parser Text
takeWhile (forall a. Eq a => a -> a -> Bool
/= Char
']')
Text
_ <- Text -> Parser Text
string Text
"]("
Text
address <- (Char -> Bool) -> Parser Text
takeWhile1 (forall a. Eq a => a -> a -> Bool
/= Char
')')
Char
_ <- Char -> Parser Char
char Char
')'
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Link -> Token
Image forall a b. (a -> b) -> a -> b
$ Link {linkName :: Text
linkName = Text
name, linkAddress :: Text
linkAddress = Text
address}
parseCodeBlock :: Parser Token
parseCodeBlock :: Parser Token
parseCodeBlock = Parser Token
parseOldStyleCodeBlock forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Token
parseNewStyleCodeBlock
parseNewStyleCodeBlock :: Parser Token
parseNewStyleCodeBlock :: Parser Token
parseNewStyleCodeBlock = do
Text
_ <- Text -> Parser Text
string Text
"```"
Text
lang <- Text -> Text
T.strip forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char -> Bool) -> Parser Text
takeWhile (forall a. Eq a => a -> a -> Bool
/= Char
'\n')
Char
_ <- Char -> Parser Char
char Char
'\n'
let maybeLang :: Maybe Text
maybeLang = if Text -> Bool
T.null Text
lang then forall a. Maybe a
Nothing
else forall a. a -> Maybe a
Just Text
lang
Text
code <- [Char] -> Text
T.pack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a b. Alternative f => f a -> f b -> f [a]
manyTill Parser Char
anyChar (Text -> Parser Text
string Text
"\n```")
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Language -> Text -> Token
CodeBlock (Text -> Language
Language forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
maybeLang) Text
code
parseOldStyleCodeBlock :: Parser Token
parseOldStyleCodeBlock :: Parser Token
parseOldStyleCodeBlock = do
Text
_ <- Text -> Parser Text
string Text
"|["
Maybe Language
lang <- (forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Language
parseLanguage) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
Text
code <- [Char] -> Text
T.pack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a b. Alternative f => f a -> f b -> f [a]
manyTill Parser Char
anyChar (Text -> Parser Text
string Text
"]|")
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Language -> Text -> Token
CodeBlock Maybe Language
lang Text
code
parseLanguage :: Parser Language
parseLanguage :: Parser Language
parseLanguage = do
Text
_ <- Text -> Parser Text
string Text
"<!--"
Parser ()
skipSpace
Text
_ <- Text -> Parser Text
string Text
"language=\""
Text
lang <- (Char -> Bool) -> Parser Text
takeWhile1 (forall a. Eq a => a -> a -> Bool
/= Char
'"')
Char
_ <- Char -> Parser Char
char Char
'"'
Parser ()
skipSpace
Text
_ <- Text -> Parser Text
string Text
"-->"
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> Language
Language Text
lang
parseSectionHeader :: Parser Token
= Char -> Parser Char
char Char
'\n' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Token
parseInitialSectionHeader
parseInitialSectionHeader :: Parser Token
= do
Text
hashes <- (Char -> Bool) -> Parser Text
takeWhile1 (forall a. Eq a => a -> a -> Bool
== Char
'#')
[Char]
_ <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
many1 Parser Char
space
Text
heading <- (Char -> Bool) -> Parser Text
takeWhile1 ([Char] -> Char -> Bool
notInClass [Char]
"#\n")
Char
_ <- (Text -> Parser Text
string Text
hashes forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Parser Char
char Char
'\n') forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Char -> Parser Char
char Char
'\n')
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> GtkDoc -> Token
SectionHeader (Text -> Int
T.length Text
hashes) (Text -> GtkDoc
parseGtkDoc Text
heading)
parseList :: Parser Token
parseList :: Parser Token
parseList = do
[ListItem]
items <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
many1 Parser ListItem
parseListItem
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [ListItem] -> Token
List [ListItem]
items
where parseListItem :: Parser ListItem
parseListItem :: Parser ListItem
parseListItem = do
Char
_ <- Char -> Parser Char
char Char
'\n'
Text
_ <- Text -> Parser Text
string Text
"\n- " forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Text -> Parser Text
string Text
"- "
Text
first <- (Char -> Bool) -> Parser Text
takeWhile1 (forall a. Eq a => a -> a -> Bool
/= Char
'\n')
[Text]
rest <- forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many' Parser Text
parseLine
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ GtkDoc -> [GtkDoc] -> ListItem
ListItem (Text -> GtkDoc
parseGtkDoc Text
first) (forall a b. (a -> b) -> [a] -> [b]
map Text -> GtkDoc
parseGtkDoc [Text]
rest)
parseLine :: Parser Text
parseLine :: Parser Text
parseLine = Text -> Parser Text
string Text
"\n " forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Char -> Bool) -> Parser Text
takeWhile1 (forall a. Eq a => a -> a -> Bool
/= Char
'\n')