{-# LANGUAGE CPP                #-}

-- ------------------------------------------------------------

{- |
   Module     : Text.XML.HXT.Parser.XmlParsec
   Copyright  : Copyright (C) 2005 Uwe Schmidt
   License    : MIT

   Maintainer : Uwe Schmidt (uwe@fh-wedel.de)
   Stability  : experimental
   Portability: portable

   Xml Parsec parser with pure filter interface

-}

-- ------------------------------------------------------------

module Text.XML.HXT.Parser.XmlParsec
    ( charData
    , charData'
    , comment
    , pI
    , cDSect
    , document
    , document'
    , prolog
    , xMLDecl
    , xMLDecl'
    , versionInfo
    , misc
    , doctypedecl
    , markupdecl
    , sDDecl
    , element
    , content
    , contentWithTextDecl
    , textDecl
    , encodingDecl
    , xread
    , xreadDoc

    , parseXmlContent
    , parseXmlDocEncodingSpec
    , parseXmlDocument
    , parseXmlDTDPart
    , parseXmlEncodingSpec
    , parseXmlEntityEncodingSpec
    , parseXmlEntityValueAsAttrValue
    , parseXmlEntityValueAsContent

    , parseXmlPart
    , parseXmlText

    , parseNMToken
    , parseName

    , removeEncodingSpec
    )
where

#if MIN_VERSION_base(4,8,2)
#else
import           Control.Applicative                   ((<$>))
#endif

import           Text.ParserCombinators.Parsec         (between, char, eof,
                                                        getInput, getPosition,
                                                        many, many1,
                                                        notFollowedBy, option,
                                                        runParser, sourceName,
                                                        string, try, unexpected,
                                                        (<?>), (<|>))

import           Text.XML.HXT.DOM.Interface
import           Text.XML.HXT.DOM.ShowXml              (xshow)
import           Text.XML.HXT.DOM.XmlNode              (changeAttrl,
                                                        getAttrName, getAttrl,
                                                        getChildren, getText,
                                                        isRoot, isText,
                                                        mergeAttrl, mkAttr',
                                                        mkCdata', mkCmt',
                                                        mkDTDElem', mkElement',
                                                        mkError', mkPi',
                                                        mkRoot', mkText')
import           Text.XML.HXT.Parser.XmlCharParser     (SimpleXParser, XPState,
                                                        XParser,
                                                        withNormNewline,
                                                        withoutNormNewline,
                                                        xmlChar)
import qualified Text.XML.HXT.Parser.XmlDTDTokenParser as XD
import qualified Text.XML.HXT.Parser.XmlTokenParser    as XT

import           Control.FlatSeq

import           Data.Char                             (toLower)
import           Data.Maybe

-- import Debug.Trace

-- ------------------------------------------------------------
--
-- Character Data (2.4)

charData                :: XParser s XmlTrees
charData :: forall s. XParser s XmlTrees
charData
    = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (forall s. XParser s XmlTree
charData' forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s. XParser s XmlTree
XT.referenceT)

charData'               :: XParser s XmlTree
charData' :: forall s. XParser s XmlTree
charData'
    =  do
       [Char]
t <- forall s.
(XParser s Char -> XParser s [Char])
-> (Char -> Bool) -> [Char] -> XParser s [Char]
XT.allBut1 forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 (\ Char
c -> Bool -> Bool
not (Char
c forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char]
"<&")) [Char]
"]]>"
       forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> XmlTree
mkText' [Char]
t)

-- ------------------------------------------------------------
--
-- Comments (2.5)

comment         :: XParser s XmlTree
comment :: forall s. XParser s XmlTree
comment
    = forall s. XParser s () -> XParser s XmlTree
comment'' forall a b. (a -> b) -> a -> b
$ forall s. [Char] -> XParser s ()
XT.checkString [Char]
"<!--"

-- the leading <! is already parsed

comment'        :: XParser s XmlTree
comment' :: forall s. XParser s XmlTree
comment'
    = forall s. XParser s () -> XParser s XmlTree
comment'' (forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
string [Char]
"--" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ())

comment''       :: XParser s () -> XParser s XmlTree
comment'' :: forall s. XParser s () -> XParser s XmlTree
comment'' XParser s ()
op
    = ( do
        [Char]
c <- forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between XParser s ()
op (forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
string ([Char]
"-->")) (forall s.
(XParser s Char -> XParser s [Char]) -> [Char] -> XParser s [Char]
XT.allBut forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many [Char]
"--")
        forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> XmlTree
mkCmt' [Char]
c)
      ) forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"comment"

-- ------------------------------------------------------------
--
-- Processing Instructions

pI             :: XParser s XmlTree
pI :: forall s. XParser s XmlTree
pI = forall s. XParser s () -> XParser s XmlTree
pI'' forall a b. (a -> b) -> a -> b
$ forall s. [Char] -> XParser s ()
XT.checkString [Char]
"<?"

-- the leading < is already parsed

pI'             :: XParser s XmlTree
pI' :: forall s. XParser s XmlTree
pI' = forall s. XParser s () -> XParser s XmlTree
pI'' (forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'?' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ())

pI''             :: XParser s () -> XParser s XmlTree
pI'' :: forall s. XParser s () -> XParser s XmlTree
pI'' XParser s ()
op
    = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between XParser s ()
op (forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
string [Char]
"?>")
      ( do
        [Char]
n <- forall s. XParser s [Char]
pITarget
        [Char]
p <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [Char]
"" (forall s. XParser s [Char]
XT.sPace
                        forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                        forall s.
(XParser s Char -> XParser s [Char]) -> [Char] -> XParser s [Char]
XT.allBut forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many [Char]
"?>"
                       )
        forall (m :: * -> *) a. Monad m => a -> m a
return (QName -> XmlTrees -> XmlTree
mkPi' ([Char] -> QName
mkName [Char]
n) [QName -> XmlTrees -> XmlTree
mkAttr' ([Char] -> QName
mkName [Char]
a_value) [[Char] -> XmlTree
mkText' [Char]
p]])
      ) forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"processing instruction"
      where
      pITarget  :: XParser s String
      pITarget :: forall s. XParser s [Char]
pITarget = ( do
                   [Char]
n <- forall s. XParser s [Char]
XT.name
                   if forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower [Char]
n forall a. Eq a => a -> a -> Bool
== [Char]
t_xml
                      then forall s (m :: * -> *) t u a.
Stream s m t =>
[Char] -> ParsecT s u m a
unexpected [Char]
n
                      else forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
n
                 )

-- ------------------------------------------------------------
--
-- CDATA Sections (2.7)

cDSect          :: XParser s XmlTree
cDSect :: forall s. XParser s XmlTree
cDSect
    = forall s. XParser s () -> XParser s XmlTree
cDSect'' forall a b. (a -> b) -> a -> b
$ forall s. [Char] -> XParser s ()
XT.checkString [Char]
"<![CDATA["

-- the leading <! is already parsed, no try neccessary

cDSect'         :: XParser s XmlTree
cDSect' :: forall s. XParser s XmlTree
cDSect'
    = forall s. XParser s () -> XParser s XmlTree
cDSect'' (forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
string [Char]
"[CDATA[" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ())

cDSect''        :: XParser s () -> XParser s XmlTree
cDSect'' :: forall s. XParser s () -> XParser s XmlTree
cDSect'' XParser s ()
op
    = do
      [Char]
t <- forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between XParser s ()
op (forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
string [Char]
"]]>") (forall s.
(XParser s Char -> XParser s [Char]) -> [Char] -> XParser s [Char]
XT.allBut forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many [Char]
"]]>")
      forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> XmlTree
mkCdata' [Char]
t)
      forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"CDATA section"

-- ------------------------------------------------------------
--
-- Document (2.1) and Prolog (2.8)

document        :: XParser s XmlTree
document :: forall s. XParser s XmlTree
document
    = do
      SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
      XmlTrees
dl <- forall s. XParser s XmlTrees
document'
      forall (m :: * -> *) a. Monad m => a -> m a
return (XmlTrees -> XmlTrees -> XmlTree
mkRoot' [ QName -> XmlTrees -> XmlTree
mkAttr' ([Char] -> QName
mkName [Char]
a_source) [[Char] -> XmlTree
mkText' (SourcePos -> [Char]
sourceName SourcePos
pos)]
                      , QName -> XmlTrees -> XmlTree
mkAttr' ([Char] -> QName
mkName [Char]
a_status) [[Char] -> XmlTree
mkText' (forall a. Show a => a -> [Char]
show Int
c_ok)]
                      ] XmlTrees
dl
             )

document'       :: XParser s XmlTrees
document' :: forall s. XParser s XmlTrees
document'
    = do
      XmlTrees
pl <- forall s. XParser s XmlTrees
prolog
      XmlTree
el <- forall s. XParser s XmlTree
element
      XmlTrees
ml <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many forall s. XParser s XmlTree
misc
      forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof
      forall (m :: * -> *) a. Monad m => a -> m a
return (XmlTrees
pl forall a. [a] -> [a] -> [a]
++ [XmlTree
el] forall a. [a] -> [a] -> [a]
++ XmlTrees
ml)

prolog          :: XParser s XmlTrees
prolog :: forall s. XParser s XmlTrees
prolog
    = do
      XmlTrees
xml     <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall s. XParser s XmlTrees
xMLDecl'
      XmlTrees
misc1   <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many forall s. XParser s XmlTree
misc
      XmlTrees
dtdPart <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall s. XParser s XmlTrees
doctypedecl
      XmlTrees
misc2   <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many forall s. XParser s XmlTree
misc
      forall (m :: * -> *) a. Monad m => a -> m a
return (XmlTrees
xml forall a. [a] -> [a] -> [a]
++ XmlTrees
misc1 forall a. [a] -> [a] -> [a]
++ XmlTrees
dtdPart forall a. [a] -> [a] -> [a]
++ XmlTrees
misc2)

xMLDecl         :: XParser s XmlTrees
xMLDecl :: forall s. XParser s XmlTrees
xMLDecl
    = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (forall tok st a. GenParser tok st a -> GenParser tok st a
try forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
string [Char]
"<?xml") (forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
string [Char]
"?>")
      ( do
        XmlTrees
vi <- forall s. XParser s XmlTrees
versionInfo
        XmlTrees
ed <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall s. XParser s XmlTrees
encodingDecl
        XmlTrees
sd <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall s. XParser s XmlTrees
sDDecl
        forall s. XParser s ()
XT.skipS0
        forall (m :: * -> *) a. Monad m => a -> m a
return (XmlTrees
vi forall a. [a] -> [a] -> [a]
++ XmlTrees
ed forall a. [a] -> [a] -> [a]
++ XmlTrees
sd)
      )
      forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"xml declaration"

xMLDecl'        :: XParser s XmlTrees
xMLDecl' :: forall s. XParser s XmlTrees
xMLDecl'
    = do
      XmlTrees
al <- forall s. XParser s XmlTrees
xMLDecl
      forall (m :: * -> *) a. Monad m => a -> m a
return [QName -> XmlTrees -> XmlTree
mkPi' ([Char] -> QName
mkName [Char]
t_xml) XmlTrees
al]

xMLDecl''       :: XParser s XmlTree
xMLDecl'' :: forall s. XParser s XmlTree
xMLDecl''
    = do
      XmlTrees
al     <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (forall tok st a. GenParser tok st a -> GenParser tok st a
try forall s. XParser s XmlTrees
xMLDecl)
      forall (m :: * -> *) a. Monad m => a -> m a
return (XmlTrees -> XmlTrees -> XmlTree
mkRoot' XmlTrees
al [])

versionInfo     :: XParser s XmlTrees
versionInfo :: forall s. XParser s XmlTrees
versionInfo
    = ( do
        forall tok st a. GenParser tok st a -> GenParser tok st a
try ( forall s. XParser s ()
XT.skipS
              forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
              forall s. [Char] -> XParser s [Char]
XT.keyword [Char]
a_version
              forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
              forall (m :: * -> *) a. Monad m => a -> m a
return ()
            )
        forall s. XParser s ()
XT.eq
        [Char]
vi <- forall s a. XParser s a -> XParser s a
XT.quoted forall s. XParser s [Char]
XT.versionNum
        forall (m :: * -> *) a. Monad m => a -> m a
return [QName -> XmlTrees -> XmlTree
mkAttr' ([Char] -> QName
mkName [Char]
a_version) [[Char] -> XmlTree
mkText' [Char]
vi]]
      )
      forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"version info (with quoted version number)"

misc            :: XParser s XmlTree
misc :: forall s. XParser s XmlTree
misc
    = forall s. XParser s XmlTree
comment
      forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
      forall s. XParser s XmlTree
pI
      forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
      ( ( do
          [Char]
ws <- forall s. XParser s [Char]
XT.sPace
          forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> XmlTree
mkText' [Char]
ws)
        ) forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
""
      )

-- ------------------------------------------------------------
--
-- Document Type definition (2.8)

doctypedecl     :: XParser s XmlTrees
doctypedecl :: forall s. XParser s XmlTrees
doctypedecl
    = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (forall tok st a. GenParser tok st a -> GenParser tok st a
try forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
string [Char]
"<!DOCTYPE") (forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'>')
      ( do
        forall s. XParser s ()
XT.skipS
        [Char]
n <- forall s. XParser s [Char]
XT.name
        [([Char], [Char])]
exId <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] ( forall tok st a. GenParser tok st a -> GenParser tok st a
try ( do
                                  forall s. XParser s ()
XT.skipS
                                  forall s. XParser s [([Char], [Char])]
externalID
                                )
                          )
        forall s. XParser s ()
XT.skipS0
        XmlTrees
markup <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option []
                  ( do
                    XmlTrees
m <- forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'[' ) (forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
']') forall s. XParser s XmlTrees
markupOrDeclSep
                    forall s. XParser s ()
XT.skipS0
                    forall (m :: * -> *) a. Monad m => a -> m a
return XmlTrees
m
                  )
        forall (m :: * -> *) a. Monad m => a -> m a
return [DTDElem -> [([Char], [Char])] -> XmlTrees -> XmlTree
mkDTDElem' DTDElem
DOCTYPE (([Char]
a_name, [Char]
n) forall a. a -> [a] -> [a]
: [([Char], [Char])]
exId) XmlTrees
markup]
      )

markupOrDeclSep :: XParser s XmlTrees
markupOrDeclSep :: forall s. XParser s XmlTrees
markupOrDeclSep
    = ( do
        [XmlTrees]
ll <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ( forall s. XParser s XmlTrees
markupdecl
                     forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
                     forall s. XParser s XmlTrees
declSep
                     forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
                     forall s a. XParser s a -> XParser s [a]
XT.mkList forall s. XParser s XmlTree
conditionalSect
                   )
        forall (m :: * -> *) a. Monad m => a -> m a
return (forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [XmlTrees]
ll)
      )

declSep         :: XParser s XmlTrees
declSep :: forall s. XParser s XmlTrees
declSep
    = forall s a. XParser s a -> XParser s [a]
XT.mkList forall s. XParser s XmlTree
XT.peReferenceT
      forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
      ( do
        forall s. XParser s ()
XT.skipS
        forall (m :: * -> *) a. Monad m => a -> m a
return []
      )

markupdecl      :: XParser s XmlTrees
markupdecl :: forall s. XParser s XmlTrees
markupdecl
    = forall s a. XParser s a -> XParser s [a]
XT.mkList
      ( forall s. XParser s XmlTree
pI
        forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
        forall s. XParser s XmlTree
comment
        forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
        forall s. XParser s XmlTree
XD.dtdDeclTokenizer
      )

-- ------------------------------------------------------------
--
-- Standalone Document Declaration (2.9)

sDDecl          :: XParser s XmlTrees
sDDecl :: forall s. XParser s XmlTrees
sDDecl
    = do
      forall tok st a. GenParser tok st a -> GenParser tok st a
try ( forall s. XParser s ()
XT.skipS
            forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
            forall s. [Char] -> XParser s [Char]
XT.keyword [Char]
a_standalone
            forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
            forall (m :: * -> *) a. Monad m => a -> m a
return ()
          )
      forall s. XParser s ()
XT.eq
      [Char]
sd <- forall s a. XParser s a -> XParser s a
XT.quoted (forall s. [[Char]] -> XParser s [Char]
XT.keywords [[Char]
v_yes, [Char]
v_no])
      forall (m :: * -> *) a. Monad m => a -> m a
return [QName -> XmlTrees -> XmlTree
mkAttr' ([Char] -> QName
mkName [Char]
a_standalone) [[Char] -> XmlTree
mkText' [Char]
sd]]

-- ------------------------------------------------------------
--
-- element, tags and content (3, 3.1)

element         :: XParser s XmlTree
element :: forall s. XParser s XmlTree
element
    = forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'<'
      forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
      forall s. XParser s XmlTree
element'

element'         :: XParser s XmlTree
element' :: forall s. XParser s XmlTree
element'
    = ( do
        (QName, XmlTrees)
e <- forall s. XParser s (QName, XmlTrees)
elementStart
        forall a. WNFData a => a -> ()
rwnf (QName, XmlTrees)
e seq :: forall a b. a -> b -> b
`seq` forall s. (QName, XmlTrees) -> XParser s XmlTree
elementRest (QName, XmlTrees)
e              -- evaluate name and attribute list before parsing contents
      ) forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"element"


elementStart            :: XParser s (QName, XmlTrees)
elementStart :: forall s. XParser s (QName, XmlTrees)
elementStart
    = do
      [Char]
n  <- forall s. XParser s [Char]
XT.name
      XmlTrees
al <- forall s. XParser s XmlTrees
attrList
      forall s. XParser s ()
XT.skipS0
      forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> QName
mkName [Char]
n, XmlTrees
al)
      where
      attrList :: ParsecT [Char] (XPState s) Identity XmlTrees
attrList
          = forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] ( do
                        forall s. XParser s ()
XT.skipS
                        ParsecT [Char] (XPState s) Identity XmlTrees
attrList'
                      )
      attrList' :: ParsecT [Char] (XPState s) Identity XmlTrees
attrList'
          = forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] ( do
                        XmlTree
a1 <- forall s. XParser s XmlTree
attribute
                        XmlTrees
al <- ParsecT [Char] (XPState s) Identity XmlTrees
attrList
                        let n :: QName
n = forall a. HasCallStack => Maybe a -> a
fromJust forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. XmlNode a => a -> Maybe QName
getAttrName forall a b. (a -> b) -> a -> b
$ XmlTree
a1
                        if QName
n forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` forall a b. (a -> b) -> [a] -> [b]
map (forall a. HasCallStack => Maybe a -> a
fromJust forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. XmlNode a => a -> Maybe QName
getAttrName) XmlTrees
al
                          then forall s (m :: * -> *) t u a.
Stream s m t =>
[Char] -> ParsecT s u m a
unexpected
                               ( [Char]
"attribute name " forall a. [a] -> [a] -> [a]
++
                                 forall a. Show a => a -> [Char]
show (QName -> [Char]
qualifiedName QName
n) forall a. [a] -> [a] -> [a]
++
                                 [Char]
" occurs twice in attribute list"
                               )
                          else forall (m :: * -> *) a. Monad m => a -> m a
return (XmlTree
a1 forall a. a -> [a] -> [a]
: XmlTrees
al)
                      )

elementRest     :: (QName, XmlTrees) -> XParser s XmlTree
elementRest :: forall s. (QName, XmlTrees) -> XParser s XmlTree
elementRest (QName
n, XmlTrees
al)
    = ( do
        forall s. [Char] -> XParser s ()
XT.checkString [Char]
"/>"
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ QName -> XmlTrees -> XmlTrees -> XmlTree
mkElement' QName
n XmlTrees
al []
      )
      forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
      ( do
        forall s. XParser s ()
XT.gt
        XmlTrees
c <- forall s. XParser s XmlTrees
content
        forall s. QName -> XParser s ()
eTag QName
n
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ QName -> XmlTrees -> XmlTrees -> XmlTree
mkElement' QName
n XmlTrees
al XmlTrees
c
      )
      forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"proper attribute list followed by \"/>\" or \">\""

eTag            :: QName -> XParser s ()
eTag :: forall s. QName -> XParser s ()
eTag QName
n'
    = do
      forall s. [Char] -> XParser s ()
XT.checkString [Char]
"</" forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
""
      [Char]
n <- forall s. XParser s [Char]
XT.name
      forall s. XParser s ()
XT.skipS0
      forall s. XParser s ()
XT.gt
      if [Char]
n forall a. Eq a => a -> a -> Bool
== QName -> [Char]
qualifiedName QName
n'
         then forall (m :: * -> *) a. Monad m => a -> m a
return ()
         else forall s (m :: * -> *) t u a.
Stream s m t =>
[Char] -> ParsecT s u m a
unexpected ([Char]
"illegal end tag </" forall a. [a] -> [a] -> [a]
++ [Char]
n forall a. [a] -> [a] -> [a]
++ [Char]
"> found, </" forall a. [a] -> [a] -> [a]
++ QName -> [Char]
qualifiedName QName
n' forall a. [a] -> [a] -> [a]
++ [Char]
"> expected")

attribute       :: XParser s XmlTree
attribute :: forall s. XParser s XmlTree
attribute
    = do
      [Char]
n <- forall s. XParser s [Char]
XT.name
      forall s. XParser s ()
XT.eq
      XmlTrees
v <- forall s. XParser s XmlTrees
XT.attrValueT
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ QName -> XmlTrees -> XmlTree
mkAttr' ([Char] -> QName
mkName [Char]
n) XmlTrees
v

{- this parser corresponds to the XML spec but it's inefficent because of more than 1 char lookahead

content         :: XParser s XmlTrees
content
    = do
      c1 <- charData
      cl <- many
            ( do
              l <- ( element
                     <|>
                     cDSect
                     <|>
                     pI
                     <|>
                     comment
                   )
              c <- charData
              return (l : c)
            )
      return (c1 ++ concat cl)
-}

-- this simpler content parser does not need more than a single lookahead
-- so no try parsers (inefficient) are neccessary

content         :: XParser s XmlTrees
content :: forall s. XParser s XmlTrees
content
    = XmlTrees -> XmlTrees
XT.mergeTextNodes forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
      forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many
      ( ( do            -- parse markup but no closing tags
          forall tok st a. GenParser tok st a -> GenParser tok st a
try ( forall s. XParser s ()
XT.lt
                forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'/')
                forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                forall (m :: * -> *) a. Monad m => a -> m a
return ()
              )
          forall s. XParser s XmlTree
markup
        )
        forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
        forall s. XParser s XmlTree
charData'
        forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
        forall s. XParser s XmlTree
XT.referenceT
      )
    where
    markup :: ParsecT [Char] (XPState s) Identity XmlTree
markup
        = forall s. XParser s XmlTree
element'
          forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
          forall s. XParser s XmlTree
pI'
          forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
          ( forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'!'
            forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
            ( forall s. XParser s XmlTree
comment'
              forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
              forall s. XParser s XmlTree
cDSect'
            )
          )

contentWithTextDecl     :: XParser s XmlTrees
contentWithTextDecl :: forall s. XParser s XmlTrees
contentWithTextDecl
    = forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall s. XParser s XmlTrees
textDecl
      forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
      forall s. XParser s XmlTrees
content

-- ------------------------------------------------------------
--
-- Conditional Sections (3.4)
--
-- conditional sections are parsed in two steps,
-- first the whole content is detected,
-- and then, after PE substitution include sections are parsed again

conditionalSect         :: XParser s XmlTree
conditionalSect :: forall s. XParser s XmlTree
conditionalSect
    = do
      forall s. [Char] -> XParser s ()
XT.checkString [Char]
"<!["
      XmlTrees
cs <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many forall s. XParser s XmlTree
XD.dtdToken
      Char
_ <- forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'['
      [Char]
sect <- forall s. XParser s [Char]
condSectCont
      forall (m :: * -> *) a. Monad m => a -> m a
return (DTDElem -> [([Char], [Char])] -> XmlTrees -> XmlTree
mkDTDElem' DTDElem
CONDSECT [([Char]
a_value, [Char]
sect)] XmlTrees
cs)
    where

    condSectCont        :: XParser s String
    condSectCont :: forall s. XParser s [Char]
condSectCont
        = ( forall s. [Char] -> XParser s ()
XT.checkString [Char]
"]]>"
            forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
            forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
""
          )
          forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
          ( do
            forall s. [Char] -> XParser s ()
XT.checkString [Char]
"<!["
            [Char]
cs1 <- forall s. XParser s [Char]
condSectCont
            [Char]
cs2 <- forall s. XParser s [Char]
condSectCont
            forall (m :: * -> *) a. Monad m => a -> m a
return ([Char]
"<![" forall a. [a] -> [a] -> [a]
++ [Char]
cs1 forall a. [a] -> [a] -> [a]
++ [Char]
"]]>" forall a. [a] -> [a] -> [a]
++ [Char]
cs2)
          )
          forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
          ( do
            Char
c  <- forall s. XParser s Char
xmlChar
            [Char]
cs <- forall s. XParser s [Char]
condSectCont
            forall (m :: * -> *) a. Monad m => a -> m a
return (Char
c forall a. a -> [a] -> [a]
: [Char]
cs)
          )

-- ------------------------------------------------------------
--
-- External Entities (4.2.2)

externalID      :: XParser s Attributes
externalID :: forall s. XParser s [([Char], [Char])]
externalID
    = ( do
        [Char]
_ <- forall s. [Char] -> XParser s [Char]
XT.keyword [Char]
k_system
        forall s. XParser s ()
XT.skipS
        [Char]
lit <- forall s. XParser s [Char]
XT.systemLiteral
        forall (m :: * -> *) a. Monad m => a -> m a
return [([Char]
k_system, [Char]
lit)]
      )
      forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
      ( do
        [Char]
_ <- forall s. [Char] -> XParser s [Char]
XT.keyword [Char]
k_public
        forall s. XParser s ()
XT.skipS
        [Char]
pl <- forall s. XParser s [Char]
XT.pubidLiteral
        forall s. XParser s ()
XT.skipS
        [Char]
sl <- forall s. XParser s [Char]
XT.systemLiteral
        forall (m :: * -> *) a. Monad m => a -> m a
return [ ([Char]
k_system, [Char]
sl)
               , ([Char]
k_public, [Char]
pl) ]
      )
      forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"SYSTEM or PUBLIC declaration"

-- ------------------------------------------------------------
--
-- Text Declaration (4.3.1)

textDecl        :: XParser s XmlTrees
textDecl :: forall s. XParser s XmlTrees
textDecl
    = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (forall tok st a. GenParser tok st a -> GenParser tok st a
try forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
string [Char]
"<?xml") (forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
string [Char]
"?>")
      ( do
        XmlTrees
vi <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall s. XParser s XmlTrees
versionInfo
        XmlTrees
ed <- forall s. XParser s XmlTrees
encodingDecl
        forall s. XParser s ()
XT.skipS0
        forall (m :: * -> *) a. Monad m => a -> m a
return (XmlTrees
vi forall a. [a] -> [a] -> [a]
++ XmlTrees
ed)
      )
      forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
"text declaration"


textDecl''      :: XParser s XmlTree
textDecl'' :: forall s. XParser s XmlTree
textDecl''
    = do
      XmlTrees
al    <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (forall tok st a. GenParser tok st a -> GenParser tok st a
try forall s. XParser s XmlTrees
textDecl)
      forall (m :: * -> *) a. Monad m => a -> m a
return (XmlTrees -> XmlTrees -> XmlTree
mkRoot' XmlTrees
al [])

-- ------------------------------------------------------------
--
-- Encoding Declaration (4.3.3)

encodingDecl    :: XParser s XmlTrees
encodingDecl :: forall s. XParser s XmlTrees
encodingDecl
    = do
      forall tok st a. GenParser tok st a -> GenParser tok st a
try ( forall s. XParser s ()
XT.skipS
            forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
            forall s. [Char] -> XParser s [Char]
XT.keyword [Char]
a_encoding
            forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
            forall (m :: * -> *) a. Monad m => a -> m a
return ()
          )
      forall s. XParser s ()
XT.eq
      [Char]
ed <- forall s a. XParser s a -> XParser s a
XT.quoted forall s. XParser s [Char]
XT.encName
      forall (m :: * -> *) a. Monad m => a -> m a
return [QName -> XmlTrees -> XmlTree
mkAttr' ([Char] -> QName
mkName [Char]
a_encoding) [[Char] -> XmlTree
mkText' [Char]
ed]]

-- ------------------------------------------------------------
--
-- the main entry points:
--      parsing the content of a text node
--      or parsing the text children from a tag node

-- |
-- the inverse function to 'xshow', (for XML content).
--
-- the string parameter is parsed with the XML content parser.
-- result is the list of trees or in case of an error a single element list with the
-- error message as node. No entity or character subtitution is done here,
-- but the XML parser can do this for the predefined XML or the char references for performance reasons
--
-- see also: 'parseXmlContent'

xread                   :: String -> XmlTrees
xread :: [Char] -> XmlTrees
xread                   = XParser () XmlTrees -> [Char] -> XmlTrees
xread' forall s. XParser s XmlTrees
content         -- take the content parser for parsing the string

xreadDoc                :: String -> XmlTrees
xreadDoc :: [Char] -> XmlTrees
xreadDoc                = XParser () XmlTrees -> [Char] -> XmlTrees
xread' forall s. XParser s XmlTrees
document'       -- take the document' parser for parsing the string

xread'                   :: XParser () XmlTrees -> String -> XmlTrees
xread' :: XParser () XmlTrees -> [Char] -> XmlTrees
xread' XParser () XmlTrees
content' [Char]
str
    = XParser () XmlTrees -> XPState () -> [Char] -> [Char] -> XmlTrees
parseXmlFromString XParser () XmlTrees
parser (forall a. a -> XPState a
withNormNewline ()) [Char]
loc [Char]
str
    where
    loc :: [Char]
loc = [Char]
"string: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (if forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
str forall a. Ord a => a -> a -> Bool
> Int
40 then forall a. Int -> [a] -> [a]
take Int
40 [Char]
str forall a. [a] -> [a] -> [a]
++ [Char]
"..." else [Char]
str)
    parser :: XParser () XmlTrees
parser = do
             XmlTrees
res <- XParser () XmlTrees
content'
             forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof                        -- test on everything consumed
             forall (m :: * -> *) a. Monad m => a -> m a
return XmlTrees
res

-- |
-- the filter version of 'xread'

parseXmlContent         :: XmlTree -> XmlTrees
parseXmlContent :: XmlTree -> XmlTrees
parseXmlContent
    = [Char] -> XmlTrees
xread forall b c a. (b -> c) -> (a -> b) -> a -> c
. XmlTrees -> [Char]
xshow forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[])

-- |
-- a more general version of 'parseXmlContent'.
-- The parser to be used and the context are extra parameter

parseXmlText            :: SimpleXParser XmlTrees -> XPState () -> String -> XmlTree -> XmlTrees
parseXmlText :: XParser () XmlTrees -> XPState () -> [Char] -> XmlTree -> XmlTrees
parseXmlText XParser () XmlTrees
p XPState ()
s0 [Char]
loc   = XParser () XmlTrees -> XPState () -> [Char] -> [Char] -> XmlTrees
parseXmlFromString XParser () XmlTrees
p XPState ()
s0 [Char]
loc forall b c a. (b -> c) -> (a -> b) -> a -> c
. XmlTrees -> [Char]
xshow forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[])

parseXmlDocument        :: String -> String -> XmlTrees
parseXmlDocument :: [Char] -> [Char] -> XmlTrees
parseXmlDocument        = XParser () XmlTrees -> XPState () -> [Char] -> [Char] -> XmlTrees
parseXmlFromString forall s. XParser s XmlTrees
document' (forall a. a -> XPState a
withNormNewline ())

parseXmlFromString      :: SimpleXParser XmlTrees -> XPState () -> String -> String -> XmlTrees
parseXmlFromString :: XParser () XmlTrees -> XPState () -> [Char] -> [Char] -> XmlTrees
parseXmlFromString XParser () XmlTrees
parser XPState ()
s0 [Char]
loc
    = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ((forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Char] -> XmlTree
mkError' Int
c_err forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. [a] -> [a] -> [a]
++ [Char]
"\n") forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> [Char]
show) forall a. a -> a
id
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall tok st a.
GenParser tok st a -> st -> [Char] -> [tok] -> Either ParseError a
runParser XParser () XmlTrees
parser XPState ()
s0 [Char]
loc

-- ------------------------------------------------------------
--

removeEncodingSpec      :: XmlTree -> XmlTrees
removeEncodingSpec :: XmlTree -> XmlTrees
removeEncodingSpec XmlTree
t
    | forall a. XmlNode a => a -> Bool
isText XmlTree
t
        = ( forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ((forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Char] -> XmlTree
mkError' Int
c_err forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. [a] -> [a] -> [a]
++ [Char]
"\n") forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> [Char]
show) ((forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> XmlTree
mkText')
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall tok st a.
GenParser tok st a -> st -> [Char] -> [tok] -> Either ParseError a
runParser forall s. XParser s [Char]
parser (forall a. a -> XPState a
withNormNewline ()) [Char]
"remove encoding spec"
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe [Char]
""
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. XmlNode a => a -> Maybe [Char]
getText
          ) XmlTree
t
    | Bool
otherwise
        = [XmlTree
t]
    where
    parser :: XParser s String
    parser :: forall s. XParser s [Char]
parser = forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall s. XParser s XmlTrees
textDecl
             forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
             forall (m :: * -> *) s u. Monad m => ParsecT s u m s
getInput

-- ------------------------------------------------------------

-- |
-- general parser for parsing arbitray parts of a XML document

parseXmlPart    :: SimpleXParser XmlTrees -> String -> String -> XmlTree -> XmlTrees
parseXmlPart :: XParser () XmlTrees -> [Char] -> [Char] -> XmlTree -> XmlTrees
parseXmlPart XParser () XmlTrees
parser [Char]
expected [Char]
context XmlTree
t
    = XParser () XmlTrees -> XPState () -> [Char] -> XmlTree -> XmlTrees
parseXmlText
      ( do
        XmlTrees
res <- XParser () XmlTrees
parser
        forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof forall s u (m :: * -> *) a.
ParsecT s u m a -> [Char] -> ParsecT s u m a
<?> [Char]
expected
        forall (m :: * -> *) a. Monad m => a -> m a
return XmlTrees
res
      ) (forall a. a -> XPState a
withoutNormNewline ()) [Char]
context
      forall a b. (a -> b) -> a -> b
$ XmlTree
t

-- ------------------------------------------------------------

-- |
-- Parser for parts of a DTD

parseXmlDTDPart :: String -> XmlTree -> XmlTrees
parseXmlDTDPart :: [Char] -> XmlTree -> XmlTrees
parseXmlDTDPart
    = XParser () XmlTrees -> [Char] -> [Char] -> XmlTree -> XmlTrees
parseXmlPart forall s. XParser s XmlTrees
markupOrDeclSep [Char]
"markup declaration"

-- ------------------------------------------------------------

-- |
-- Parser for general entites

parseXmlEntityValueAsContent      :: String -> XmlTree -> XmlTrees
parseXmlEntityValueAsContent :: [Char] -> XmlTree -> XmlTrees
parseXmlEntityValueAsContent
    = XParser () XmlTrees -> [Char] -> [Char] -> XmlTree -> XmlTrees
parseXmlPart forall s. XParser s XmlTrees
content [Char]
"general entity value"

-- ------------------------------------------------------------

-- |
-- Parser for entity substitution within attribute values

parseXmlEntityValueAsAttrValue       :: String -> XmlTree -> XmlTrees
parseXmlEntityValueAsAttrValue :: [Char] -> XmlTree -> XmlTrees
parseXmlEntityValueAsAttrValue
    = XParser () XmlTrees -> [Char] -> [Char] -> XmlTree -> XmlTrees
parseXmlPart (forall s. [Char] -> XParser s XmlTrees
XT.attrValueT' [Char]
"<&") [Char]
"attribute value"

-- ------------------------------------------------------------

-- |
-- Parser for NMTOKENs

parseNMToken            :: String -> XmlTree -> XmlTrees
parseNMToken :: [Char] -> XmlTree -> XmlTrees
parseNMToken
    = XParser () XmlTrees -> [Char] -> [Char] -> XmlTree -> XmlTrees
parseXmlPart (forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 forall s. XParser s XmlTree
XT.nmtokenT) [Char]
"nmtoken"

-- ------------------------------------------------------------

-- |
-- Parser for XML names

parseName               :: String -> XmlTree -> XmlTrees
parseName :: [Char] -> XmlTree -> XmlTrees
parseName
    = XParser () XmlTrees -> [Char] -> [Char] -> XmlTree -> XmlTrees
parseXmlPart (forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 forall s. XParser s XmlTree
XT.nameT) [Char]
"name"

-- ------------------------------------------------------------

-- |
-- try to parse a xml encoding spec.
--
--
--    * 1.parameter encParse :  the parser for the encoding decl
--
--    - 2.parameter root :  a document root
--
--    - returns : the same tree, but with an additional
--                        attribute \"encoding\" in the root node
--                        in case of a valid encoding spec
--                        else the unchanged tree

parseXmlEncodingSpec    :: SimpleXParser XmlTree -> XmlTree -> XmlTrees
parseXmlEncodingSpec :: SimpleXParser XmlTree -> XmlTree -> XmlTrees
parseXmlEncodingSpec SimpleXParser XmlTree
encDecl XmlTree
x
    = (forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      ( if forall a. XmlNode a => a -> Bool
isRoot XmlTree
x
        then XmlTree -> XmlTree
parseEncSpec
        else forall a. a -> a
id
      ) forall a b. (a -> b) -> a -> b
$ XmlTree
x
    where
    parseEncSpec :: XmlTree -> XmlTree
parseEncSpec XmlTree
r
        = case ( forall tok st a.
GenParser tok st a -> st -> [Char] -> [tok] -> Either ParseError a
runParser SimpleXParser XmlTree
encDecl (forall a. a -> XPState a
withNormNewline ()) [Char]
source
                 forall b c a. (b -> c) -> (a -> b) -> a -> c
. XmlTrees -> [Char]
xshow
                 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Tree t => t a -> [t a]
getChildren
                 forall a b. (a -> b) -> a -> b
$ XmlTree
r
               ) of
          Right XmlTree
t
              -> forall a. XmlNode a => (XmlTrees -> XmlTrees) -> a -> a
changeAttrl (XmlTrees -> XmlTrees -> XmlTrees
mergeAttrl forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe [] forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. XmlNode a => a -> Maybe XmlTrees
getAttrl forall a b. (a -> b) -> a -> b
$ XmlTree
t) XmlTree
r
          Left ParseError
_
              -> XmlTree
r
        where
        -- arrow \"getAttrValue a_source\" programmed on the tree level (oops!)
        source :: [Char]
source = XmlTrees -> [Char]
xshow
                 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat
                 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall (t :: * -> *) a. Tree t => t a -> [t a]
getChildren
                 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
filter ((forall a. Eq a => a -> a -> Bool
== [Char]
a_source)
                 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. b -> (a -> b) -> Maybe a -> b
maybe [Char]
"" QName -> [Char]
qualifiedName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. XmlNode a => a -> Maybe QName
getAttrName)
                 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe []
                 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. XmlNode a => a -> Maybe XmlTrees
getAttrl forall a b. (a -> b) -> a -> b
$ XmlTree
r

parseXmlEntityEncodingSpec      :: XmlTree -> XmlTrees
parseXmlEntityEncodingSpec :: XmlTree -> XmlTrees
parseXmlEntityEncodingSpec      = SimpleXParser XmlTree -> XmlTree -> XmlTrees
parseXmlEncodingSpec forall s. XParser s XmlTree
textDecl''

parseXmlDocEncodingSpec         :: XmlTree -> XmlTrees
parseXmlDocEncodingSpec :: XmlTree -> XmlTrees
parseXmlDocEncodingSpec         = SimpleXParser XmlTree -> XmlTree -> XmlTrees
parseXmlEncodingSpec forall s. XParser s XmlTree
xMLDecl''

-- ------------------------------------------------------------