diff --git a/Makefile b/Makefile deleted file mode 100644 --- a/Makefile +++ /dev/null @@ -1,138 +0,0 @@ -include Version.mk - -HXT_HOME = . - -DIST = $(DIST_NAME) -DIST_TAR = $(DIST_NAME).tar.gz -DIST_FILES = Makefile Version.mk README LICENCE Setup.lhs $(SOFTWARE).cabal - -SETUP = Setup.lhs - -VERSIONTAG = $(DIST_NAME) -PUBDATE := $(shell date +%Y-%m-%d) - -EDIT_VERSION = sed 's/%DISTFILE%/$(DIST_NAME)/g' \ - | sed 's/%VERSION%/$(VERSION)/g' \ - | sed 's/%PUBDATE%/$(PUBDATE)/g' - -HSCOLOUR = HsColour -HSCOLOUR_CSS = doc/hscolour.css - -# -------------------------------------------------- - -all : - $(MAKE) -C src all - $(MAKE) $(SOFTWARE).cabal - -allexamples : - $(MAKE) -C examples all - -test : - $(MAKE) -C examples test - -# ------------------------------------------------------------ - -cabal : - $(MAKE) cabal_configure cabal_build cabal_doc cabal_install - -cabal_configure : - runhaskell $(SETUP) configure --global - -cabal_doc : - $(HSCOLOUR) -print-css > $(HSCOLOUR) - runhaskell $(SETUP) haddock --hyperlink-source --hscolour-css=$(HSCOLOUR) - rm -f $(HSCOLOUR) - -cabal_build : - runhaskell $(SETUP) build - -cabal_install : - sudo runhaskell $(SETUP) install --global - -# ------------------------------------------------------------ - -$(SOFTWARE).cabal : src/$(SOFTWARE)-package.hs src/Makefile Makefile - $(MAKE) -C src ../$(SOFTWARE).cabal - -DOC_HXT = $(DIST)/doc/$(SOFTWARE) - -doc : $(SOFTWARE).cabal - $(MAKE) cabal_configure cabal_doc - [ -d $(DOC_HXT) ] || mkdir -p $(DOC_HXT) - ( cd dist/doc/html/$(SOFTWARE) ; tar cf - . ) | ( cd $(DOC_HXT) ; tar xf - ) - -dist : all doc - [ -d $(DIST) ] || mkdir -p $(DIST) - $(MAKE) -C src dist - $(MAKE) -C examples dist - cp $(DIST_FILES) $(DIST) - -tarball : dist - tar -zcvf $(DIST_TAR) $(DIST) - -# ------------------------------------------------------------ - -clean : - $(MAKE) -C src clean - $(MAKE) -C examples clean - rm -rf $(DIST) $(DIST_TAR) $(SOFTWARE).cabal .setup-config .installed-pkg-config dist - -# ------------------------------------------------------------ - -tag : - darcs tag $(VERSIONTAG) . - -install : - $(MAKE) -C src install - -uninstall : - $(MAKE) -C src uninstall - -DISTDATE = $(shell date -r $(DIST_TAR) +%Y-%m-%d.%R) - -distcopy : $(DIST_TAR) - scp $(DIST_TAR) hxt@darcs.fh-wedel.de:/home/hxt/$(SOFTWARE)/$(SOFTWARE)-head-$(DISTDATE).tar.gz - -# -------------------------------------------------- - -.PHONY : all doc test dist clean tag install uninstall tarball webpage cleanwebpage - -# -------------------------------------------------- - -# Create webpage directory for distribution - -WEBHOME = ../../../fh/public_html/HXmlToolbox - -webpage : tarball - [ -d $(WEBHOME) ] || exit 1 - [ -d $(WEBHOME)/hdoc-filter ] || mkdir -p $(WEBHOME)/hdoc-filter - cp -r dist/doc/html/$(SOFTWARE)/* $(WEBHOME)/hdoc-filter - cp $(DIST_TAR) $(WEBHOME) - -# -------------------------------------------------- - -# make a clean installation from distribution tar - -PROD_DIR = ~/tmp -INSTALL = echo now run: "(" cd $(PROD_DIR)/$(DIST) ";" -INSTEND = ")" - -distbuild : tarball - ( [ -f $(DIST_TAR) ] || exit 1 \ - ; cp -f $(DIST_TAR) $(PROD_DIR) || exit 1 \ - ; cd $(PROD_DIR) || exit 1 \ - ; rm -rf $(DIST) \ - ; tar xvzf $(DIST_TAR) \ - ; cd $(DIST) || exit 1 \ - ; runhaskell $(SETUP) configure || exit 1 \ - ; runhaskell $(SETUP) build || exit 1 \ - ; $(INSTALL) sudo runhaskell $(SETUP) install --global $(INSTEND) \ - ) - -distinstall : - $(MAKE) distbuild INSTALL="" INSTEND="" - -# -------------------------------------------------- -# - -# end Makefile diff --git a/README b/README deleted file mode 100644 --- a/README +++ /dev/null @@ -1,23 +0,0 @@ -The Haskell XML Toolbox is a collection of tools for processing XML with -Haskell. - -The Haskell XML Toolbox is available from: - http://www.fh-wedel.de/~si/HXmlToolbox/ -or from hackage.haskell.org - -Detailed information about the features, changes, requirements, installation and documentation -is available from that web page. - -This is the "old" approach with the filters like in HaXmL. -The package name for these modules is "hxt-filter". -It requires the "hxt" package to be installed. -For new projects we strongly recomend the -library based on arrows (package "hxt"). - -Installation can be done with cabal in the usual way. - -Good luck, - -Uwe Schmidt - -(uwe@fh-wedel.de) diff --git a/Version.mk b/Version.mk deleted file mode 100644 --- a/Version.mk +++ /dev/null @@ -1,7 +0,0 @@ -# Version.mk -# Version numbering for HXT filter package - -SOFTWARE = hxt-filter -VERSION = 8.3.0 -LASTVERSION = 8.2.0 -DIST_NAME = $(SOFTWARE)-$(VERSION) diff --git a/doc/hxt-filter/Control-Monad-MonadStateIO.html b/doc/hxt-filter/Control-Monad-MonadStateIO.html deleted file mode 100644 --- a/doc/hxt-filter/Control-Monad-MonadStateIO.html +++ /dev/null @@ -1,487 +0,0 @@ - - -Control.Monad.MonadStateIO
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Control.Monad.MonadStateIO
Description

general usefull state monad for a local state and IO -

This module is used for threading a state and io actions - through a computation. - Here the monad is constructed by hand. - It could easily be refactored with the use of the monad transformer library. -

Synopsis
newtype StateIO state res = STIO {
trans :: state -> IO (res, state)
}
io :: IO a -> StateIO state a
trcState :: (state -> String) -> StateIO state ()
changeState :: (state -> state) -> StateIO state state
setState :: state -> StateIO state state
getState :: StateIO state state
run :: state -> StateIO state res -> IO res
Documentation
newtype StateIO state res Source
Constructors
STIO
trans :: state -> IO (res, state)
show/hide Instances
Monad (StateIO state)
io :: IO a -> StateIO state aSource
lift IO command to StateIO -
trcState :: (state -> String) -> StateIO state ()Source
state inspection command: a "show"-like function is applied to the state - and the result is written to stderr. -
changeState :: (state -> state) -> StateIO state stateSource
change the state with a given function and return the new state -
setState :: state -> StateIO state stateSource
set the state -
getState :: StateIO state stateSource
read the state -
run :: state -> StateIO state res -> IO resSource
run a StateIO command with an initial state -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Data-Tree-NTree-Filter.html b/doc/hxt-filter/Data-Tree-NTree-Filter.html deleted file mode 100644 --- a/doc/hxt-filter/Data-Tree-NTree-Filter.html +++ /dev/null @@ -1,3754 +0,0 @@ - - -Data.Tree.NTree.Filter
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Data.Tree.NTree.Filter
Portabilityportable
Stabilitystable
MaintainerUwe Schmidt (uwe\@fh-wedel.de)
Contents
Filter -
Monadic Filter -
Description

Filter for n-ary tree structure with filter combinators - copied and modified from HaXml (http://www.cs.york.ac.uk/fp/HaXml/) -

Similar but more flexible functions for tree processing are defined in the - arrow classes Control.Arrow.ArrowList, Control.Arrow.ArrowIf, Control.Arrow.ArrowTree and Control.Arrow.ArrowState. - For new applications, especially for XML processing, it's recommended to use the arrow interface - Text.XML.HXT.Arrow instead of this filter approach as part of the api Text.XML.HXT.Parser -

Synopsis
type TFilter node = NTree node -> NTrees node
type TSFilter node = NTrees node -> NTrees node
satisfies :: (a -> [b]) -> a -> Bool
none :: a -> [b]
this :: a -> [a]
isOf :: (a -> Bool) -> a -> [a]
isOfNode :: (node -> Bool) -> TFilter node
mkNTree :: NTree node -> TFilter node
replaceNode :: node -> TFilter node
replaceChildren :: NTrees node -> TFilter node
modifyNode :: (node -> Maybe node) -> TFilter node
modifyNode0 :: (node -> node) -> TFilter node
modifyChildren :: TSFilter node -> TFilter node
substChildren :: TFilter node -> TFilter node
processChildren :: TFilter node -> TFilter node
o :: (a -> [b]) -> (c -> [a]) -> c -> [b]
(.>) :: (a -> [b]) -> (b -> [c]) -> a -> [c]
seqF :: [a -> [a]] -> a -> [a]
(..>) :: (a -> [b]) -> (a -> b -> [d]) -> a -> [d]
(+++) :: (a -> [b]) -> (a -> [b]) -> a -> [b]
cat :: [a -> [b]] -> a -> [b]
orElse :: (a -> [b]) -> (a -> [b]) -> a -> [b]
iff :: (a -> [c]) -> (a -> [b]) -> (a -> [b]) -> a -> [b]
choice :: [IfThen (a -> [c]) (a -> [b])] -> a -> [b]
data IfThen a b = a :-> b
when :: (a -> [a]) -> (a -> [a]) -> a -> [a]
whenNot :: (a -> [a]) -> (a -> [a]) -> a -> [a]
guards :: (a -> [b]) -> (a -> [b]) -> a -> [b]
neg :: (a -> [c]) -> a -> [a]
containing :: (a -> [b]) -> (b -> [c]) -> a -> [b]
notContaining :: (a -> [b]) -> (b -> [c]) -> a -> [b]
(/>) :: TFilter node -> TFilter node -> TFilter node
(</) :: TFilter node -> TFilter node -> TFilter node
deep :: TFilter node -> TFilter node
deepest :: TFilter node -> TFilter node
multi :: TFilter node -> TFilter node
processBottomUp :: TFilter node -> TFilter node
processBottomUpIfNot :: TFilter node -> TFilter node -> TFilter node
processTopDown :: TFilter node -> TFilter node
processTopDownUntil :: TFilter node -> TFilter node
insertChildrenAt :: Int -> TFilter node -> TFilter node
insertChildrenAfter :: TFilter node -> TFilter node -> TFilter node
thisM :: Monad m => a -> m [a]
noneM :: Monad m => a -> m [b]
(.>>) :: Monad m => (a -> m [b]) -> (b -> m [c]) -> a -> m [c]
seqM :: Monad m => [a -> m [a]] -> a -> m [a]
(+++>>) :: Monad m => (a -> m [b]) -> (a -> m [b]) -> a -> m [b]
catM :: Monad m => [a -> m [b]] -> a -> m [b]
ifM :: Monad m => (a -> [b]) -> (a -> m [c]) -> (a -> m [c]) -> a -> m [c]
choiceM :: Monad m => [IfThen (a -> [c]) (a -> m [b])] -> a -> m [b]
whenM :: Monad m => (a -> m [a]) -> (a -> [b]) -> a -> m [a]
whenNotM :: Monad m => (a -> m [a]) -> (a -> [b]) -> a -> m [a]
guardsM :: Monad m => (a -> [b]) -> (a -> m [c]) -> a -> m [c]
containingM :: Monad m => (a -> m [b]) -> (b -> [c]) -> a -> m [b]
processChildrenM :: Monad m => (NTree node -> m [NTree node]) -> NTree node -> m [NTree node]
processTopDownM :: Monad m => (NTree node -> m [NTree node]) -> NTree node -> m [NTree node]
processBottomUpM :: Monad m => (NTree node -> m [NTree node]) -> NTree node -> m [NTree node]
liftMf :: Monad m => (a -> [b]) -> a -> m [b]
($$) :: (a -> [b]) -> [a] -> [b]
($$<) :: Monad m => (a -> m [b]) -> [a] -> m [b]
performAction :: Monad m => (a -> m b) -> a -> m [a]
Documentation
type TFilter node = NTree node -> NTrees nodeSource

tree filter type: a function mapping a tree onto a list of trees -

filter can be used in various ways, as predicates, selectors, transformers, ... -

type TSFilter node = NTrees node -> NTrees nodeSource
a filter for sequences -
satisfies :: (a -> [b]) -> a -> BoolSource

satisfies converts a result of a predicate filter into a boolean -

is a shortcut for not . null -

typical use in guards or ifs: if (satisfies f) t then ... else ... -

  • 1.parameter f : the predicate filter -
  • 2.parameter t : the tree to be tested -
  • returns : b = not (null (f t)) -
Filter -
none :: a -> [b]Source
the null filter, returns the empty list -
this :: a -> [a]Source
the unit filter, returns the single element list containing the argument -
isOf :: (a -> Bool) -> a -> [a]Source

conversion from predicate function to filter -

  • 1.parameter p : the predicate for testing the tree -
  • returns : this or none depending on the predicate -
isOfNode :: (node -> Bool) -> TFilter nodeSource

select filter, selects trees with node values with a specific property -

  • 1.parameter p : the predicate for testing the node value -
  • returns : [] or [t] depending on p t -

a special case of isOf filter -

mkNTree :: NTree node -> TFilter nodeSource

filter for substituting an arbitray tree by a constant -

  • 1.parameter t : the result tree, the input tree is ignored -
  • returns : the filter -
replaceNode :: node -> TFilter nodeSource

filter for replacing the node -

  • 1.parameter n : the new node -
  • returns : the editing filter -
replaceChildren :: NTrees node -> TFilter nodeSource

filter for replacing the children -

  • 1.parameter cs : cs the list of children -
  • returns : the filter -
modifyNode :: (node -> Maybe node) -> TFilter nodeSource
modifyNode0 :: (node -> node) -> TFilter nodeSource

filter for editing the node -

  • 1.parameter nf : the XNode editing funtion -
  • returns : the filter -
modifyChildren :: TSFilter node -> TFilter nodeSource

filter for editing the children -

all children are processed with a filter mapping lists to lists, - this enables not only elementwise editing by lifting a normal - filter to a list filter with (f $$) (see '($$)') but also manipulation - of the order of the elements, e.g. reverse is an appropriate childen - editing function. -

  • 1.parameter csf : the children editing function -
  • returns : the filter -

see also : processChildren -

substChildren :: TFilter node -> TFilter nodeSource
filter for substituting the children of a tree by - a new list of childen computed by applying a filter to the input tree. - modifyChildren can be expressed by substChildren: - modifyChildren f t is equal to substChildren (f . getChildren) -
processChildren :: TFilter node -> TFilter nodeSource

Filter for editing the children of a tree element wise -

  • 1.parameter cf : the filter applied to the children -
  • returns : the editing filter -

see also : modifyChildren -

o :: (a -> [b]) -> (c -> [a]) -> c -> [b]Source

sequential composition of filters, usually written in infix notation f2 o f1. -

for predicate filter the logical AND -

  • 1.parameter f2 : the 2. filter -
  • 2.parameter f1 : the 1. filter -
  • returns : the fiter applying first f1 to n and then f2 to the result (like function composition) -
(.>) :: (a -> [b]) -> (b -> [c]) -> a -> [c]Source

pronounced "followed by", defined as: f .> g = g `o` f. -

allows filter composition in a more readable way from left to right -

  • 1.parameter f1 : the 1. filter -
  • 2.parameter f2 : the 2. filter -
  • returns : the composition of f1 and f2 -

see also : o, '(..>)' -

seqF :: [a -> [a]] -> a -> [a]Source

apply a list of filters sequentially with '(.>)', for predicate filters the generalized AND -

see also : '(.>)' -

(..>) :: (a -> [b]) -> (a -> b -> [d]) -> a -> [d]Source

special sequential composition. -

filter f is applied to an argument t. - then filter g is applied to all elements of the result list, - but the argument t is also passed as extra parameter to g. -

This allows for step by step transformations of a tree - with access to the original tree in every - transformation step. -

see also : '(.>)', o -

(+++) :: (a -> [b]) -> (a -> [b]) -> a -> [b]Source

binary parallel composition, the logical OR for predicate filter -

  • 1.parameter f1 : the 1. filter -
  • 2.parameter f2 : the 2. filter -
  • returns : the filter for applying f1 and f2 both to an argument tree and concatenating the results -
cat :: [a -> [b]] -> a -> [b]Source

apply a list of filters, a "union" for lists, for predicate filters the generalized OR -

  • 1.parameter fs : the list of filters -
  • returns : the composing filter -
orElse :: (a -> [b]) -> (a -> [b]) -> a -> [b]Source

directional choice, usually written in infix notation as f orElse g -

  • 1.parameter f : the 1. filter -
  • 2.parameter g : the 2. filter -
  • 3.parameter t : the tree -
  • returns : the filter, that applies f to t, if the result is not the empty list, the result is found, else g t is the result -
iff :: (a -> [c]) -> (a -> [b]) -> (a -> [b]) -> a -> [b]Source

if then else lifted to filters -

  • 1.parameter p : the predicate filter -
  • 2.parameter t : the "then" filter -
  • 3.parameter e : the "else" filter -
  • returns : the resulting conditional filter -
choice :: [IfThen (a -> [c]) (a -> [b])] -> a -> [b]Source

multiway branch. The list of cases f :-> g is processed sequentially, - in the first case for that f holds g is applied, if no case matches, none is - applied. - This filter can be used like a case expression: choice [ p1 :-> f1, p2 :-> f2, ... , this :-> defaultFilter] -

see also : iff, choiceM -

data IfThen a b Source
auxiliary datatype for cases within choice filter -
Constructors
a :-> b
when :: (a -> [a]) -> (a -> [a]) -> a -> [a]Source

when the predicate p holds, f is applied, else the identity filter this -

  • 1.parameter f : the conditinally applied filter -
  • 2.parameter p : the predicate -
  • returns : the conditional filter -

see also : iff, whenNot, guards, whenM -

whenNot :: (a -> [a]) -> (a -> [a]) -> a -> [a]Source

the complementary filter of when -

shortcut for f when neg g -

see also : iff, when, whenNotM, neg -

guards :: (a -> [b]) -> (a -> [b]) -> a -> [b]Source

when the predicate p holds, f is applied, else the null filter none -

  • 1.parameter p : the predicate filter -
  • 2.parameter f : the conditionally applied filter -
  • returns : the conditional filter -

see also : iff, when, guardsM -

neg :: (a -> [c]) -> a -> [a]Source

negation lifted to filters -

  • 1.parameter f : the predicate filter -
  • returns : the filter, that succeeds, when f failed -
containing :: (a -> [b]) -> (b -> [c]) -> a -> [b]Source

pruning: keep only those results from f for which g holds, usually written in infix notation as f containing g -

  • 1.parameter f : the processing filter -
  • 2.parameter g : the predicate filter -
  • 3.parameter t : the tree -
  • returns : all trees r from f t, for which g r holds (is not the empty list) -

see also : notContaining -

notContaining :: (a -> [b]) -> (b -> [c]) -> a -> [b]Source

pruning: keep only those results from f for which g does not hold -

see also : containing -

(/>) :: TFilter node -> TFilter node -> TFilter nodeSource
pronounced "slash", meaning g inside f -
(</) :: TFilter node -> TFilter node -> TFilter nodeSource
pronounced "outside" meaning f containing g -
deep :: TFilter node -> TFilter nodeSource

top down search. -

search terminates, when filter f succeeds - can e.g. be used for finding all outermost tag node of a specific kind -

deepest :: TFilter node -> TFilter nodeSource

bottom up search. -

first the children are processed, - if this does not succeed, the node itself is processed - can e.g. be used for finding all innermost tag nodes of a specific kind -

multi :: TFilter node -> TFilter nodeSource

process all nodes of the whole tree. -

can e.g. be used for finding all nodes of a specific kind -

processBottomUp :: TFilter node -> TFilter nodeSource

bottom up transformation -

  • 1.parameter f : the simple transforming filter -
  • returns : the filter that applies f to all subtrees and the tree itself in a deepth first left to right manner -

see also : processTopDown, processBottomUpIfNot -

processBottomUpIfNot :: TFilter node -> TFilter node -> TFilter nodeSource

guarded bottom up transformation, stops at subtrees for which a predicate p holds -

  • 1.parameter f : the transforming filter -
  • 2.parameter p : the predicate filter for the guard -
  • returns : the filter for processing all (sub-)trees -

see also : processBottomUp -

processTopDown :: TFilter node -> TFilter nodeSource

top down transformation -

  • 1.parameter f : the simple transforming filter -
  • returns : the filter that applies f first to the tree and then recursively to all subtrees of the result -

see also : processBottomUp -

processTopDownUntil :: TFilter node -> TFilter nodeSource

top down transformation until a node to be transformed is found -

  • 1.parameter f : the simple transforming filter -
  • returns : the filter that applies f first to the tree and, if the filter does not succeed, - recursively to all children of the input tree. -

Example: -

processTopDownUntil none

is the identity filter (maybe a bit more inefficient). -

Example: -

processTopDownUntil (add1Attr "border" "2" `containing` isTag "table")

is a filter for adding an attribute border="2" in all top level table tags. - The content of table tags will remain unchanged. -

see also : processTopDown, processBottomUp -

insertChildrenAt :: Int -> TFilter node -> TFilter nodeSource

insertion of trees into the list of children at a given position -

useful for inserting something into the list of children at a given position - the list of children is split with the splitAt function - the nodes are inserted between these two sublists. -

examples: insertChildrenAt 0 ins t inserts all elements computed with ins t in front - of the childen of t, insertChildrenAt 1 ins t behind the first child -

see also: insertChildrenAfter -

insertChildrenAfter :: TFilter node -> TFilter node -> TFilter nodeSource

insertion of trees into the list of children after specific elements -

useful for inserting something into the list of children of a node - the list of children is split with the span function and the filter p as predicate - the nodes are inserted between these two sublists -

examples: insertChildrenAfter none ins t inserts all elements computed with ins t in front - of the childen of t, insertChildrenAfter this ins t appends the elements to the children -

see also: insertChildrenAt -

Monadic Filter -
thisM :: Monad m => a -> m [a]Source

the monadic version of the identity filter this. -

see also : this -

noneM :: Monad m => a -> m [b]Source

the monadic version of the null filter none. -

see also : none -

(.>>) :: Monad m => (a -> m [b]) -> (b -> m [c]) -> a -> m [c]Source

sequential composition of monadic filters, monadic version of ".>". -

  • 1.parameter f1 : the 1. monadic filter -
  • 2.parameter f2 : the 2. monadic filter -
  • returns : the monadic fiter applying first f1 to n and then f2 to the result (like function composition) -

see also : '(.>)' -

seqM :: Monad m => [a -> m [a]] -> a -> m [a]Source
generalized sequential composition of monadic filters -
(+++>>) :: Monad m => (a -> m [b]) -> (a -> m [b]) -> a -> m [b]Source

binary parallel composition, the logical OR for predicate filter -

  • 1.parameter f1 : the 1. filter -
  • 2.parameter f2 : the 2. filter -
  • returns : the filter for applying f1 and f2 both to an argument tree and concatenating the results - see also: cat, +++, catM -
catM :: Monad m => [a -> m [b]] -> a -> m [b]Source

apply a list of monadic filters -

  • 1.parameter fs : the list of filters -
  • returns : the composing filter - see also: cat, +++, +++>> -
ifM :: Monad m => (a -> [b]) -> (a -> m [c]) -> (a -> m [c]) -> a -> m [c]Source

monadic if-then-else. -

  • 1.parameter p : the predicate -
  • 2.parameter thenP : the then part: the monadic filter, that is applied if p holds for the input tree -
  • 3.parameter elseP : the else part -
  • returns : the monadic filter for the conditional -
choiceM :: Monad m => [IfThen (a -> [c]) (a -> m [b])] -> a -> m [b]Source

monadic version of multiway branch. The list of cases f :-> g is processed sequentially, - in the first case for that f holds g is applied, if no case matches, noneM is - applied. - This filter can be used like a case expression: choiceM [ p1 :-> f1, p2 :-> f2, ... , thisM :-> defaultFilter] -

see also : choice, ifM -

whenM :: Monad m => (a -> m [a]) -> (a -> [b]) -> a -> m [a]Source

when the predicate p holds, the monadic filter f is applied, else the identity filter. -

  • 1.parameter f : the conditinally applied monadic filter -
  • 2.parameter p : the simple predicate -
  • returns : the conditional filter -

see also : ifM, when, guardsM, whenNotM -

whenNotM :: Monad m => (a -> m [a]) -> (a -> [b]) -> a -> m [a]Source

the complementary filter of whenM. -

see also : ifM, whenM, whenNot -

guardsM :: Monad m => (a -> [b]) -> (a -> m [c]) -> a -> m [c]Source

when the predicate p holds, the monadic filter f is applied, else the null filter. -

  • 1.parameter p : the simple predicate filter -
  • 2.parameter f : the conditionally applied monadic filter -
  • returns : the conditional filter -

see also : ifM, guards, whenM -

containingM :: Monad m => (a -> m [b]) -> (b -> [c]) -> a -> m [b]Source

pruning: monadic version of containing, usually written in infix notation as f containingM g -

  • 1.parameter f : the monadic processing filter -
  • 2.parameter g : the predicate filter -
  • 3.parameter t : the tree -
  • returns : all trees r from f t, for which g r holds (is not the empty list) -

see also : notContaining -

processChildrenM :: Monad m => (NTree node -> m [NTree node]) -> NTree node -> m [NTree node]Source

Filter for editing the children of a tree with a monadic filter -

  • 1.parameter cf : the monadic filter applied to the children -
  • returns : the monadic editing filter -

see also : processChildren -

processTopDownM :: Monad m => (NTree node -> m [NTree node]) -> NTree node -> m [NTree node]Source
monadic variant of processTopDown -
processBottomUpM :: Monad m => (NTree node -> m [NTree node]) -> NTree node -> m [NTree node]Source
monadic variant of processBottomUp -
liftMf :: Monad m => (a -> [b]) -> a -> m [b]Source

lift a filter to a monadic filter -

  • 1.parameter f : the simple filter -
  • returns : the lifted monadic version -
($$) :: (a -> [b]) -> [a] -> [b]Source

infix operator for applying a filter to a list of trees -

  • 1.parameter f : the filter -
  • 2.parameter ts : the list of trees -
  • returns : the concatenated list of results -
($$<) :: Monad m => (a -> m [b]) -> [a] -> m [b]Source

infix operator for applying a monadic filter to a list of trees, - typically used in do-notation for processing of intermediate results. -

  • 1.parameter f : the monadic filter -
  • 2.parameter ts : the list of trees -
  • returns : the concatenated list of results -

see also : '($$)' -

performAction :: Monad m => (a -> m b) -> a -> m [a]Source

run an arbitray command on a tree t and return the tree, - used for inserting arbitray commands in a filter pipeline -

  • 1.parameter cmd : the command -
  • 2.parameter t : the argument tree -
  • returns : the unchanged tree as a single element list -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/System-PipeOpen.html b/doc/hxt-filter/System-PipeOpen.html deleted file mode 100644 --- a/doc/hxt-filter/System-PipeOpen.html +++ /dev/null @@ -1,190 +0,0 @@ - - -System.PipeOpen
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
System.PipeOpen
Portabilitynone portable
Stabilityexperimental
MaintainerUwe Schmidt (uwe\@fh-wedel.de)
Description

Version : $Id: PipeOpen.hs,v 1.2 20050902 17:09:39 hxml Exp $ -

pipe open implemented with System.Process functions -

Synopsis
popen :: String -> [String] -> IO (String, String, Int)
Documentation
popen :: String -> [String] -> IO (String, String, Int)Source
call an external program with a list of command line arguments - and return content of stdout, content of stderr and return code -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-DOM-EditFilters.html b/doc/hxt-filter/Text-XML-HXT-DOM-EditFilters.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-DOM-EditFilters.html +++ /dev/null @@ -1,1463 +0,0 @@ - - -Text.XML.HXT.DOM.EditFilters
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.DOM.EditFilters
Description
XML editing filters -
Synopsis
canonicalizeTree :: XmlFilter -> XmlFilter
canonicalizeAllNodes :: XmlFilter
canonicalizeForXPath :: XmlFilter
collapseXText :: XmlFilter
collapseAllXText :: XmlFilter
indentDoc :: XmlFilter
removeWhiteSpace :: XmlFilter
removeAllWhiteSpace :: XmlFilter
removeDocWhiteSpace :: XmlFilter
removeComment :: XmlFilter
removeAllComment :: XmlFilter
transfCdata :: XmlFilter
transfAllCdata :: XmlFilter
transfCdataEscaped :: XmlFilter
transfAllCdataEscaped :: XmlFilter
transfCharRef :: XmlFilter
transfAllCharRef :: XmlFilter
escapeXmlDoc :: XmlFilter
escapeXmlText :: XmlFilter
escapeXmlAttrValue :: XmlFilter
unparseXmlDoc :: XmlFilter
numberLinesInXmlDoc :: XmlFilter
numberLines :: String -> String
treeRepOfXmlDoc :: XmlFilter
haskellRepOfXmlDoc :: XmlFilter
addHeadlineToXmlDoc :: XmlFilter
addXmlPiToDoc :: XmlFilter
Documentation
canonicalizeTree :: XmlFilter -> XmlFilterSource

Applies some Canonical XML rules to the nodes of a tree. -

The rule differ slightly for canonical XML and XPath in handling of comments -

Note: This is not the whole canonicalization as it is specified by the W3C - Recommendation. Adding attribute defaults or sorting attributes in lexicographic - order is done by the transform function of module Text.XML.HXT.Validator.Validation. - Replacing entities or line feed normalization is done by the parser. -

Not implemented yet: -

  • Whitespace within start and end tags is normalized -
  • Special characters in attribute values and character content are replaced by character references -

see canonicalizeAllNodes and canonicalizeForXPath -

canonicalizeAllNodes :: XmlFilterSource

canonicalize tree and remove comments and <?xml ... ?> declarations -

see canonicalizeTree -

canonicalizeForXPath :: XmlFilterSource

Canonicalize a tree for XPath - Comment nodes are not removed -

see canonicalizeTree -

collapseXText :: XmlFilterSource
Collects sequences of child XText nodes into one XText node. -
collapseAllXText :: XmlFilterSource

Applies collapseXText recursively. -

see also : collapseXText -

indentDoc :: XmlFilterSource

filter for indenting a document tree for pretty printing. -

the tree is traversed for inserting whitespace for tag indentation. -

whitespace is only inserted or changed at places, where it isn't significant, - is's not inserted between tags and text containing non whitespace chars. -

whitespace is only inserted or changed at places, where it's not significant. - preserving whitespace may be controlled in a document tree - by a tag attribute xml:space -

allowed values for this attribute are default | preserve. -

input is a complete document tree. - result the semantically equivalent formatted tree. -

see also : removeDocWhiteSpace -

removeWhiteSpace :: XmlFilterSource

simple filter for removing whitespace. -

no check on sigificant whitespace is done. -

see also : removeAllWhiteSpace, removeDocWhiteSpace -

removeAllWhiteSpace :: XmlFilterSource

simple recursive filter for removing all whitespace. -

removes all text nodes in a tree that consist only of whitespace. -

see also : removeWhiteSpace, removeDocWhiteSpace -

removeDocWhiteSpace :: XmlFilterSource

filter for removing all not significant whitespace. -

the tree traversed for removing whitespace between tags, - that was inserted for indentation and readability. - whitespace is only removed at places, where it's not significat - preserving whitespace may be controlled in a document tree - by a tag attribute xml:space -

allowed values for this attribute are default | preserve -

input is root node of the document to be cleaned up - output the semantically equivalent simplified tree -

see also : indentDoc, removeAllWhiteSpace -

removeComment :: XmlFilterSource
remove Comments -
removeAllComment :: XmlFilterSource
remove all Comments recursively -
transfCdata :: XmlFilterSource
converts CDATA section in normal text sections -
transfAllCdata :: XmlFilterSource
converts CDATA sections in whole document tree -
transfCdataEscaped :: XmlFilterSource
converts CDATA section in normal text nodes -
transfAllCdataEscaped :: XmlFilterSource
converts CDATA sections in whole document tree into normal text nodes -
transfCharRef :: XmlFilterSource
converts character references to normal text -
transfAllCharRef :: XmlFilterSource
recursively converts all character references to normal text -
escapeXmlDoc :: XmlFilterSource

convert the special XML chars ", <, >, & and ' in a document to char references, - attribute values are converted with escapeXmlAttrValue -

see also: escapeXmlText, escapeXmlAttrValue -

escapeXmlText :: XmlFilterSource

convert the special XML chars in a text or comment node - into character references -

see also escapeXmlDoc -

escapeXmlAttrValue :: XmlFilterSource

convert the special XML chars in an attribute value into - charachter references. Not only the XML specials but also \n, \r and \t are converted -

see also: escapeXmlDoc, escapeXmlText -

unparseXmlDoc :: XmlFilterSource

convert a document tree into an output string representation - with respect to the output encoding. -

The children of the document root are stubstituted by - a single text node for the text representation of the document. -

Encoding of the document is performed with respect - to the output-encoding attribute in the root node, or if not present, - of the encoding attribute for the original input encoding. - If the encoding is not specified or not supported, UTF-8 is taken. -

numberLinesInXmlDoc :: XmlFilterSource

convert a document into a text and add line numbers to the text representation. -

Result is a root node with a single text node as child. - Useful for debugging and trace output. - see also : haskellRepOfXmlDoc, treeRepOfXmlDoc -

numberLines :: String -> StringSource
treeRepOfXmlDoc :: XmlFilterSource

convert a document into a text representation in tree form. -

Useful for debugging and trace output. - see also : haskellRepOfXmlDoc, numberLinesInXmlDoc -

haskellRepOfXmlDoc :: XmlFilterSource

convert a document into a Haskell representation (with show). -

Useful for debugging and trace output. - see also : treeRepOfXmlDoc, numberLinesInXmlDoc -

addHeadlineToXmlDoc :: XmlFilterSource
addXmlPiToDoc :: XmlFilterSource
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-DOM-Namespace.html b/doc/hxt-filter/Text-XML-HXT-DOM-Namespace.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-DOM-Namespace.html +++ /dev/null @@ -1,174 +0,0 @@ - - -Text.XML.HXT.DOM.Namespace
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.DOM.Namespace
Description
main namespace filter for propagation, checking, tracing and error handling -
Synopsis
propagateAndValidateNamespaces :: XmlStateFilter a
module Text.XML.HXT.DOM.NamespaceFilter
Documentation
propagateAndValidateNamespaces :: XmlStateFilter aSource

propagate all namespace declarations, check namespace constraints and issue errors. - If no error was found, result is the unchanged input tree, else the root node "/" with an empty document is returned. -

see also : propagateNamespaces, validateNamespaces -

module Text.XML.HXT.DOM.NamespaceFilter
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-DOM-NamespaceFilter.html b/doc/hxt-filter/Text-XML-HXT-DOM-NamespaceFilter.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-DOM-NamespaceFilter.html +++ /dev/null @@ -1,434 +0,0 @@ - - -Text.XML.HXT.DOM.NamespaceFilter
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.DOM.NamespaceFilter
Description

Namespace filter -

Namespaces are processed with two main filter, propagateNamespaces - and validateNamespaces. -

propagateNamespaces takes a XML tree and - attaches extra namespace info at every tag name and attribute name. - So after processing a tree with propagateNamespaces, the access functions - namespaceOf and universalNameOf deliver the associated namespace (or "") - for tag names and attribute names. -

validateNamespaces checks whether names are wellformed related to the XML namespace definition. - whether a legal namespace is declared for all prefixes, and whether attribute names are unique - related to universal names. -

Synopsis
type NamespaceTable = NsEnv
propagateNamespaces :: XmlFilter
propagateNamespaceEnv :: NamespaceTable -> XmlFilter
validateNamespaces :: XmlFilter
validate1Namespaces :: XmlFilter
isNamespaceDecl :: XmlFilter
Documentation
type NamespaceTable = NsEnvSource
Type for the namespace association list, used when propagating namespaces by - modifying the QName values in a tree -
propagateNamespaces :: XmlFilterSource

propagate all namespace declarations "xmlns:ns=..." to all - tag and attribute nodes of a document. -

This filter does not check for illegal use of namespaces. - The real work is done by propagateNamespaceEnv. -

The filter may be applied repeatedly if neccessary. -

propagateNamespaceEnv :: NamespaceTable -> XmlFilterSource
attaches the namespace info given by the namespace table - to a tag node and its attributes and children. -
validateNamespaces :: XmlFilterSource
validate the namespace constraints in a whole tree. - result is the list of errors concerning namespaces. - Work is done by applying validate1Namespaces to all nodes. - Predicates isWellformedQName, isWellformedQualifiedName, isDeclaredNamespace - and isWellformedNSDecl are applied to the appropriate tags and attributes. -
validate1Namespaces :: XmlFilterSource
a single node for namespace constrains. -
isNamespaceDecl :: XmlFilterSource
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-DOM-XmlState.html b/doc/hxt-filter/Text-XML-HXT-DOM-XmlState.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-DOM-XmlState.html +++ /dev/null @@ -1,3126 +0,0 @@ - - -Text.XML.HXT.DOM.XmlState
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.DOM.XmlState
Description

This module provides a Monad for an internal state and IO commands. - The state consists of two parts, the user state and the system state - user state ist a type parameter, the system state is a list - name-value pair. If the user state is not needed, the type parameter - can be instantiated with (). -

Furthermore there are types for Xml filter working on this monad - and functions for manipulating the state components - and for lifting i/o commands and XmlFilter to monad filters. -

Error reporting functions are also located in this module. -

Synopsis
data SysState = SysState {
sysStateAttrs :: !SysStateAttrs
sysStateErrorHandler :: !(XmlStateFilter ())
}
type SysStateAttrs = AssocList String XmlTrees
data XmlState state = XmlState {
sysState :: !SysState
userState :: !state
}
type XState state res = StateIO (XmlState state) res
type XmlStateFilter state = XmlTree -> XState state XmlTrees
changeState :: (state -> state) -> XState state state
setState :: state -> XState state state
getState :: XState state state
changeSysState :: (SysState -> SysState) -> XState state SysState
setSysState :: SysState -> XState state SysState
getSysState :: XState state SysState
initialSysState :: SysState
changeSysStateAttrs :: (SysStateAttrs -> SysStateAttrs) -> SysState -> SysState
setSysErrorHandler :: XmlStateFilter () -> XState state ()
getSysErrorHandler :: XState state (XmlStateFilter ())
setSysParamTree :: String -> XmlTrees -> XState state ()
setSysParam :: String -> String -> XState state ()
setSysParamInt :: String -> Int -> XState state ()
setSystemParams :: XmlStateFilter state
getSysParamTree :: String -> XState state XmlTrees
getSysParam :: String -> XState state String
getSysParamWithDefault :: String -> String -> XState state String
getSysParamInt :: String -> Int -> XState state Int
run0 :: XmlState state -> XState state res -> IO (res, XmlState state)
run :: state -> XState state res -> IO res
run' :: XState () res -> IO res
chain' :: state1 -> XState state1 res -> XState state0 (res, state1)
chain :: state1 -> XState state1 res -> XState state0 res
liftF :: XmlFilter -> XmlStateFilter state
io :: IO a -> XState state a
setTraceLevel :: Int -> XState state ()
getTraceLevel :: XState state Int
traceCmd :: Int -> XState state a -> XState state ()
trace :: Int -> String -> XState state ()
traceState :: Int -> (state -> String) -> XState state ()
clearStatus :: XmlStateFilter state
issueError :: XmlStateFilter state
errorMsgHandler :: XmlStateFilter state
setErrorMsgLevel :: XmlStateFilter state
errorMsgToStderr :: XmlStateFilter state
errorMsgLogging :: XmlStateFilter state
errorMsgLoggingAndToStderr :: XmlStateFilter state
getErrorMsg :: XmlStateFilter state
errClass :: Int -> String
issueWarn :: String -> XmlStateFilter state
issueErr :: String -> XmlStateFilter state
issueFatal :: String -> XmlStateFilter state
addFatal :: String -> XmlStateFilter state
checkStatus :: XmlStateFilter state
setStatus :: Int -> String -> XmlFilter
statusOk :: XmlFilter
checkResult :: String -> XmlStateFilter state
processAttrM :: XmlStateFilter a -> XmlStateFilter a
Documentation
data SysState Source
The internal system state consists of a list of name-value pairs - of type (String, XmlTrees), so arbitrary lists of trees can be stored. - For options, often only strings are used as values, so a set of access - functions with string values is available - The error handling method can be controlled by an error handler filter, - the default filter issues the errors on stderr -
Constructors
SysState
sysStateAttrs :: !SysStateAttrs
sysStateErrorHandler :: !(XmlStateFilter ())
type SysStateAttrs = AssocList String XmlTreesSource
data XmlState state Source
The State has a system and a user part - the user state is a type parameter -
Constructors
XmlState
sysState :: !SysState
userState :: !state
type XState state res = StateIO (XmlState state) resSource
The monad type for commands. It is an instance of StateIO from the - general module Control.Monad.MonadStateIO. -
type XmlStateFilter state = XmlTree -> XState state XmlTreesSource
The XmlFilter type for filters working on a state -
changeState :: (state -> state) -> XState state stateSource

change the user state -

  • 1.parameter fct : the user state change function -
  • returns : the new state -
setState :: state -> XState state stateSource

set the user state. -

  • 1.parameter s : the new state -
  • returns : the new state -
getState :: XState state stateSource

read the user state -

  • returns : the current state -
changeSysState :: (SysState -> SysState) -> XState state SysStateSource

change the system part of the state. -

see also : changeState -

setSysState :: SysState -> XState state SysStateSource

set the system part of the state. -

see also : setState -

getSysState :: XState state SysStateSource

read the system part of the state. -

see also : getState -

initialSysState :: SysStateSource

the initial system state -

an empty list of attribute value pairs -

changeSysStateAttrs :: (SysStateAttrs -> SysStateAttrs) -> SysState -> SysStateSource
change the attributes in the system state -
setSysErrorHandler :: XmlStateFilter () -> XState state ()Source
set the error message handler -
getSysErrorHandler :: XState state (XmlStateFilter ())Source
get the error handler -
setSysParamTree :: String -> XmlTrees -> XState state ()Source

set or change a single system parameter. -

  • 1.parameter name : the name of the parameter -
  • 2.parameter value : the list of associated trees -
  • returns : nothing -

see also : setSysParam, setSysParamInt -

setSysParam :: String -> String -> XState state ()Source

set or change a single system parameter of type string. -

  • 1.parameter name : the name of the parameter -
  • 2.parameter value : the (new) string value -
  • returns : nothing -

see also : setSysParamTree, setSysParamInt -

setSysParamInt :: String -> Int -> XState state ()Source

set or change a single integer type system parameter -

see also : setSysParam -

setSystemParams :: XmlStateFilter stateSource
add (or change) all attributes of the document root to the system state - - returns : this -
getSysParamTree :: String -> XState state XmlTreesSource

read a system parameter -

  • 1.parameter name : the name of the parameter -
  • returns : the list of tres associated with the key, or the empty list for unknown parameters -
getSysParam :: String -> XState state StringSource

read a system string parameter -

  • 1.parameter name : the name of the parameter -
  • returns : the value, or the empty string for unknown parameters -
getSysParamWithDefault :: String -> String -> XState state StringSource

read a system parameter or return a default value -

  • 1.parameter name : the name of the parameter -
  • 2.parameter default : the default value -
  • returns : the value if found, else the default -
getSysParamInt :: String -> Int -> XState state IntSource

read an integer system parameter -

  • 1.parameter name : -
  • 2.parameter default : -

see also : getSysParamWithDefault -

run0 :: XmlState state -> XState state res -> IO (res, XmlState state)Source

exec a XState command with initial state. -

  • 1.parameter initalState : the inital user state -
  • 2.parameter cmd : the command -
  • returns : the i/o command with result and user state -
run :: state -> XState state res -> IO resSource
exec a XState command with initial user state. - ignore final user state. - like run0, but ignore the resulting user state -
run' :: XState () res -> IO resSource
exec a XState command in th IO monad. - like run with the empty state (). -
chain' :: state1 -> XState state1 res -> XState state0 (res, state1)Source

run a command in a new user state. - chain the system state part, - init new system state with the current one, run the command and - update the old system state with the resulting new system state -

  • 1.parameter initialUserState : the initial user state -
  • 2.parameter cmd : the command -
  • returns : the result of executing cmd and the final state -
chain :: state1 -> XState state1 res -> XState state0 resSource

like chain' but forget the final user state -

  • 1.parameter initialUserState : the initial user state -
  • 2.parameter cmd : the command -
  • returns : only the result of executing cmd -
liftF :: XmlFilter -> XmlStateFilter stateSource

lift a XmlFilter to a XmlStateFilter filter - issue all error nodes as error messages - and remove the error nodes from the result -

  • 1.parameter f : the filter -
  • returns : the filter running in the state monad -

all errors are filtered from the result and issued on stderr -

io :: IO a -> XState state aSource

lift an I/O command -

  • 1.parameter cmd : the i/o command -
  • returns : the i/o command lifted to the XML state monad -
setTraceLevel :: Int -> XState state ()Source

set the trace level. -

convention: -

0: no trace output (default) -

1: trace important computation steps, e.g. accessing a document -

2: trace small computation steps -

3: output an intermediate result XmlTree in XML source format -

4: output an intermediate result XmlTree in tree representation -

  • 1.parameter level : the trace level -
  • returns : nothing -
getTraceLevel :: XState state IntSource

get the current trace level. -

  • returns : the current trace level -
traceCmd :: Int -> XState state a -> XState state ()Source

trace output for arbitray commands. -

  • 1.parameter level : the trace level, - for which the command will be execuded - if level <= current trace level -
  • 2.parameter cmd : the command to be executed -
  • returns : nothing -
trace :: Int -> String -> XState state ()Source

trace output function for simple text. -

  • 1.parameter level : like in traceCmd -
  • 2.parameter str : the test -
  • returns : nothing -
traceState :: Int -> (state -> String) -> XState state ()Source

trace output of the user part of the program state. -

  • 1.parameter level : like in traceCmd -
  • 2.parameter showFct : the toString function -
  • returns : nothing -
clearStatus :: XmlStateFilter stateSource
filter to reset the state attribute a_status - - returns : this -
issueError :: XmlStateFilter stateSource

report an error message. -

  • returns : if the input tree n represents an error, res = [] - and the error is processed by the errror handler filter (default: error is issued on stderr) - else res = [n] -

see also : issueErr -

errorMsgHandler :: XmlStateFilter stateSource
setErrorMsgLevel :: XmlStateFilter stateSource
set the error level in system state -
errorMsgToStderr :: XmlStateFilter stateSource
default error handler for writing errors to stderr -
errorMsgLogging :: XmlStateFilter stateSource
error message handler for collecting all error messages - all messages are stored under attribute a_error_log - they can be read with getSysParamTree a_error_log or by - applying the filter getErrorMsg to the root node -
errorMsgLoggingAndToStderr :: XmlStateFilter stateSource
getErrorMsg :: XmlStateFilter stateSource

the filter for reading all collected error mesages -

result is the list of error messages, the input tree is ignored -

errClass :: Int -> StringSource
error level translation - c_warn (1) : warning, - c_err (2): error (e.g. parse error, validation error, ...), - c_fatal (3) : fatal error (document access error, internal error, ...) -
issueWarn :: String -> XmlStateFilter stateSource

short cut for issuing a warning -

see also : issueError, issueErr -

issueErr :: String -> XmlStateFilter stateSource

short cut for issuing an error -

see also : issueError -

issueFatal :: String -> XmlStateFilter stateSource

short cut for issuing a fatal error -

see also : issueError, issueErr -

addFatal :: String -> XmlStateFilter stateSource
checkStatus :: XmlStateFilter stateSource
checks the value of the attribute a_status in a document root. - if it contains a value greater or equal to c_err, an error with error message - stored in attribute a_module is issued and the filter acts as the noneM filter - else its the thisM filter -
setStatus :: Int -> String -> XmlFilterSource
add the error level and the module where the error occured - to the attributes of a document root node and remove the children when level is greater or equal to c_err -
statusOk :: XmlFilterSource
check whether tree is a document root and the status attribute has a value less than c_err -
checkResult :: String -> XmlStateFilter stateSource
check whether the error level attribute in the system state - is set to error, in this case the children of the document root are - removed and error info is added as attributes with setStatus - else nothing is changed -
processAttrM :: XmlStateFilter a -> XmlStateFilter aSource

monadic filter for processing the attribute list of a tag. - for other trees this filter acts like noneM -

see also : processAttr, processAttrl -

Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-DOM-XmlTree.html b/doc/hxt-filter/Text-XML-HXT-DOM-XmlTree.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-DOM-XmlTree.html +++ /dev/null @@ -1,120 +0,0 @@ - - -Text.XML.HXT.DOM.XmlTree
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.DOM.XmlTree
Description
This helper module exports elements from the basic libraries: - XmlTreeTypes, XmlKeywords, XNodeFunctions, XmlTreeFunctions and XmlTreeFilter -
Documentation
module Text.XML.HXT.DOM.XmlTreeTypes
module Text.XML.HXT.DOM.XmlTreeFunctions
module Text.XML.HXT.DOM.XmlTreeFilter
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-DOM-XmlTreeFilter.html b/doc/hxt-filter/Text-XML-HXT-DOM-XmlTreeFilter.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-DOM-XmlTreeFilter.html +++ /dev/null @@ -1,5758 +0,0 @@ - - -Text.XML.HXT.DOM.XmlTreeFilter
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.DOM.XmlTreeFilter
Description
basic XmlTree filter -
Synopsis
isRoot :: XmlFilter
isTag :: String -> XmlFilter
isNsTag :: String -> String -> XmlFilter
hasLocalPart :: String -> XmlFilter
hasPrefix :: String -> XmlFilter
hasNamespace :: String -> XmlFilter
isOfTag :: (TagName -> Bool) -> XmlFilter
hasAttr :: String -> XmlFilter
hasNsAttr :: String -> String -> XmlFilter
hasValue :: String -> (String -> Bool) -> XmlFilter
isPi :: String -> XmlFilter
isXmlPi :: XmlFilter
isOfPi :: (TagName -> Bool) -> XmlFilter
isXCdata :: XmlFilter
isXCharRef :: XmlFilter
isXCmt :: XmlFilter
isXDTD :: XmlFilter
isXEntityRef :: XmlFilter
isXError :: XmlFilter
isXPi :: XmlFilter
isXTag :: XmlFilter
isXAttr :: XmlFilter
isAttr :: String -> XmlFilter
isNsAttr :: String -> String -> XmlFilter
isOfAttr :: (AttrName -> Bool) -> XmlFilter
isXText :: XmlFilter
isText :: String -> XmlFilter
isOfText :: (String -> Bool) -> XmlFilter
isWhiteSpace :: XmlFilter
isDoctype :: XmlFilter
isAttlist :: XmlFilter
isElement :: XmlFilter
isEntity :: XmlFilter
isPeRef :: XmlFilter
isDTDName :: XmlFilter
isCondSect :: XmlFilter
isParameterEntity :: XmlFilter
isNotation :: XmlFilter
isDefaultAttrKind :: XmlFilter
isEnumAttrType :: XmlFilter
isFixedAttrKind :: XmlFilter
isIdAttrType :: XmlFilter
isIdRefAttrType :: XmlFilter
isNotationAttrType :: XmlFilter
isRequiredAttrKind :: XmlFilter
isAttlistParameterEntity :: XmlFilter
isEmptyElement :: XmlFilter
isMixedContentElement :: XmlFilter
isElemWithContent :: XmlFilter
isAttlistOfElement :: String -> XmlFilter
isElemContentParamEntity :: XmlFilter
isUnparsedEntity :: XmlFilter
isExternalParameterEntity :: XmlFilter
isInternalParameterEntity :: XmlFilter
isWarning :: XmlFilter
isError :: XmlFilter
isFatalError :: XmlFilter
mkXTag :: String -> XmlFilter -> XmlFilter -> XmlFilter
mkQTag :: QName -> XmlFilter -> XmlFilter -> XmlFilter
mkXNsTag :: String -> String -> XmlFilter -> XmlFilter -> XmlFilter
mkXAttr :: String -> XmlFilter -> XmlFilter
mkQAttr :: QName -> XmlFilter -> XmlFilter
mkXNsAttr :: String -> String -> XmlFilter -> XmlFilter
mkXText :: String -> XmlFilter
mkXCharRef :: Int -> XmlFilter
mkXEntityRef :: String -> XmlFilter
mkXCmt :: XmlFilter -> XmlFilter
mkXDTD :: DTDElem -> Attributes -> XmlTrees -> XmlFilter
mkXCdata :: XmlFilter -> XmlFilter
mkXPi :: String -> XmlFilter -> XmlFilter
mkXError :: Int -> String -> XmlFilter
getName :: XmlFilter
getAttrl :: XmlFilter
getValue :: String -> XmlFilter
getNsValue :: String -> String -> XmlFilter
getDTDValue :: String -> XmlFilter
getXCmt :: XmlFilter
getXCdata :: XmlFilter
replaceQName :: String -> XmlFilter
modifyText :: (String -> String) -> XmlFilter
modifyQName :: (TagName -> TagName) -> XmlFilter
processAttrl :: XmlSFilter -> XmlFilter
processAttr :: XmlFilter -> XmlFilter
replaceAttrl :: XmlTrees -> XmlFilter
del1Attr :: String -> XmlFilter
add1Attr :: XmlTree -> XmlFilter
addAttrl :: XmlFilter -> XmlFilter
addAttr :: String -> String -> XmlFilter
addAttrInt :: String -> Int -> XmlFilter
modifyAttr :: String -> (String -> String) -> XmlFilter
addDTDAttr :: String -> String -> XmlFilter
(+=) :: XmlFilter -> XmlFilter -> XmlFilter
(++=) :: XmlFilter -> [XmlFilter] -> XmlFilter
valueOf :: String -> XmlTree -> String
intValueOf :: String -> XmlTree -> Int
tag :: String -> [XmlFilter] -> [XmlFilter] -> XmlFilter
stag :: String -> [XmlFilter] -> XmlFilter
atag :: String -> [XmlFilter] -> XmlFilter
etag :: String -> XmlFilter
qetag :: QName -> XmlFilter
qtag :: QName -> XmlFilter -> XmlFilter -> XmlFilter
rootTag :: [XmlFilter] -> [XmlFilter] -> XmlFilter
attr :: String -> XmlFilter -> XmlFilter
qattr :: QName -> XmlFilter -> XmlFilter
sattr :: String -> String -> XmlFilter
txt :: String -> XmlFilter
cmt :: String -> XmlFilter
spi :: String -> String -> XmlFilter
cdata :: String -> XmlFilter
dtd :: DTDElem -> [XmlFilter] -> [XmlFilter] -> XmlFilter
warn :: String -> XmlFilter
err :: String -> XmlFilter
fatal :: String -> XmlFilter
hasOption :: String -> XmlFilter
Documentation
isRoot :: XmlFilterSource
test whether the root of a tree contains a document root node. -
isTag :: String -> XmlFilterSource

test whether the root of a tree contains a tag node. -

see also: isNsTag -

isNsTag :: String -> String -> XmlFilterSource

namespace aware test whether the root of a tree contains a tag node. Parameters are the local part and namespace. - Only usable after namespace propagation. -

see also: isTag -

hasLocalPart :: String -> XmlFilterSource
test whether the root of a tree has a given local name - see also : hasNamespace, hasPrefix, isTag, isAttr -
hasPrefix :: String -> XmlFilterSource
test whether the root of a tree has a given prefix name - see also : hasNamespace, hasLocalPart, isTag, isAttr -
hasNamespace :: String -> XmlFilterSource
test whether the root of a tree belongs to a given namespace - see also : isTag, isAttr, hasLocalPart, hasPrefix -
isOfTag :: (TagName -> Bool) -> XmlFilterSource
test whether the root of a tree contains a tag node with a special name. -
hasAttr :: String -> XmlFilterSource

test whether the node of a tree is a XTag node or a XPi node with an attibute of a specific name -

see also: isAttr, hasNsAttr -

hasNsAttr :: String -> String -> XmlFilterSource

test whether the tree is a XTag node with an attibute of a specific local name and namespace uri -

see also: hasAttr, isNsAttr -

hasValue :: String -> (String -> Bool) -> XmlFilterSource

test whether the given node is a XTag node or a XPI node with an attribute with a value with a specific property. - In case of a match, the attribute value represented by a text node is returned as single element list, - else the empty list is the result. -

see also : getValue -

isPi :: String -> XmlFilterSource
test whether the tree is a processing instruction with a given name. -
isXmlPi :: XmlFilterSource
test whether the tree is a <?xml ... ?> declaration -
isOfPi :: (TagName -> Bool) -> XmlFilterSource
test whether the root of a tree contains a processing instruction of a special name. -
isXCdata :: XmlFilterSource
test whether the root of a tree contains a CDATA node. -
isXCharRef :: XmlFilterSource
test whether the root of a tree contains a character reference node. -
isXCmt :: XmlFilterSource
test whether the root of a tree contains a comment node. -
isXDTD :: XmlFilterSource
test whether the root of a tree contains a DTD part. -
isXEntityRef :: XmlFilterSource
test whether the root of a tree contains an entity reference node. -
isXError :: XmlFilterSource
test whether the root of a tree contains an error node. -
isXPi :: XmlFilterSource
test whether the root of a tree contains a processing instruction node. -
isXTag :: XmlFilterSource
test whether the root of a tree contains a tag node. -
isXAttr :: XmlFilterSource
test whether the root of a tree contains an attribute node. -
isAttr :: String -> XmlFilterSource
test whether the root of a tree is an attribute node for a given attribute name -
isNsAttr :: String -> String -> XmlFilterSource

namespace aware test whether the tree contains an attribute node. Parameters are the local part of the atribute name and the namespace. - Only usable after namespace propagation. -

see also: isNsTag, isAttr, hasNsAttr -

isOfAttr :: (AttrName -> Bool) -> XmlFilterSource
general test for an attribute name -
isXText :: XmlFilterSource
test whether the root of a tree contains a text node. -
isText :: String -> XmlFilterSource
test whether the root of a tree contains a special text. -
isOfText :: (String -> Bool) -> XmlFilterSource
test whether the root of a tree contains a text node with a special property -
isWhiteSpace :: XmlFilterSource
test whether the root of a tree contains a text node only with whitespace. -
isDoctype :: XmlFilterSource
test whether the root of a tree contains a DOCTYPE DTD part. -
isAttlist :: XmlFilterSource
test whether the root of a tree contains an ATTLIST DTD part. -
isElement :: XmlFilterSource
test whether the root of a tree contains an ELEMENT DTD part. -
isEntity :: XmlFilterSource
test whether the root of a tree contains an ENTITY DTD part. -
isPeRef :: XmlFilterSource
test whether the root of a tree contains a parameter ENTITY reference. -
isDTDName :: XmlFilterSource
test whether the root of a tree contains a DTD name part. -
isCondSect :: XmlFilterSource
test whether the root of a tree contains a conditional section DTD part. -
isParameterEntity :: XmlFilterSource
test whether the root of a tree contains a parameter entity declaration. -
isNotation :: XmlFilterSource
test whether the root of a tree contains a NOTATION DTD part. -
isDefaultAttrKind :: XmlFilterSource
isEnumAttrType :: XmlFilterSource
isFixedAttrKind :: XmlFilterSource
isIdAttrType :: XmlFilterSource
isIdRefAttrType :: XmlFilterSource
isNotationAttrType :: XmlFilterSource
isRequiredAttrKind :: XmlFilterSource
isAttlistParameterEntity :: XmlFilterSource
isEmptyElement :: XmlFilterSource
isMixedContentElement :: XmlFilterSource
isElemWithContent :: XmlFilterSource
isAttlistOfElement :: String -> XmlFilterSource
isElemContentParamEntity :: XmlFilterSource
isUnparsedEntity :: XmlFilterSource
isExternalParameterEntity :: XmlFilterSource
isInternalParameterEntity :: XmlFilterSource
isWarning :: XmlFilterSource
test whether the root of a tree contains an error node for a warning. -
isError :: XmlFilterSource
test whether the root of a tree contains an error node for an error. -
isFatalError :: XmlFilterSource
test whether the root of a tree contains an error node for a fatal error. -
mkXTag :: String -> XmlFilter -> XmlFilter -> XmlFilterSource

constructor filter for a tag node. - a new tree is constructed. - the attributes and the children are computed by applying the aproprate filter to the input tree -

  • 1.parameter n : the tag name -
  • 2.parameter af : the filter for the attribute list -
  • 3.parameter cf : the filter for the children -
  • returns : the constructor filter -
mkQTag :: QName -> XmlFilter -> XmlFilter -> XmlFilterSource
Version with qualified names of mkXTag -
mkXNsTag :: String -> String -> XmlFilter -> XmlFilter -> XmlFilterSource

constructor filter for a tag node. - a new tree is constructed. - the attributes and the children are computed by applying the aproprate filter to the input tree -

  • 1.parameter n : the tag name in form of prefix:localpart -
  • 2.parameter ns: the namespace uri -
  • 3.parameter af : the filter for the attribute list -
  • 4.parameter cf : the filter for the children -
  • returns : the constructor filter -
mkXAttr :: String -> XmlFilter -> XmlFilterSource
filter for attribute construction. - a new tree with attribute name and a value computed by a filter - is build. -
mkQAttr :: QName -> XmlFilter -> XmlFilterSource
Qualified version mkXAttr -
mkXNsAttr :: String -> String -> XmlFilter -> XmlFilterSource
filter for attribute construction. - a new tree with attribute name and namespace and a value computed by a filter - is build. -
mkXText :: String -> XmlFilterSource
constructor filter for a text node. - a new tree is constructed. - the input tree is ignored. -
mkXCharRef :: Int -> XmlFilterSource
constructor filter for a character reference node. - a new tree is constructed. - the input tree is ignored. -
mkXEntityRef :: String -> XmlFilterSource
constructor filter for an entity reference node. - a new tree is constructed. - the input tree is ignored. -
mkXCmt :: XmlFilter -> XmlFilterSource
constructor filter for a comment node. - a new tree is constructed. - the xml string representation of the filter result - forms the comment -
mkXDTD :: DTDElem -> Attributes -> XmlTrees -> XmlFilterSource
constructor filter for a DTD part. - a new tree is constructed. - the input tree is ignored. -
mkXCdata :: XmlFilter -> XmlFilterSource
constructor filter for a CDATA section node. - a new tree is constructed. - the input tree is ignored. -
mkXPi :: String -> XmlFilter -> XmlFilterSource
constructor filter for a processing instruction - a new tree is constructed from the text representation - of the input tree -
mkXError :: Int -> String -> XmlFilterSource
constructor filter for an error message node. - a new tree is constructed. - the input tree is ignored. -
getName :: XmlFilterSource
filter for selecting the name of a tag node, an attribute node or a pi node. - Result of the filter is a single element list with a text node or the empty list -
getAttrl :: XmlFilterSource
filter for selecting the attibute list -
getValue :: String -> XmlFilterSource

filter for selecting the value of an attribute in a tag node. - Result of the filter is a single element list with a text node or the empty list -

see also : hasValue, getNsValue -

getNsValue :: String -> String -> XmlFilterSource

filter for selecting the value of an attribute with namespace in a tag node. - Result of the filter is a single element list with a text node or the empty list -

see also : getValue, isNsAttr -

getDTDValue :: String -> XmlFilterSource
filter for selecting an attribute of a DTD node. - Result of the filter is a single element list with a text node or the empty list -
getXCmt :: XmlFilterSource
filter for selecting content of a comment. - Result of the filter is a single element list with a text node or the empty list -
getXCdata :: XmlFilterSource
filter for selecting the CDATA content. - Result of the filter is a single element list with a text node or the empty list -
replaceQName :: String -> XmlFilterSource
edit filter for changing the name of a tag node, an attribute or a pi. - result of the filter is a single element list with a tag node or the empty list -
modifyText :: (String -> String) -> XmlFilterSource

edit filter for changing the text of a text node. - result of the filter is a single element list with a text node or the empty list -

example for editing all text nodes of a tree with an edit function f: -

processBottomUp (modifyText f `when` isXText)
modifyQName :: (TagName -> TagName) -> XmlFilterSource
edit filter for changing the name of a tag node. - result of the filter is a single element list with a text node or the empty list -
processAttrl :: XmlSFilter -> XmlFilterSource
process the attribute list of a tag node with a tree list filter. - for other trees this filter acts like none -
processAttr :: XmlFilter -> XmlFilterSource

elementwise processing of the attributes of a tag. - for other trees this filter acts like none -

see also : processAttrl -

replaceAttrl :: XmlTrees -> XmlFilterSource
replace an attribute list - to be renamed when replaceAttrl is eliminated -
del1Attr :: String -> XmlFilterSource
delete an attribute from the attribute list of a tag tree -
add1Attr :: XmlTree -> XmlFilterSource

add an attribute to the attribute list of a tag. - If the attribute already exists, it's substituted, -

see also: sattr, += -

addAttrl :: XmlFilter -> XmlFilterSource

adds an attribute list computed by a filter, uses add1Attr. -

see also: += -

addAttr :: String -> String -> XmlFilterSource
add or change an attribute with a given string as value for a XTag or XPi tree, - uses add1Attr. -
addAttrInt :: String -> Int -> XmlFilterSource
add or change an attribute with an Int value. - uses addAttr. -
modifyAttr :: String -> (String -> String) -> XmlFilterSource

edit filter for changing the value of an attribute in a tag node. - result of the filter is a single element list with the tag node or the empty list. -

  • 1.parameter n : the name of the attribute -
  • 2.parameter f : the edit function for the attribute value -
  • returns : the edit filter -
addDTDAttr :: String -> String -> XmlFilterSource
add or change an attribute of a DTD tree -
(+=) :: XmlFilter -> XmlFilter -> XmlFilterSource

convenient function for tag node tree construction -

infixl 7 -

filter combinator for tag tree constrcution - take a 1. filter for computing a tag node tree (or a whole list of tag node trees) - then add all trees computed by the 2. filter to the attribute list when they represent attributes - else append them to the list of children. -

if the 1. filter computes a list of tag nodes, the results of the 2. filter are added to all trees -

example: etag "a" += sattr "href" "#42" += txt "the answer" - gives the tree <a href="#42">the answer</a> -

example: ( etag "a" +++ etag "b" ) += sattr "x" "42" - gives the tree <a x="42"/><b x="42"/> -

see also : etag, tag, add1Attr, modifyChildren, ++= -

(++=) :: XmlFilter -> [XmlFilter] -> XmlFilterSource

convenient filter function adding a whole list of trees, just for not writing to many ( ... ). -

infixl 7 -

 f ++= gl  == f += cat gl

see also : += -

valueOf :: String -> XmlTree -> StringSource
combination of getValue and conversion into a String -
intValueOf :: String -> XmlTree -> IntSource
combination of getValue and conversion to a Int -
tag :: String -> [XmlFilter] -> [XmlFilter] -> XmlFilterSource

variant of mkXTag with a list of filters for the attributes and a list of filters for the children. - this variant leads to a more readable source for a complicated construction filter - than the simple solution with a combination of mkXTag and cat. -

see also : mkXTag, stag, etag, cat, += -

stag :: String -> [XmlFilter] -> XmlFilterSource

variant of tag, useful for tags without attributes and with a list of filters for - constructing the children -

see also : mkXTag, tag, etag, cat, += -

atag :: String -> [XmlFilter] -> XmlFilterSource

variant of tag, useful for tags with attributes but without children -

see also : mkXTag, tag, stag, etag, cat -

etag :: String -> XmlFilterSource

Short cut for empty tags without attributes -

see also : tag, atag, stag, mkXTag and += -

qetag :: QName -> XmlFilterSource
Qualified version of etag -
qtag :: QName -> XmlFilter -> XmlFilter -> XmlFilterSource
Alias for mkQTag -
rootTag :: [XmlFilter] -> [XmlFilter] -> XmlFilterSource

filter for creating a document root node with a list of filters for the attributes and a list of filters for the document. -

see also : tag -

attr :: String -> XmlFilter -> XmlFilterSource
Alias for mkXAttr -
qattr :: QName -> XmlFilter -> XmlFilterSource
Alias for mkQAttr -
sattr :: String -> String -> XmlFilterSource

short cut for attribute construction with string constants -

set also : attr, mkXAttr and mkXText -

txt :: String -> XmlFilterSource
short cut for mkXText -
cmt :: String -> XmlFilterSource

short cut for simple comment - the input tree is ignored -

see also : mkXCmt -

spi :: String -> String -> XmlFilterSource

short cut for generating simple processing instructions (spi) - the input tree is ignored -

spi "xyz" "abc" is equal to mkXPi "xyz" (txt "abc") - (the name pi is already used in prelude) -

cdata :: String -> XmlFilterSource
short cut for generating simple cdata sections, - the input tree is ignored -
dtd :: DTDElem -> [XmlFilter] -> [XmlFilter] -> XmlFilterSource
DTD part generation with filter for attributes and children - see also: mkXDTDTree -
warn :: String -> XmlFilterSource

short cut for mkXError c_warn. -

see also : mkXError -

err :: String -> XmlFilterSource

short cut for mkXError c_fatal. -

see also : mkXError -

fatal :: String -> XmlFilterSource

short cut for mkXError c_fatal. -

see also : mkXError -

hasOption :: String -> XmlFilterSource

check whether an option is set -

reads the value of an attribute, usually applied to a document root node, - and checks if the value represents True. The following strings are interpreted - as true: "1", "True", "true", "yes", "Yes". -

Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-DOM-XmlTreeFunctions.html b/doc/hxt-filter/Text-XML-HXT-DOM-XmlTreeFunctions.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-DOM-XmlTreeFunctions.html +++ /dev/null @@ -1,3474 +0,0 @@ - - -Text.XML.HXT.DOM.XmlTreeFunctions
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.DOM.XmlTreeFunctions
Portabilityportable
Stabilitystable
MaintainerUwe Schmidt (uwe@fh-wedel.de)
Description
Basic XmlTree functions -
Synopsis
isXCdataNode :: XNode -> Bool
isXCharRefNode :: XNode -> Bool
isXCmtNode :: XNode -> Bool
isXDTDNode :: XNode -> Bool
isXAttrNode :: XNode -> Bool
isXEntityRefNode :: XNode -> Bool
isXErrorNode :: XNode -> Bool
isXPiNode :: XNode -> Bool
isXTagNode :: XNode -> Bool
isXTextNode :: XNode -> Bool
isRootNode :: XNode -> Bool
isTagNode :: String -> XNode -> Bool
isOfTagNode :: (TagName -> Bool) -> XNode -> Bool
isAttrNode :: String -> XNode -> Bool
isOfAttrNode :: (AttrName -> Bool) -> XNode -> Bool
isTextNode :: String -> XNode -> Bool
isOfTextNode :: (String -> Bool) -> XNode -> Bool
isPiNode :: String -> XNode -> Bool
isOfPiNode :: (TagName -> Bool) -> XNode -> Bool
isDTDElemNode :: DTDElem -> XNode -> Bool
isErrorNode :: Int -> XNode -> Bool
textOfXNode :: XNode -> String
mkXTagTree :: String -> XmlTrees -> XmlTrees -> XmlTree
mkQTagTree :: QName -> XmlTrees -> XmlTrees -> XmlTree
mkXNsTagTree :: String -> String -> XmlTrees -> XmlTrees -> XmlTree
newRoot :: XmlTrees -> XmlTree
emptyRoot :: XmlTree
newDocument :: String -> XmlTree
newDocument' :: Attributes -> XmlTree
mkRootTree :: XmlTrees -> XmlTrees -> XmlTree
mkXTextTree :: String -> XmlTree
mkXCharRefTree :: Int -> XmlTree
mkXEntityRefTree :: String -> XmlTree
mkXCmtTree :: String -> XmlTree
mkXDTDTree :: DTDElem -> Attributes -> XmlTrees -> XmlTree
mkXAttrTree :: String -> XmlTrees -> XmlTree
mkQAttrTree :: QName -> XmlTrees -> XmlTree
mkXNsAttrTree :: String -> String -> XmlTrees -> XmlTree
mkXPERefTree :: String -> XmlTree
mkXPiTree :: String -> String -> XmlTree
mkXmlDeclTree :: XmlTrees -> XmlTree
mkXCdataTree :: String -> XmlTree
mkXErrorTree :: Int -> String -> XmlTrees -> XmlTree
maybeString2XText :: Maybe String -> XmlTrees
showXText :: XmlTrees -> String
showXCharRef :: XmlTrees -> String
showXEntityRef :: XmlTrees -> String
showXErrors :: XmlTrees -> String
xmlTreesToString :: XmlTrees -> String
xmlTreesToText :: XmlSFilter
xmlContentModelToString :: XmlTree -> String
nameOf :: XmlTree -> String
localPartOf :: XmlTree -> String
namespaceOf :: XmlTree -> String
prefixOf :: XmlTree -> String
universalNameOf :: XmlTree -> String
attrlOfDTD :: XmlTree -> Attributes
valueOfDTD :: String -> XmlTree -> String
ofDTDequals :: String -> String -> XmlTree -> Bool
xcmt :: String -> XmlTrees
xerr :: String -> XmlTrees
xwarn :: String -> XmlTrees
xtext :: String -> XmlTrees
xtag :: String -> XmlTrees -> XmlTrees -> XmlTrees
xattr :: String -> String -> XmlTrees
toTreel :: XmlTrees -> AssocList String XmlTrees
toAttrl :: XmlTrees -> Attributes
fromTreel :: AssocList String XmlTrees -> XmlTrees
fromAttrl :: Attributes -> XmlTrees
Documentation
isXCdataNode :: XNode -> BoolSource
isXCharRefNode :: XNode -> BoolSource
isXCmtNode :: XNode -> BoolSource
isXDTDNode :: XNode -> BoolSource
isXAttrNode :: XNode -> BoolSource
isXEntityRefNode :: XNode -> BoolSource
isXErrorNode :: XNode -> BoolSource
isXPiNode :: XNode -> BoolSource
isXTagNode :: XNode -> BoolSource
isXTextNode :: XNode -> BoolSource
isRootNode :: XNode -> BoolSource
isTagNode :: String -> XNode -> BoolSource
isOfTagNode :: (TagName -> Bool) -> XNode -> BoolSource
isAttrNode :: String -> XNode -> BoolSource
isOfAttrNode :: (AttrName -> Bool) -> XNode -> BoolSource
isTextNode :: String -> XNode -> BoolSource
isOfTextNode :: (String -> Bool) -> XNode -> BoolSource
isPiNode :: String -> XNode -> BoolSource
isOfPiNode :: (TagName -> Bool) -> XNode -> BoolSource
isDTDElemNode :: DTDElem -> XNode -> BoolSource
isErrorNode :: Int -> XNode -> BoolSource
textOfXNode :: XNode -> StringSource
mkXTagTree :: String -> XmlTrees -> XmlTrees -> XmlTreeSource

Create a tree with a tag node. -

  • 1.parameter n : the name of the tag -
  • 2.parameter al : the tag attribte list -
  • 3.parameter cs : the list of children -
  • returns : the new tree -
mkQTagTree :: QName -> XmlTrees -> XmlTrees -> XmlTreeSource
Version with qualified name of mkXTagTree -
mkXNsTagTree :: String -> String -> XmlTrees -> XmlTrees -> XmlTreeSource

create a tree with a namespace aware tag node. -

  • 1.parameter n : the prefix:localpart of the tag -
  • 2.parameter ns: the namespace uri -
  • 3.parameter al : the tag attribte list -
  • 4.parameter cs : the list of children -
  • returns : the new tree -

see also: mkXTagTree -

newRoot :: XmlTrees -> XmlTreeSource

creates a new document tree with empty contents. -

  • 1.parameter al : the attribute list for the root node -

returns a single node tree with tag name "/" indicating a root and - with empty list of children -

see also : emptyRoot -

emptyRoot :: XmlTreeSource

the empty document tree -

see also : newRoot -

newDocument :: String -> XmlTreeSource
create a new empty document with source name as parameter -
newDocument' :: Attributes -> XmlTreeSource

create a new empty document with a list of attributes for source location and options -

see also : newDocument -

mkRootTree :: XmlTrees -> XmlTrees -> XmlTreeSource

create a document root tree. -

  • 1.parameter al : the attribute list for the root. This list must contain at - least an attribute "source" that contains the URI of the document to be processed -
  • 2.parameter cs : the list for the document content -
  • returns : the document root -
mkXTextTree :: String -> XmlTreeSource

create a leaf for a text element. -

  • 1.parameter txt : the text -
  • returns : the tree with the single node containing the text -
mkXCharRefTree :: Int -> XmlTreeSource

create a leaf for a char reference. -

  • 1.parameter i : the integer representing the Unicode char -
  • returns : the tree with the single node containing the char reference -
mkXEntityRefTree :: String -> XmlTreeSource

create a leaf for an entity reference. -

  • 1.parameter n : the name of the entity reference -
  • returns : the tree with the single node containing the entity reference -
mkXCmtTree :: String -> XmlTreeSource

create a leaf for a comment, -

  • 1.parameter c : the comment text -
  • returns : the tree with the single node containing the comment -
mkXDTDTree :: DTDElem -> Attributes -> XmlTrees -> XmlTreeSource

create a tree for a part of a DTD -

  • 1.parameter d : the type of the DTD part -
  • 2.parameter al : the attribute list for the DTD part -
  • 3.parameter ds : the possibly empty list of components for the DTD part -
  • returns : the tree with the composed DTD part -
mkXAttrTree :: String -> XmlTrees -> XmlTreeSource

create an attribute tree as part of a tag attribute list of tag nodes -

  • 1.parameter al : the attribute name -
  • 2.parameter av : the attribute value as tree list, usually containing a single text node -
mkQAttrTree :: QName -> XmlTrees -> XmlTreeSource
Qualified version of mkXAttrTree -
mkXNsAttrTree :: String -> String -> XmlTrees -> XmlTreeSource

create an attribute tree with a namespace -

  • 1.parameter al : the attribute name -
  • 2.parameter ns : namespace uri -
  • 3.parameter av : the attribute value as tree list, usually containing a single text node -

see also: mkXAttrTree, mkXNsTagTree -

mkXPERefTree :: String -> XmlTreeSource

create a parameter entity reference DTD part. -

  • 1.parameter ref : the name of the reference -
  • returns : the DTD part for a PERef -
mkXPiTree :: String -> String -> XmlTreeSource

create a processing instruction tree. -

  • 1.parameter n : the name of the PI -
  • 2.parameter str : the content of a PI -
  • returns : the processing instruction tree with a single attribute "value" - with the str parameter as attribute value, with valueOf a_value applied to the result tree - the content of the PI can be selected -
mkXmlDeclTree :: XmlTrees -> XmlTreeSource
create xml declaration -
mkXCdataTree :: String -> XmlTreeSource

create a CDATA section tree. -

  • 1.parameter s : the content of the CDATA section -
  • returns : the tree for the CDATA section -
mkXErrorTree :: Int -> String -> XmlTrees -> XmlTreeSource

create an error tree. -

  • 1.parameter l : the level of the error (warning, error fatal) -
  • 2.parameter msg : the error message -
  • 3.parameter cs : the context, where the error was detected -
maybeString2XText :: Maybe String -> XmlTreesSource
showXText :: XmlTrees -> StringSource
showXCharRef :: XmlTrees -> StringSource
showXEntityRef :: XmlTrees -> StringSource
showXErrors :: XmlTrees -> StringSource
xmlTreesToString :: XmlTrees -> StringSource
old name for xshow (deprecated) -
xmlTreesToText :: XmlSFilterSource

conversion of a filter result into a text node -

see also : xshow -

xmlContentModelToString :: XmlTree -> StringSource
nameOf :: XmlTree -> StringSource
select the name of a node. For tags, attributes and pi's the name string - is returned, else the empty string. -
localPartOf :: XmlTree -> StringSource
select the local part of a name of a node. For tags, attributes the name string - is returned, for pi's the whole name, else the empty string. -
namespaceOf :: XmlTree -> StringSource
select the namespace URI of a tag or an attribute tree, else the empty string is returned - see also : nameOf -
prefixOf :: XmlTree -> StringSource
select the namespace prefix of a tag or an attribute tree, else the empty string is returned - see also : nameOf, localPartOf -
universalNameOf :: XmlTree -> StringSource
select the universal name (namespace uri ++ localPart) of a tag or an attribute tree, else the empty string is returned - see also : nameOf, namespaceOf -
attrlOfDTD :: XmlTree -> AttributesSource
select the attributes of a dtd tree -
valueOfDTD :: String -> XmlTree -> StringSource
select a special attribute of a DTD part -
ofDTDequals :: String -> String -> XmlTree -> BoolSource
test an attribute of a DTD part -
xcmt :: String -> XmlTreesSource
xerr :: String -> XmlTreesSource
xwarn :: String -> XmlTreesSource
xtext :: String -> XmlTreesSource
xtag :: String -> XmlTrees -> XmlTrees -> XmlTreesSource
xattr :: String -> String -> XmlTreesSource
toTreel :: XmlTrees -> AssocList String XmlTreesSource
toAttrl :: XmlTrees -> AttributesSource
fromTreel :: AssocList String XmlTrees -> XmlTreesSource
fromAttrl :: Attributes -> XmlTreesSource
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-DOM-XmlTreeTypes.html b/doc/hxt-filter/Text-XML-HXT-DOM-XmlTreeTypes.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-DOM-XmlTreeTypes.html +++ /dev/null @@ -1,690 +0,0 @@ - - -Text.XML.HXT.DOM.XmlTreeTypes
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.DOM.XmlTreeTypes
Description

exports the core data types - and some additional types and functions - for compatibility with none arrow modules -

Version : $Id: XmlTreeTypes.hs,v 1.6 20060509 15:30:43 hxml Exp $ -

Synopsis
module Data.Tree.NTree.Filter
mkNode :: node -> NTrees node -> NTree node
formatNTree :: (node -> String) -> NTree node -> String
foldNTree :: (a -> [b] -> b) -> NTree a -> b
mapNTree :: (a -> b) -> NTree a -> NTree b
nTreeToList :: NTree a -> [a]
depthNTree :: NTree a -> Int
cardNTree :: NTree a -> Int
type XmlFilter = TFilter XNode
type XmlSFilter = TSFilter XNode
type TagName = QName
type AttrName = QName
tName :: QName -> String
aName :: QName -> String
Documentation
module Data.Tree.NTree.Filter
mkNode :: node -> NTrees node -> NTree nodeSource
formatNTree :: (node -> String) -> NTree node -> StringSource
foldNTree :: (a -> [b] -> b) -> NTree a -> bSource
mapNTree :: (a -> b) -> NTree a -> NTree bSource
nTreeToList :: NTree a -> [a]Source
depthNTree :: NTree a -> IntSource
cardNTree :: NTree a -> IntSource
type XmlFilter = TFilter XNodeSource
A functions that takes a node and returns a list of nodes -
type XmlSFilter = TSFilter XNodeSource
A function that takes a list of nodes and returns a list of nodes -
type TagName = QNameSource
Tag name -
type AttrName = QNameSource
Attribute name -
tName :: QName -> StringSource
shortcut for qualifiedName -
aName :: QName -> StringSource
shortcut for qualifiedName -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-DOM.html b/doc/hxt-filter/Text-XML-HXT-DOM.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-DOM.html +++ /dev/null @@ -1,134 +0,0 @@ - - -Text.XML.HXT.DOM
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.DOM
Description

DOM data types and functions -

export of all basic datatypes and functions of the toolbox DOM. -

Documentation
module Text.XML.HXT.DOM.XmlTree
module Text.XML.HXT.DOM.XmlState
module Text.XML.HXT.DOM.EditFilters
module Text.XML.HXT.DOM.Namespace
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-DTDProcessing.html b/doc/hxt-filter/Text-XML-HXT-Parser-DTDProcessing.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-DTDProcessing.html +++ /dev/null @@ -1,347 +0,0 @@ - - -Text.XML.HXT.Parser.DTDProcessing
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.DTDProcessing
Portabilityportable
Stabilityexperimental
MaintainerUwe Schmidt (uwe@fh-wedel.de)
Description
DTD processing function for - including external parts of a DTD - parameter entity substitution and general entity substitution -
Synopsis
getWellformedDoc :: XmlStateFilter state
checkWellformedDoc :: XmlStateFilter state
processDTD :: XmlStateFilter a
processGeneralEntities :: XmlStateFilter a
Documentation
getWellformedDoc :: XmlStateFilter stateSource

monadic filter for reading, parsing and checking a wellformed document. - the input tree must consist of a root node with a source attribute - in its attribute list. -

All attributes from the document root are copied into the system state, - and may be queried by the monadic filters, e.g. trace options. -

Result is the single element list containing the well-formed document tree - or, in case of errors, the document root with an empty list as children - and attributes a_status and a_module for error level and the module, - where the error occured. -

this is a shortcut for getXmlContents .>> checkWellformedDoc -

example for a main program: -

- main =
-   run' $
-   do
-   res  <- getWellformedDoc $ newDocument "myfile.xml"
-   ...
-
checkWellformedDoc :: XmlStateFilter stateSource
parses a text node with parseXmlDoc, processes the DTD and general entities - and transforms all char references into characters -
processDTD :: XmlStateFilter aSource

a filter for DTD processing -

inclusion of external parts of DTD, - parameter entity substitution - conditional section evaluation -

input tree must represent a complete document including root node -

processGeneralEntities :: XmlStateFilter aSource

substitution of general entities -

input: a complete document tree including root node -

Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-DefaultURI.html b/doc/hxt-filter/Text-XML-HXT-Parser-DefaultURI.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-DefaultURI.html +++ /dev/null @@ -1,104 +0,0 @@ - - -Text.XML.HXT.Parser.DefaultURI
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.DefaultURI
Documentation
setDefaultURI :: XState state ()Source
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-HtmlParser.html b/doc/hxt-filter/Text-XML-HXT-Parser-HtmlParser.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-HtmlParser.html +++ /dev/null @@ -1,338 +0,0 @@ - - -Text.XML.HXT.Parser.HtmlParser
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.HtmlParser
Portabilityportable
Stabilitystable
MaintainerUwe Schmidt (uwe@fh-wedel.de)
Description

This parser tries to interprete everything as HTML - no errors are emitted during parsing. If something looks - weired, warning messages are inserted in the document tree. -

Module contains state filter for easy parsing and error handling - real work is done in Text.XML.HXT.Parser.HtmlParsec -

Synopsis
getHtmlDoc :: XmlStateFilter state
parseHtmlDoc :: XmlStateFilter a
runHtmlParser :: XmlStateFilter a
substHtmlEntities :: XmlTree -> XmlTrees
Documentation
getHtmlDoc :: XmlStateFilter stateSource

read a document and parse it with parseHtmlDoc. The main entry point of this module -

The input tree must be a root tree like in ' Text.XML.HXT.Parser.MainFunctions.getXmlDoc'. The content is read with getXmlContents, - is parsed with parseHtmlDoc and canonicalized (char refs are substituted in content and attributes, - but comment is preserved) -

see also : Text.XML.HXT.Parser.DTDProcessing.getWellformedDoc -

parseHtmlDoc :: XmlStateFilter aSource

The HTML parsing filter -

The input is parsed with runHtmlParser, everything is interpreted as HTML, - if errors ocuur, the parser will try to do some meaningfull action and continues - parsing. Afterwards the entitiy references for defined for XHTML are resovled, - any unresolved reference is transformed into plain text. -

Error messages - during parsing and entity resolving are added as warning nodes into the resulting tree. -

The warnings are issued, if the 1. parameter noWarnings is set to True, - afterwards all are removed from the resulting tree. -

runHtmlParser :: XmlStateFilter aSource
The pure HTML parser, usually called via parseHtmlDoc. -
substHtmlEntities :: XmlTree -> XmlTreesSource
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-MainFunctions.html b/doc/hxt-filter/Text-XML-HXT-Parser-MainFunctions.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-MainFunctions.html +++ /dev/null @@ -1,694 +0,0 @@ - - -Text.XML.HXT.Parser.MainFunctions
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.MainFunctions
Description

Simple parse functions. -

the main building blocks for an application. - this module exports complex filters and functions for - common tasks for input and parsing, output and option handling. -

Synopsis
getXmlDocument :: Attributes -> String -> IO (XmlTree, XmlTrees, Int)
putXmlDocument :: Attributes -> String -> XmlTree -> IO (XmlTrees, Int)
parseDocument :: Attributes -> XmlStateFilter state
writeDocument :: Attributes -> XmlStateFilter state
Documentation
getXmlDocument :: Attributes -> String -> IO (XmlTree, XmlTrees, Int)Source

convenient function for reading a XML document without - dealing with state monads, error messages collection and other details -

getXmlDocument calls parseDocument with the list of parsing options - and an url or filename as document source. -

result is a triple -

  • the resulting document tree with a root node containing all - meta info about the document (options, status info, http header, ...) -
  • the list of errors and warnings -
  • the error level: one of c_ok, c_warn, c_err, c_fatal -

example for input (see also example in putXmlDocument and example in writeDocument) -

 main :: IO ()
- main
-   = do
-     (res, errs, rc) <- getXmlDocument [] "test.xml"
-     if rc >= c_err
-       then issueErrors errs
-       else processTree res
-
- issueErrors :: XmlTrees -> IO ()
-
- processTree :: XmlTree  -> IO ()
-

for options see parseDocument, a_collect_errors is set implicitly -

putXmlDocument :: Attributes -> String -> XmlTree -> IO (XmlTrees, Int)Source

the inverse operation to getXmlDocument -

writes a complete document tree to a file, writing can be - controlled by options, the real work is done with filter writeDocument. - useful options are the options of writeDocument. -

result is a pair: 1.part is a list of error messages, 2. part is the return code, - the status info of the write filter -

this filter is useful, when processing XML in an arbitray context in the IO monad -

an example main program for such an application is: -

 main :: IO ()
- main
-   = do
-     (input, readErrs, rc) <- getXmlDocument [...] "test.xml"
-     if rc >= c_err
-       then issueErrors readErrs
-       else processTree input
-
- processTree :: XmlTree -> IO ()
- processTree t
-   = let res = computeNewTree input
-     in do
-        (writeErrs, rc2) <- putXmlDocument [...] "out.xml" res
-        if rc2 >= c_err
-          then issueErrors writeErrs
-          else return ()
-
- issueErrors :: XmlTrees -> IO ()
-
- computeNewTree :: XmlTree -> XmlTree
-
parseDocument :: Attributes -> XmlStateFilter stateSource

the main parsing filter -

this filter can be configured by an option list, a list of - option name, option value pairs. - the input tree must be a possibly empty document root tree. - all the options are stored as attributes in this root node to control processing. -

available options: -

  • a_parse_html: use HTML parser, else use XML parser (default) -
  • a_validate : validate document (default), else skip validation -
  • a_check_namespaces : check namespaces, else skip namespace processing (default) -
  • a_canonicalize : canonicalize document (default), else skip canonicalization -
  • a_preserve_comment : preserve comments during canonicalization, else remove comments (default) -
  • a_remove_whitespace : remove all whitespace, used for document indentation, else skip this step (default) -
  • a_indent : indent document by inserting whitespace, else skip this step (default) -
  • a_issue_warnings : issue warnings, when parsing HTML (default), else ignore HTML parser warnings -
  • a_issue_errors : issue all error messages on stderr (default), or ignore all error messages -
  • a_collect_errors : all error messages are collected during processing and appended to the result document - for further processing within the calling modules -
  • a_trace : trace level: values: 0 -4 -
  • a_proxy : proxy for http access, e.g. www-cache:3128 -
  • a_use_curl : for http access via external programm curl, default is native HTTP access -
  • a_options_curl : more options for external program curl -
  • a_source : the document source url -
  • a_encoding : default document encoding (utf8, isoLatin1, usAscii, ...) -

examples: -

 parseDocument [ (a_source,   "test.xml")
-               , (a_validate, "0")
-               , (a_encoding, isoLatin1)
-               ] emptyRoot
-

reads document "test.xml" without validation and default encoding isoLatin1 -

 parseDocument [ (a_source,         "http://www.haskell.org/")
-               , (a_parse_html,     "1")
-               , (a_proxy,          "www-cache:3128")
-               , (a_curl,           "1")
-               , (a_issue_warnings, "0")
-               ] emptyRoot
-

reads Haskell homepage with HTML parser ignoring any warnings and with http access via external program curl and proxy "www-cache" at port 3128 -

 parseDocument [ (a_source,            "http://www.w3c.org/")
-               , (a_parse_html,        "0")                       -- default
-               , (a_validate,          "1")                       -- default
-               , (a_check_namespace,   "1")
-               , (a_remove_whitespace, "1")
-               , (a_trace,             "2")
-               ] emptyRoot
-

read w3c home page, validate and chech namespaces, remove whitespace between tags, trace activities with level 2 -

 parseDocument [ (a_source,   "test.xml")
-               , (a_validate,        "1")
-               , (a_check_namespace, "1")
-               , (a_collect_errors,  "1")
-               , (a_issue_errors,    "0")
-               ] emptyRoot
-

reads file "test.xml", validates it, checks namespaces, does not issue any erros - but collects errors and appends the list of errors to the single element list for the document. - this enables the calling application to define own error handlers. -

writeDocument :: Attributes -> XmlStateFilter stateSource

the main filter for writing documents -

this filter can be configured by an option list like getXmlDocument -

available options are -

  • a_indent : indent document for readability, (default: no indentation) -
  • a_remove_whitespace : remove all redundant whitespace for shorten text (default: no removal) -
  • a_output_file : destination file for document, default is "-" for stdout -
  • a_output_encoding : encoding of document, default is a_encoding or utf8 -
  • a_output_xml : (default) issue XML: quote special XML chars >,<,",',& - add XML processing instruction - and encode document with respect to a_output_encoding, - if explizitly switched of, the plain text is issued, this is useful - for non XML output, e.g. generated Haskell code, LaTex, Java, ... -
  • a_show_tree : show tree representation of document (for debugging) -
  • a_show_haskell : show Haskell representaion of document (for debugging) -
  • a_issue_errors, a_collect_errors : see parseDocument -

a typical main program running in the XmlState monad - has the following structure: -

- main :: IO ()
- main
-     = do
-       argv <- getArgs                                              -- get the commandline arguments
-       (inp, outp, options) <- cmdlineOpts argv                     -- and evaluate them, return a key-value list
-                                                                    -- and input and output
-       res  <- run' $ application inp outp options $ emptyRoot      -- run the application
- 
-       exitWith (if null res
-                 then ExitFailure (-1)
-                 else exitSuccess
-                )
-
- application :: String -> String -> Attributes -> XmlStateFilter ()
- application inp outp al
-   = parseDocument (al ++ [(a_source, inp)])                        -- set options and source
-     .>>                                                            -- and parse document
-     processDocument                                                -- the hard work
-     .>>
-     writeDocument [(a_output_file, outp)]                          -- issue results
-     .>>
-     checkStatus                                                    -- check errors
-
-
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandler.html b/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandler.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandler.html +++ /dev/null @@ -1,108 +0,0 @@ - - -Text.XML.HXT.Parser.ProtocolHandler
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.ProtocolHandler
Documentation
getProtocolHandler :: String -> URI -> XmlStateFilter aSource
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerFile.html b/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerFile.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerFile.html +++ /dev/null @@ -1,106 +0,0 @@ - - -Text.XML.HXT.Parser.ProtocolHandlerFile
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.ProtocolHandlerFile
Documentation
getFileContents :: URI -> XmlStateFilter aSource
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerHttpCurl.html b/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerHttpCurl.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerHttpCurl.html +++ /dev/null @@ -1,106 +0,0 @@ - - -Text.XML.HXT.Parser.ProtocolHandlerHttpCurl
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.ProtocolHandlerHttpCurl
Documentation
getHttpContentsWithCurl :: URI -> XmlStateFilter aSource
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerHttpNative.html b/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerHttpNative.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerHttpNative.html +++ /dev/null @@ -1,106 +0,0 @@ - - -Text.XML.HXT.Parser.ProtocolHandlerHttpNative
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.ProtocolHandlerHttpNative
Documentation
getHttpContentsWithHttp :: URI -> XmlStateFilter aSource
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerHttpNativeOrCurl.html b/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerHttpNativeOrCurl.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-ProtocolHandlerHttpNativeOrCurl.html +++ /dev/null @@ -1,106 +0,0 @@ - - -Text.XML.HXT.Parser.ProtocolHandlerHttpNativeOrCurl
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.ProtocolHandlerHttpNativeOrCurl
Documentation
getHttpContentsNativeOrWithCurl :: URI -> XmlStateFilter aSource
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-XmlInput.html b/doc/hxt-filter/Text-XML-HXT-Parser-XmlInput.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-XmlInput.html +++ /dev/null @@ -1,658 +0,0 @@ - - -Text.XML.HXT.Parser.XmlInput
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.XmlInput
Synopsis
getXmlContents :: XmlStateFilter a
getXmlEntityContents :: XmlStateFilter a
getUrlContents :: XmlStateFilter a
getContentLength :: XmlFilter
guessDocEncoding :: XmlStateFilter a
runInLocalURIContext :: XmlStateFilter a -> XmlStateFilter a
runInNewURIContext :: String -> XmlStateFilter a -> XmlStateFilter a
getBaseURI :: XState state String
setBaseURI :: String -> XState state ()
getAbsolutURI :: String -> XState state String
isStandaloneDocument :: XState state Bool
Documentation
getXmlContents :: XmlStateFilter aSource

filter for reading the content of a XML document -

input is a root node with the source as an attibute - the text is read, the encoding scheme is parsed and selected - and the input is translated into the internal UTF-8 string representation -

getXmlEntityContents :: XmlStateFilter aSource

filter for reading the content of an external XML entity -

see also : getXmlContents -

getUrlContents :: XmlStateFilter aSource

the hard io operations -

for reading a file or accessing a document via http - input must be a root node with a source attribute specifying the URI -

getContentLength :: XmlFilterSource
compute the length of the data for a document read previously - by a call of 'getUrlContents. The result is stored as an attribute - value in the document root node. the attribute name is a_contentLength -
guessDocEncoding :: XmlStateFilter aSource

guessEncoding uses encoding attribute and content - to determine the encoding scheme. -

it's assumed that an encoding spec has been tried to parse before guessing the encoding. -

UTF-8 is the default encoding -

other supported encodings are ISO-8859-1 (also known as ISO-Latin-1), - US-ASCII, UTF-16 or ISO-10646-UCS-2, UTF-16BE, UTF-16LE -

runInLocalURIContext :: XmlStateFilter a -> XmlStateFilter aSource

filter command for saving and restoring - the base URI -

  • 1.parameter f : the filter that possible changes the base URI -
  • returns : a filter with the same effect as f, that restores the base URI after application of f -
runInNewURIContext :: String -> XmlStateFilter a -> XmlStateFilter aSource
filter command for running an action in a new URI context -
getBaseURI :: XState state StringSource

read the current base URI -

see also : setBaseURI -

setBaseURI :: String -> XState state ()Source

set the base URI, all other URIs are handled relative to this base URI -

the default base URI is file:///<current-working-dir>/ -

see also : getBaseURI -

getAbsolutURI :: String -> XState state StringSource

transform an URI into an absolut URI using the current base URI -

  • 1.parameter uri : the URI as string -
  • returns : the absolut URI as string or "" in case of an error -
isStandaloneDocument :: XState state BoolSource
predicate for testing the standalone document attribute -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-XmlOutput.html b/doc/hxt-filter/Text-XML-HXT-Parser-XmlOutput.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-XmlOutput.html +++ /dev/null @@ -1,583 +0,0 @@ - - -Text.XML.HXT.Parser.XmlOutput
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.XmlOutput
Description
output functions - implemented as filer -
Synopsis
putXmlDoc :: XmlStateFilter a
putXmlDocToFile :: String -> XmlStateFilter a
putXmlTree :: XmlStateFilter a
putXmlSource :: XmlStateFilter a
hPutXmlDoc :: Handle -> XmlStateFilter a
hPutXmlTree :: Handle -> XmlStateFilter a
hPutXmlSource :: Handle -> XmlStateFilter a
traceF :: Int -> XmlStateFilter a -> XmlStateFilter a
traceMsg :: Int -> String -> XmlStateFilter a
traceTree :: XmlStateFilter a
traceSource :: XmlStateFilter a
Documentation
putXmlDoc :: XmlStateFilter aSource

document output for standard output -

see also : hPutXmlDoc -

putXmlDocToFile :: String -> XmlStateFilter aSource

document output on a given file name -

Result is the input document -

see also : hPutXmlDoc, putXmlDoc -

putXmlTree :: XmlStateFilter aSource
putXmlSource :: XmlStateFilter aSource
hPutXmlDoc :: Handle -> XmlStateFilter aSource

document output for arbitrary files. -

Result is the input document -

hPutXmlTree :: Handle -> XmlStateFilter aSource
output of tree representation for trace -
hPutXmlSource :: Handle -> XmlStateFilter aSource
output of text representation for trace -
traceF :: Int -> XmlStateFilter a -> XmlStateFilter aSource
traceMsg :: Int -> String -> XmlStateFilter aSource
traceTree :: XmlStateFilter aSource
traceSource :: XmlStateFilter aSource
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser-XmlParser.html b/doc/hxt-filter/Text-XML-HXT-Parser-XmlParser.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser-XmlParser.html +++ /dev/null @@ -1,184 +0,0 @@ - - -Text.XML.HXT.Parser.XmlParser
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser.XmlParser
Description
Xml Parser: the main parse filter -
Synopsis
parseXmlDoc :: XmlStateFilter a
substXmlEntities :: XmlFilter
Documentation
parseXmlDoc :: XmlStateFilter aSource
The monadic parser for a whole document. - input must be a root node with a single text child. - Error messages are issued and global error state is set. -
substXmlEntities :: XmlFilterSource
Filter for substitution of all occurences of the predefined XML entites quot, amp, lt, gt, apos - by equivalent character references -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Parser.html b/doc/hxt-filter/Text-XML-HXT-Parser.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Parser.html +++ /dev/null @@ -1,178 +0,0 @@ - - -Text.XML.HXT.Parser
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Parser
Description

Simple parse functions. -

the main building blocks for an application. - this module exports all important functions for parsing, validating and transforming XML. - it also exports all basic datatypes and functions of the toolbox. -

Documentation
module Text.XML.HXT.DOM
module Text.XML.HXT.Parser.XmlParser
module Text.XML.HXT.Parser.HtmlParser
module Text.XML.HXT.Parser.XmlInput
module Text.XML.HXT.Parser.XmlOutput
module Text.XML.HXT.Parser.DTDProcessing
module Text.XML.HXT.Parser.MainFunctions
module Text.XML.HXT.Validator.Validation
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Validator-AttributeValueValidation.html b/doc/hxt-filter/Text-XML-HXT-Validator-AttributeValueValidation.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Validator-AttributeValueValidation.html +++ /dev/null @@ -1,232 +0,0 @@ - - -Text.XML.HXT.Validator.AttributeValueValidation
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Validator.AttributeValueValidation
Description
This module provides functions for validating attributes. -
Synopsis
checkAttributeValue :: XmlTrees -> XmlTree -> XmlFilter
normalizeAttributeValue :: Maybe XmlTree -> String -> String
Documentation
checkAttributeValue :: XmlTrees -> XmlTree -> XmlFilterSource

Checks if the attribute value meets the lexical constraints of its type. -

  • 1.parameter dtdPart : the children of the DOCTYPE node -
  • 2.parameter attrDecl : the declaration of the attribute from the DTD -
  • returns : a function which takes an element (XTag or XDTD ATTLIST), - checks if the attribute value meets the lexical constraints - of its type and returns a list of errors -
normalizeAttributeValue :: Maybe XmlTree -> String -> StringSource

Normalizes an attribute value with respect to its type. (3.3.3 / p.29 in Spec) -

  • 1.parameter attrDecl : the declaration of the attribute from the DTD. Expected - is a list. If the list is empty, no declaration exists. -
  • 2.parameter value : the attribute value to be normalized -
  • returns : the normalized value -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Validator-DTDValidation.html b/doc/hxt-filter/Text-XML-HXT-Validator-DTDValidation.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Validator-DTDValidation.html +++ /dev/null @@ -1,199 +0,0 @@ - - -Text.XML.HXT.Validator.DTDValidation
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Validator.DTDValidation
Description
This module provides functions for validating the DTD of XML documents - represented as XmlTree. -
Synopsis
removeDoublicateDefs :: XmlFilter
validateDTD :: XmlFilter
Documentation
removeDoublicateDefs :: XmlFilterSource

Removes doublicate declarations from the DTD, which first declaration is - binding. This is the case for ATTLIST and ENTITY declarations. -

  • returns : A function that replaces the children of DOCTYPE nodes by a list - where all multiple declarations are removed. -
validateDTD :: XmlFilterSource

Validate a DTD. -

  • returns : a functions which takes the DTD subset of the XmlTree, checks - if the DTD is valid and returns a list of errors -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Validator-DocTransformation.html b/doc/hxt-filter/Text-XML-HXT-Validator-DocTransformation.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Validator-DocTransformation.html +++ /dev/null @@ -1,164 +0,0 @@ - - -Text.XML.HXT.Validator.DocTransformation
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Validator.DocTransformation
Description
This module provides functions for transforming XML documents represented as - XmlTree with respect to its DTD. -
Synopsis
transform :: XmlTree -> XmlTree -> XmlTrees
Documentation
transform :: XmlTree -> XmlTree -> XmlTreesSource

filter for transforming the document. -

  • 1.parameter dtdPart : the DTD subset (Node DOCTYPE) of the XmlTree -
  • 2.parameter doc : the document subset of the XmlTree -
  • returns : a list of errors -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Validator-DocValidation.html b/doc/hxt-filter/Text-XML-HXT-Validator-DocValidation.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Validator-DocValidation.html +++ /dev/null @@ -1,164 +0,0 @@ - - -Text.XML.HXT.Validator.DocValidation
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Validator.DocValidation
Description
This module provides functions for validating XML Documents represented as - XmlTree. -
Synopsis
validateDoc :: XmlTree -> XmlTree -> XmlTrees
Documentation
validateDoc :: XmlTree -> XmlTree -> XmlTreesSource

Validate a document. -

  • 1.parameter dtdPart : the DTD subset (Node DOCTYPE) of the XmlTree -
  • 2.parameter doc : the document subset of the XmlTree -
  • returns : a list of errors -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Validator-IdValidation.html b/doc/hxt-filter/Text-XML-HXT-Validator-IdValidation.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Validator-IdValidation.html +++ /dev/null @@ -1,167 +0,0 @@ - - -Text.XML.HXT.Validator.IdValidation
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Validator.IdValidation
Description
This module provides functions for checking special IDIDREFIDREFS constraints. -
Synopsis
validateIds :: XmlTree -> XmlTree -> XmlTrees
Documentation
validateIds :: XmlTree -> XmlTree -> XmlTreesSource

Perform the validation of the IDIDREFIDREFS constraints. -

  • 1.parameter dtdPart : the DTD subset (Node DOCTYPE) of the XmlTree -
  • 2.parameter doc : the document subset of the XmlTree -
  • returns : a list of errors -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Validator-RE.html b/doc/hxt-filter/Text-XML-HXT-Validator-RE.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Validator-RE.html +++ /dev/null @@ -1,1152 +0,0 @@ - - -Text.XML.HXT.Validator.RE
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Validator.RE
Description

A module for regular expression matching based on derivatives of regular expressions. -

The code was taken from Joe English (http://www.flightlab.com/~joe/sgml/validate.html). - Tested and extended by Martin Schmidt. -

Further references for the algorithm: -

Janusz A. Brzozowski. -

Derivatives of Regular Expressions. Journal of the ACM, Volume 11, Issue 4, 1964. -

Mark Hopkins. -

Regular Expression Package. Posted to comp.compilers, 1994. - Available per FTP at ftp://iecc.com/pub/file/regex.tar.gz. -

Synopsis
data RE a
= RE_ZERO String
| RE_UNIT
| RE_SYM a
| RE_DOT
| RE_REP (RE a)
| RE_PLUS (RE a)
| RE_OPT (RE a)
| RE_SEQ (RE a) (RE a)
| RE_ALT (RE a) (RE a)
re_unit :: RE a
re_zero :: String -> RE a
re_sym :: a -> RE a
re_rep :: RE a -> RE a
re_plus :: RE a -> RE a
re_opt :: RE a -> RE a
re_seq :: RE a -> RE a -> RE a
re_alt :: RE a -> RE a -> RE a
re_dot :: RE a
checkRE :: Show a => RE a -> String
matches :: (Eq a, Show a) => RE a -> [a] -> RE a
nullable :: Show a => RE a -> Bool
printRE :: Show a => RE a -> String
Documentation
data RE a Source
Data type for regular expressions. -
Constructors
RE_ZERO String
RE_UNIT
RE_SYM a
RE_DOT
RE_REP (RE a)
RE_PLUS (RE a)
RE_OPT (RE a)
RE_SEQ (RE a) (RE a)
RE_ALT (RE a) (RE a)
show/hide Instances
Eq a => Eq (RE a)
Show a => Show (RE a)
re_unit :: RE aSource

Constructs a regular expression for an empty sequence. -

  • returns : regular expression for an empty sequence -
re_zero :: String -> RE aSource

Constructs a regular expression for an empty set. -

  • 1.parameter errMsg : error message -
  • returns : regular expression for an empty set -
re_sym :: a -> RE aSource

Constructs a regular expression for accepting a symbol -

  • 1.parameter sym : the symbol to be accepted -
  • returns : regular expression for accepting a symbol -
re_rep :: RE a -> RE aSource

Constructs an optional repetition (*) of a regular expression -

  • 1.parameter re_a : regular expression to be repeted -
  • returns : new regular expression -
re_plus :: RE a -> RE aSource

Constructs a repetition (+) of a regular expression -

  • 1.parameter re_a : regular expression to be repeted -
  • returns : new regular expression -
re_opt :: RE a -> RE aSource

Constructs an option (?) of a regular expression -

  • 1.parameter re_a : regular expression to be optional -
  • returns : new regular expression -
re_seq :: RE a -> RE a -> RE aSource

Constructs a sequence (,) of two regular expressions -

  • 1.parameter re_a : first regular expression in sequence -
  • 2.parameter re_b : second regular expression in sequence -
  • returns : new regular expression -
re_alt :: RE a -> RE a -> RE aSource

Constructs an alternative (|) of two regular expressions -

  • 1.parameter re_a : first regular expression of alternative -
  • 2.parameter re_b : second regular expression of alternative -
  • returns : new regular expression -
re_dot :: RE aSource

Constructs a regular expression for accepting any singel symbol -

  • returns : regular expression for accepting any singel symbol -
checkRE :: Show a => RE a -> StringSource

Checks if an input matched a regular expression. The function should be - called after matches. -

Was the sentence used in matches in the language of the regular expression? - -> matches e s == s `in` L(e)? -

  • 1.parameter re : the derived regular expression -
  • returns : empty String if input matched the regular expression, otherwise - an error message is returned -
matches :: (Eq a, Show a) => RE a -> [a] -> RE aSource

Derives a regular expression with respect to a sentence. -

  • 1.parameter re : regular expression -
  • 2.parameter s : sentence to which the regular expression is applied -
  • returns : the derived regular expression -
nullable :: Show a => RE a -> BoolSource

Checks if a regular expression matches the empty sequence. -

nullable e == [] `in` L(e) -

This check indicates if a regular expression fits to a sentence or not. -

  • 1.parameter re : regular expression to be checked -
  • returns : true if regular expression matches the empty sequence, - otherwise false -
printRE :: Show a => RE a -> StringSource

Constructs a string representation of a regular expression. -

  • 1.parameter re : a regular expression -
  • returns : the string representation of the regular expression -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Validator-Validation.html b/doc/hxt-filter/Text-XML-HXT-Validator-Validation.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Validator-Validation.html +++ /dev/null @@ -1,180 +0,0 @@ - - -Text.XML.HXT.Validator.Validation
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Validator.Validation
Description

This module provides a state filter as a main function for validating XML documents. -

The real validation is done with pure filters from module Text.XML.HXT.Validator.ValidationFilter -

Author : .\artin Schmidt -

Synopsis
getValidatedDoc :: XmlStateFilter state
module Text.XML.HXT.Validator.ValidationFilter
Documentation
getValidatedDoc :: XmlStateFilter stateSource

monadic filter for validating and transforming a wellformed document. -

the main function for validation. -

the input tree must consist of a root node with a complete document and DTD. - Result is the single element list containing same tree but tranformed with respect to the DTD, - or, in case of errors, the root with an empty list of children -

module Text.XML.HXT.Validator.ValidationFilter
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Validator-ValidationFilter.html b/doc/hxt-filter/Text-XML-HXT-Validator-ValidationFilter.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Validator-ValidationFilter.html +++ /dev/null @@ -1,387 +0,0 @@ - - -Text.XML.HXT.Validator.ValidationFilter
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Validator.ValidationFilter
Description
This module provides functions for validating XML documents represented as - XmlTree. -
Synopsis
getDTDSubset :: XmlFilter
validate :: XmlFilter
validateDTD :: XmlFilter
validateDoc :: XmlFilter
removeDoublicateDefs :: XmlFilter
transform :: XmlFilter
Documentation
getDTDSubset :: XmlFilterSource
validate :: XmlFilterSource

Main validation filter. Check if the DTD and the document are valid. -

  • returns : a function which expects a complete document as XmlTree input - and returns a list of all errors found. -
validateDTD :: XmlFilterSource

Check if the DTD is valid. -

  • returns : a function which expects an XmlTree from the parser as input - and returns a list of all errors found in the DTD. -
validateDoc :: XmlFilterSource

Check if the document corresponds to the given DTD. -

  • returns : a function which expects a complete document as XmlTree input - and returns a list of all errors found in the content part. -
removeDoublicateDefs :: XmlFilterSource

Removes doublicate declarations from the DTD which first declaration is - binding. This is the case for ATTLIST and ENTITY declarations. -

  • returns : A function that replaces the children of DOCTYPE nodes by a list - where all multiple declarations are removed. -
transform :: XmlFilterSource

filter for transforming a document with respect to the given DTD. -

Validating parsers - are expected to normalize attribute values and add default values. - This function should be called after a successful validation. -

  • returns : a function which expects a complete XML document tree - and returns the transformed XmlTree -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/Text-XML-HXT-Validator-XmlRE.html b/doc/hxt-filter/Text-XML-HXT-Validator-XmlRE.html deleted file mode 100644 --- a/doc/hxt-filter/Text-XML-HXT-Validator-XmlRE.html +++ /dev/null @@ -1,874 +0,0 @@ - - -Text.XML.HXT.Validator.XmlRE
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).Source codeContentsIndex
Text.XML.HXT.Validator.XmlRE
Description

A module for regular expression matching, adapted for XML DTDs. -

This module is based on the module RE. -

Author .\artin Schmidt -

Synopsis
data RE a
checkRE :: Show a => RE a -> String
matches :: RE String -> XmlTrees -> RE String
printRE :: Show a => RE a -> String
re_unit :: RE a
re_zero :: String -> RE a
re_sym :: a -> RE a
re_rep :: RE a -> RE a
re_plus :: RE a -> RE a
re_opt :: RE a -> RE a
re_seq :: RE a -> RE a -> RE a
re_alt :: RE a -> RE a -> RE a
re_dot :: RE a
Documentation
data RE a Source
Data type for regular expressions. -
show/hide Instances
Eq a => Eq (RE a)
Show a => Show (RE a)
checkRE :: Show a => RE a -> StringSource

Checks if an input matched a regular expression. The function should be - called after matches. -

Was the sentence used in matches in the language of the regular expression? - -> matches e s == s `in` L(e)? -

  • 1.parameter re : the derived regular expression -
  • returns : empty String if input matched the regular expression, otherwise - an error message is returned -
matches :: RE String -> XmlTrees -> RE StringSource

Derives a regular expression with respect to a list of elements. -

  • 1.parameter re : regular expression -
  • 2.parameter list : list of elements to which the regular expression is applied -
  • returns : the derived regular expression -
printRE :: Show a => RE a -> StringSource

Constructs a string representation of a regular expression. -

  • 1.parameter re : a regular expression -
  • returns : the string representation of the regular expression -
re_unit :: RE aSource

Constructs a regular expression for an empty sequence. -

  • returns : regular expression for an empty sequence -
re_zero :: String -> RE aSource

Constructs a regular expression for an empty set. -

  • 1.parameter errMsg : error message -
  • returns : regular expression for an empty set -
re_sym :: a -> RE aSource

Constructs a regular expression for accepting a symbol -

  • 1.parameter sym : the symbol to be accepted -
  • returns : regular expression for accepting a symbol -
re_rep :: RE a -> RE aSource

Constructs an optional repetition (*) of a regular expression -

  • 1.parameter re_a : regular expression to be repeted -
  • returns : new regular expression -
re_plus :: RE a -> RE aSource

Constructs a repetition (+) of a regular expression -

  • 1.parameter re_a : regular expression to be repeted -
  • returns : new regular expression -
re_opt :: RE a -> RE aSource

Constructs an option (?) of a regular expression -

  • 1.parameter re_a : regular expression to be optional -
  • returns : new regular expression -
re_seq :: RE a -> RE a -> RE aSource

Constructs a sequence (,) of two regular expressions -

  • 1.parameter re_a : first regular expression in sequence -
  • 2.parameter re_b : second regular expression in sequence -
  • returns : new regular expression -
re_alt :: RE a -> RE a -> RE aSource

Constructs an alternative (|) of two regular expressions -

  • 1.parameter re_a : first regular expression of alternative -
  • 2.parameter re_b : second regular expression of alternative -
  • returns : new regular expression -
re_dot :: RE aSource

Constructs a regular expression for accepting any singel symbol -

  • returns : regular expression for accepting any singel symbol -
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/doc-index.html b/doc/hxt-filter/doc-index.html deleted file mode 100644 --- a/doc/hxt-filter/doc-index.html +++ /dev/null @@ -1,5830 +0,0 @@ - - -hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant). (Index)
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).ContentsIndex
Search:
$$Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
$$<Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
+++Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
+++>>Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
++=Text.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
+=Text.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
..>Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
.>Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
.>>Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
/>Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
:->Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
</Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
add1AttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
addAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
addAttrIntText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
addAttrlText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
addDTDAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
addEntriesText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
addEntryText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
addFatalText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
addHeadlineToXmlDocText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
addXmlPiToDocText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
allButText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
allBut1Text.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
aNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
asciiLetterText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
AssocListText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
atagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
ATTLISTText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
attrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
AttributesText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
attrlOfDTDText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
AttrNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
attrNodesText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
attrValueText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
attrValueTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
attrValueT'Text.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
a_canonicalizeText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_check_namespacesText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_check_restrictionsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_collect_errorsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_columnText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_contentLengthText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_defaultText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_default_baseuriText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_canonicalizeText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_check_namespacesText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_check_restrictionsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_collect_errorsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_issue_errorsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_issue_warningsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_preserve_commentText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_remove_whitespaceText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_use_curlText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_validateText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_validate_externalRefText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_do_not_validate_includeText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_encodingText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_errorText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_error_logText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_helpText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_ignore_encoding_errorsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_ignore_none_xml_contentsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_indentText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_issue_errorsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_issue_warningsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_kindText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_lineText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_mime_typesText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_modifierText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_moduleText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_nameText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_no_empty_elementsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_no_xml_piText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_options_curlText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_output_changesText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_output_encodingText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_output_fileText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_output_htmlText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_output_xmlText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_parse_by_mimetypeText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_parse_htmlText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_parse_xmlText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_perefText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_preserve_commentText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_propagate_errorsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_proxyText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_relax_schemaText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_remove_whitespaceText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_show_haskellText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_show_treeText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_sourceText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_standaloneText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_statusText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_strict_inputText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_tagsoupText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_traceText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_typeText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_urlText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_use_curlText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_validateText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_validate_externalRefText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_validate_includeText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_valueText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_verboseText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_versionText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_xmlText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
a_xmlnsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
barText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
buildUniversalNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
canonicalizeAllNodesText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
canonicalizeForXPathText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
canonicalizeTreeText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
cardNTreeText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
cardTreeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
catData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
catMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
cdataText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
cDSectText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
chainText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
chain'Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
changeChildrenData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
changeNodeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
changeState
1 (Function)Control.Monad.MonadStateIO
2 (Function)Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
changeSysStateText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
changeSysStateAttrsText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
charDataText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
charData'Text.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
charRefText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
charRefTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
checkAttributeValueText.XML.HXT.Validator.AttributeValueValidation
checkREText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
checkResultText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
checkStatusText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
checkWellformedDocText.XML.HXT.Parser.DTDProcessing, Text.XML.HXT.Parser
ChildNodesText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
childNodesText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
choiceData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
choiceMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
clearStatusText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
closesHtmlTagText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
cmtText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
collapseAllXTextText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
collapseXTextText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
commaText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
commentText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
concResText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
CONDSECTText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
containingData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
containingMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
CONTENTText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
contentText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
contentWithTextDeclText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
c_errText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
c_fatalText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
c_okText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
c_warnText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
deepData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
deepestData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
del1AttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
delEntriesText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
delEntryText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
depthNTreeText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
depthTreeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
DOCTYPEText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
doctypedeclText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
documentText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
document'Text.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
dqText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
dtdText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
DTDElemText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
ELEMENTText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
elementText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
emptyHtmlTagsText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
emptyRootText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
encNameText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
encodingDeclText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
ENTITYText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
entityCharTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
entityRefText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
entityRefTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
entityTokensTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
entityValueText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
entityValueTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
eqText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
equalQNameByText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
equivQNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
equivUriText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
errText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
errClassText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
errorMsgHandlerText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
errorMsgLoggingText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
errorMsgLoggingAndToStderrText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
errorMsgToStderrText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
escapeXmlAttrValueText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
escapeXmlDocText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
escapeXmlTextText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
etagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
fatalText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
foldNTreeText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
foldTreeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
formatNTreeText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
formatNTreeFData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
formatTreeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
formatXmlContentsText.XML.HXT.DOM, Text.XML.HXT.Parser
formatXmlTreeText.XML.HXT.DOM, Text.XML.HXT.Parser
fromAttrlText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
fromTreelText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
generalOptionsText.XML.HXT.DOM, Text.XML.HXT.Parser
getAbsolutURIText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
getAttrlText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getBaseURIText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
getChildrenData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getContentLengthText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
getDTDSubsetText.XML.HXT.Validator.ValidationFilter, Text.XML.HXT.Validator.Validation, Text.XML.HXT.Parser
getDTDValueText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getErrorMsgText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getFileContentsText.XML.HXT.Parser.ProtocolHandlerFile
getHtmlDocText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
getHttpContentsNativeOrWithCurlText.XML.HXT.Parser.ProtocolHandlerHttpNativeOrCurl
getHttpContentsWithCurlText.XML.HXT.Parser.ProtocolHandlerHttpCurl
getHttpContentsWithHttpText.XML.HXT.Parser.ProtocolHandlerHttpNative
getNameText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getNodeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getNsValueText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getProtocolHandlerText.XML.HXT.Parser.ProtocolHandler
getState
1 (Function)Control.Monad.MonadStateIO
2 (Function)Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getSysErrorHandlerText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getSysParamText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getSysParamIntText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getSysParamTreeText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getSysParamWithDefaultText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getSysStateText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getTraceLevelText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getUrlContentsText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
getValidatedDocText.XML.HXT.Validator.Validation, Text.XML.HXT.Parser
getValueText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getWellformedDocText.XML.HXT.Parser.DTDProcessing, Text.XML.HXT.Parser
getXCdataText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getXCmtText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
getXmlContentsText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
getXmlDocumentText.XML.HXT.Parser.MainFunctions, Text.XML.HXT.Parser
getXmlEntityContentsText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
gtText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
guardsData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
guardsMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
guessDocEncodingText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
hasAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
hasEntryText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
haskellRepOfXmlDocText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
hasLocalPartText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
hasNamespaceText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
hasNsAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
hasOptionText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
hasPrefixText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
hasValueText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
hPutXmlDocText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
hPutXmlSourceText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
hPutXmlTreeText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
httpPrefixText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iffData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
ifMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
IfThenData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
indentDocText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
initialSysStateText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
inputOptionsText.XML.HXT.DOM, Text.XML.HXT.Parser
insertChildrenAfterData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
insertChildrenAtData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
intValueOfText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
io
1 (Function)Control.Monad.MonadStateIO
2 (Function)Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isAttlistText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isAttlistOfElementText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isAttlistParameterEntityText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isAttrNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isCondSectText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isDeclaredNamespaceText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isDefaultAttrKindText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isDoctypeText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isDTDElemNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isDTDNameText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isElemContentParamEntityText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isElementText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isElemWithContentText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isEmptyElementText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isEmptyHtmlTagText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
isEntityText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isEnumAttrTypeText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isErrorText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isErrorNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isExternalParameterEntityText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isFatalErrorText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isFixedAttrKindText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isIdAttrTypeText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isIdRefAttrTypeText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isInnerData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isInnerHtmlTagOfText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
isInternalParameterEntityText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isLeafData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isMixedContentElementText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isNamespaceDeclText.XML.HXT.DOM.NamespaceFilter, Text.XML.HXT.DOM.Namespace, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isNameSpaceNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isNCNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isNotationText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isNotationAttrTypeText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isNsAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isNsTagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isNullXNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_1Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_10Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_11Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_13Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_14Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_15Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_16Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_2Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_3Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_4Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_5Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_6Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_7Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_8Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
iso8859_9Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isOfData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isOfAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isOfAttrNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isOfNodeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isOfPiText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isOfPiNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isOfTagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isOfTagNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isOfTextText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isOfTextNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isoLatin1Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isParameterEntityText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isPeRefText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isPiText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isPiNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isRequiredAttrKindText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isRootText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isRootNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isStandaloneDocumentText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
issueErrText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
issueErrorText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
issueFatalText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
issueWarnText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isTagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isTagNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isTextText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isTextNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isTrueValueText.XML.HXT.DOM, Text.XML.HXT.Parser
isUnparsedEntityText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isWarningText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isWellformedNameSpaceNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isWellformedNSDeclText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isWellformedQNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isWellformedQualifiedNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isWhiteSpaceText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXAttrNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXCdataText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXCdataNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXCharRefText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXCharRefNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXCmtText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXCmtNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXDTDText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXDTDNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXEntityRefText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXEntityRefNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXErrorText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXErrorNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXmlPiText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXPiText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXPiNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXTagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXTagNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXTextText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
isXTextNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
keywordText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
keywordsText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
k_anyText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_cdataText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_defaultText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_emptyText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_entitiesText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_entityText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_enumerationText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_fixedText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_idText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_idrefText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_idrefsText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_ignoreText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_impliedText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_includeText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_ndataText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_nmtokenText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_nmtokensText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_notationText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_pcdataText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_perefText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_publicText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_requiredText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
k_systemText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
liftFText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
liftMfData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
localPartText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
localPart'Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
localPartOfText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
lookup1Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
lookupDefText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
lparText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
ltText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
mapNTreeText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
markupdeclText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
matches
1 (Function)Text.XML.HXT.Validator.RE
2 (Function)Text.XML.HXT.Validator.XmlRE
maybeString2XTextText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
miscText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
mkLeafData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkListText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
mkNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkNodeText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkNsNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkNTreeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkPrefixLocalPartText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkQAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkQAttrTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkQNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkQName'Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkQTagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkQTagTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkRootTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkSNsNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkTreeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXAttrTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXCdataText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXCdataTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXCharRefText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXCharRefTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXCmtText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXCmtTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXDTDText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXDTDTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXEntityRefText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXEntityRefTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXErrorText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXErrorTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXmlDeclTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXNsAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXNsAttrTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXNsTagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXNsTagTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXPERefTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXPiText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXPiTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXTagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXTagTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXTextText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
mkXTextTreeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
modifyAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
modifyChildrenData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
modifyNodeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
modifyNode0Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
modifyQNameText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
modifyTextText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
multiData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
NAMEText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
nameText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
nameOfText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
namePrefixText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
namePrefix'Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
namesText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
namespaceOfText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
NamespaceTableText.XML.HXT.DOM.NamespaceFilter, Text.XML.HXT.DOM.Namespace, Text.XML.HXT.DOM, Text.XML.HXT.Parser
namespaceUriText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
namespaceUri'Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
nameTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
ncNameText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
negData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
newDocumentText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
newDocument'Text.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
newRootText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
newXNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
nmtokenText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
nmtokensText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
nmtokenTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
nodesTreeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
noneData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
noneMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
normalizeAttributeValueText.XML.HXT.Validator.AttributeValueValidation
normalizeNsUriText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
NOTATIONText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
notContainingData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
NsEnvText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
NTree
1 (Data Constructor)Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
2 (Type/Class)Data.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
NTreesData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
nTreeToListText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
nullableText.XML.HXT.Validator.RE
nullXNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
numberLinesText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
numberLinesInXmlDocText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
oData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
ofDTDequalsText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
optionIsSetText.XML.HXT.DOM, Text.XML.HXT.Parser
orElseData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
outputOptionsText.XML.HXT.DOM, Text.XML.HXT.Parser
parseDocumentText.XML.HXT.Parser.MainFunctions, Text.XML.HXT.Parser
parseHtmlContentText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
parseHtmlDocText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
parseHtmlDocumentText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
parseHtmlTextText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
parseNameText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseNMTokenText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlAttrValueText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlContentText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlDocText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlDocEncodingSpecText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlDocumentText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlDTDPartText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlEncodingSpecText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlEntityEncodingSpecText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlGeneralEntityValueText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlPartText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
parseXmlTextText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
PENTITYText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
PEREFText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
peReferenceText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
peReferenceTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
performActionData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
pIText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
popenSystem.PipeOpen
prefixOfText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
printREText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
processAttrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
processAttrlText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
processAttrMText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
processBottomUpData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
processBottomUpIfNotData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
processBottomUpMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
processChildrenData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
processChildrenMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
processDTDText.XML.HXT.Parser.DTDProcessing, Text.XML.HXT.Parser
processGeneralEntitiesText.XML.HXT.Parser.DTDProcessing, Text.XML.HXT.Parser
processTopDownData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
processTopDownMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
processTopDownUntilData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
prologText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
propagateAndValidateNamespacesText.XML.HXT.DOM.Namespace, Text.XML.HXT.DOM, Text.XML.HXT.Parser
propagateNamespaceEnvText.XML.HXT.DOM.NamespaceFilter, Text.XML.HXT.DOM.Namespace, Text.XML.HXT.DOM, Text.XML.HXT.Parser
propagateNamespacesText.XML.HXT.DOM.NamespaceFilter, Text.XML.HXT.DOM.Namespace, Text.XML.HXT.DOM, Text.XML.HXT.Parser
pubidLiteralText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
putXmlDocText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
putXmlDocToFileText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
putXmlDocumentText.XML.HXT.Parser.MainFunctions, Text.XML.HXT.Parser
putXmlSourceText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
putXmlTreeText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
qattrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
qetagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
QNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
qNameText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
qtagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
qualifiedNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
quotedText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
REText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
referenceText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
referenceTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
relaxNamespaceText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
relaxOptionsText.XML.HXT.DOM, Text.XML.HXT.Parser
removeAllCommentText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
removeAllWhiteSpaceText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
removeCommentText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
removeDocWhiteSpaceText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
removeDoublicateDefs
1 (Function)Text.XML.HXT.Validator.DTDValidation
2 (Function)Text.XML.HXT.Validator.ValidationFilter, Text.XML.HXT.Validator.Validation, Text.XML.HXT.Parser
removeEncodingSpecText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
removeOptionsText.XML.HXT.DOM, Text.XML.HXT.Parser
removeWhiteSpaceText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
replaceAttrlText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
replaceChildrenData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
replaceNodeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
replaceQNameText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
RE_ALTText.XML.HXT.Validator.RE
re_altText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
RE_DOTText.XML.HXT.Validator.RE
re_dotText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
RE_OPTText.XML.HXT.Validator.RE
re_optText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
RE_PLUSText.XML.HXT.Validator.RE
re_plusText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
RE_REPText.XML.HXT.Validator.RE
re_repText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
RE_SEQText.XML.HXT.Validator.RE
re_seqText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
RE_SYMText.XML.HXT.Validator.RE
re_symText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
RE_UNITText.XML.HXT.Validator.RE
re_unitText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
RE_ZEROText.XML.HXT.Validator.RE
re_zeroText.XML.HXT.Validator.RE, Text.XML.HXT.Validator.XmlRE
rootTagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
rparText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
run
1 (Function)Control.Monad.MonadStateIO
2 (Function)Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
run'Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
run0Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
runHtmlParserText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
runInLocalURIContextText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
runInNewURIContextText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
satisfiesData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
sattrText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
sDDeclText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
selectOptionsText.XML.HXT.DOM, Text.XML.HXT.Parser
semiText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
separatorText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
seqFData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
seqMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setBaseURIText.XML.HXT.Parser.XmlInput, Text.XML.HXT.Parser
setChildrenData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setDefaultURIText.XML.HXT.Parser.DefaultURI
setErrorMsgLevelText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setLocalPart'Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setNamePrefix'Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setNamespaceText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setNamespaceUri'Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setNodeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setState
1 (Function)Control.Monad.MonadStateIO
2 (Function)Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setStatusText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setSysErrorHandlerText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setSysParamText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setSysParamIntText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setSysParamTreeText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setSysStateText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setSystemParamsText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
setTraceLevelText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
showElemTypeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
showOptionsText.XML.HXT.DOM, Text.XML.HXT.Parser
showXCharRefText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
showXEntityRefText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
showXErrorsText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
showXTextText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
singleCharText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
singleCharsText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
singleCharsTText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
skipSText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
skipS0Text.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
sPaceText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
sPace0Text.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
spiText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
sqText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
stagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
StateIOControl.Monad.MonadStateIO
statusOkText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
STIOControl.Monad.MonadStateIO
stringProtocolText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
substChildrenData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
substHtmlEntitiesText.XML.HXT.Parser.HtmlParser, Text.XML.HXT.Parser
substXmlEntitiesText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
SysState
1 (Type/Class)Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
2 (Data Constructor)Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
sysStateText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
SysStateAttrsText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
sysStateAttrsText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
sysStateErrorHandlerText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
systemLiteralText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
tagText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
TagNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
textDeclText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
textOfXNodeText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
TFilterData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
thisData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
thisMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
thisNodeText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
tNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
toAttrlText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
toNsEnvText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
toTreelText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
traceText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
traceCmdText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
traceFText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
traceMsgText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
traceSourceText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
traceStateText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
traceTreeText.XML.HXT.Parser.XmlOutput, Text.XML.HXT.Parser
transControl.Monad.MonadStateIO
transfAllCdataText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transfAllCdataEscapedText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transfAllCharRefText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transfCdataText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transfCdataEscapedText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transfCharRefText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transferDefaultURIText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transferEncodingText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transferMessageText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transferMimeTypeText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transferPrefixText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transferProtocolText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transferStatusText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transferURIText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transferVersionText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
transform
1 (Function)Text.XML.HXT.Validator.DocTransformation
2 (Function)Text.XML.HXT.Validator.ValidationFilter, Text.XML.HXT.Validator.Validation, Text.XML.HXT.Parser
trcStateControl.Monad.MonadStateIO
TreeData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
treeRepOfXmlDocText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
TSFilterData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
txtText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
t_rootText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
t_xmlText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
ucs2Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
unicodeStringText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
universalNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
universalNameOfText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
universalUriText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
unparseXmlDocText.XML.HXT.DOM.EditFilters, Text.XML.HXT.DOM, Text.XML.HXT.Parser
usAsciiText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
userStateText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
utf16Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
utf16beText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
utf16leText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
utf8Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
validateText.XML.HXT.Validator.ValidationFilter, Text.XML.HXT.Validator.Validation, Text.XML.HXT.Parser
validate1NamespacesText.XML.HXT.DOM.NamespaceFilter, Text.XML.HXT.DOM.Namespace, Text.XML.HXT.DOM, Text.XML.HXT.Parser
validateDoc
1 (Function)Text.XML.HXT.Validator.DocValidation
2 (Function)Text.XML.HXT.Validator.ValidationFilter, Text.XML.HXT.Validator.Validation, Text.XML.HXT.Parser
validateDTD
1 (Function)Text.XML.HXT.Validator.DTDValidation
2 (Function)Text.XML.HXT.Validator.ValidationFilter, Text.XML.HXT.Validator.Validation, Text.XML.HXT.Parser
validateIdsText.XML.HXT.Validator.IdValidation
validateNamespacesText.XML.HXT.DOM.NamespaceFilter, Text.XML.HXT.DOM.Namespace, Text.XML.HXT.DOM, Text.XML.HXT.Parser
valueOfText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
valueOfDTDText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
versionInfoText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
versionNumText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
versionOptionsText.XML.HXT.DOM, Text.XML.HXT.Parser
v_0Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_1Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_anyText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_childrenText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_choiceText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_emptyText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_mixedText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_noText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_nullText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_optionText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_pcdataText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_plusText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_seqText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_starText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
v_yesText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
warnText.XML.HXT.DOM.XmlTreeFilter, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
whenData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
whenMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
whenNotData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
whenNotMData.Tree.NTree.Filter, Text.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
writeDocumentText.XML.HXT.Parser.MainFunctions, Text.XML.HXT.Parser
XAttrText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xattrText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XCdataText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XCharRefText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XCmtText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xcmtText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XDTDText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XEntityRefText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xerrText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XErrorText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xmlContentModelToStringText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xMLDeclText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
xMLDecl'Text.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
XmlFilterText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xmlNamespaceText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xmlNamespaceXNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XmlNodeSetText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xmlnsNamespaceText.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xmlnsNamespaceXNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xmlnsQNText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xmlnsXNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XmlSFilterText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XmlState
1 (Type/Class)Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
2 (Data Constructor)Text.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XmlStateFilterText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XmlTreeText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XmlTreesText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xmlTreesToStringText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xmlTreesToTextText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xmlXNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XNameText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XNodeText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XNSText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XPiText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xreadText.XML.HXT.Parser.XmlParser, Text.XML.HXT.Parser
xshowText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XStateText.XML.HXT.DOM.XmlState, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XTagText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xtagText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
XTextText.XML.HXT.DOM.XmlTreeTypes, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xtextText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
xwarnText.XML.HXT.DOM.XmlTreeFunctions, Text.XML.HXT.DOM.XmlTree, Text.XML.HXT.DOM, Text.XML.HXT.Parser
diff --git a/doc/hxt-filter/haddock-util.js b/doc/hxt-filter/haddock-util.js deleted file mode 100644 --- a/doc/hxt-filter/haddock-util.js +++ /dev/null @@ -1,133 +0,0 @@ -// Haddock JavaScript utilities -function toggle(button,id) -{ - var n = document.getElementById(id).style; - if (n.display == "none") - { - button.src = "minus.gif"; - n.display = "block"; - } - else - { - button.src = "plus.gif"; - n.display = "none"; - } -} - - -var max_results = 75; // 50 is not enough to search for map in the base libraries -var shown_range = null; -var last_search = null; - -function quick_search() -{ - perform_search(false); -} - -function full_search() -{ - perform_search(true); -} - - -function perform_search(full) -{ - var text = document.getElementById("searchbox").value.toLowerCase(); - if (text == last_search && !full) return; - last_search = text; - - var table = document.getElementById("indexlist"); - var status = document.getElementById("searchmsg"); - var children = table.firstChild.childNodes; - - // first figure out the first node with the prefix - var first = bisect(-1); - var last = (first == -1 ? -1 : bisect(1)); - - if (first == -1) - { - table.className = ""; - status.innerHTML = "No results found, displaying all"; - } - else if (first == 0 && last == children.length - 1) - { - table.className = ""; - status.innerHTML = ""; - } - else if (last - first >= max_results && !full) - { - table.className = ""; - status.innerHTML = "More than " + max_results + ", press Search to display"; - } - else - { - // decide what you need to clear/show - if (shown_range) - setclass(shown_range[0], shown_range[1], "indexrow"); - setclass(first, last, "indexshow"); - shown_range = [first, last]; - table.className = "indexsearch"; - status.innerHTML = ""; - } - - - function setclass(first, last, status) - { - for (var i = first; i <= last; i++) - { - children[i].className = status; - } - } - - - // do a binary search, treating 0 as ... - // return either -1 (no 0's found) or location of most far match - function bisect(dir) - { - var first = 0, finish = children.length - 1; - var mid, success = false; - - while (finish - first > 3) - { - mid = Math.floor((finish + first) / 2); - - var i = checkitem(mid); - if (i == 0) i = dir; - if (i == -1) - finish = mid; - else - first = mid; - } - var a = (dir == 1 ? first : finish); - var b = (dir == 1 ? finish : first); - for (var i = b; i != a - dir; i -= dir) - { - if (checkitem(i) == 0) return i; - } - return -1; - } - - - // from an index, decide what the result is - // 0 = match, -1 is lower, 1 is higher - function checkitem(i) - { - var s = getitem(i).toLowerCase().substr(0, text.length); - if (s == text) return 0; - else return (s > text ? -1 : 1); - } - - - // from an index, get its string - // this abstracts over alternates - function getitem(i) - { - for ( ; i >= 0; i--) - { - var s = children[i].firstChild.firstChild.data; - if (s.indexOf(' ') == -1) - return s; - } - return ""; // should never be reached - } -} diff --git a/doc/hxt-filter/haddock.css b/doc/hxt-filter/haddock.css deleted file mode 100644 --- a/doc/hxt-filter/haddock.css +++ /dev/null @@ -1,267 +0,0 @@ -/* -------- Global things --------- */ - -BODY { - background-color: #ffffff; - color: #000000; - font-family: sans-serif; - } - -A:link { color: #0000e0; text-decoration: none } -A:visited { color: #0000a0; text-decoration: none } -A:hover { background-color: #e0e0ff; text-decoration: none } - -TABLE.vanilla { - width: 100%; - border-width: 0px; - /* I can't seem to specify cellspacing or cellpadding properly using CSS... */ -} - -TABLE.vanilla2 { - border-width: 0px; -} - -/* font is a little too small in MSIE */ -TT { font-size: 100%; } -PRE { font-size: 100%; } - -LI P { margin: 0pt } - -TD { - border-width: 0px; -} - -TABLE.narrow { - border-width: 0px; -} - -TD.s8 { height: 8px; } -TD.s15 { height: 15px; } - -SPAN.keyword { text-decoration: underline; } - -/* Resize the buttom image to match the text size */ -IMG.coll { width : 0.75em; height: 0.75em; margin-bottom: 0; margin-right: 0.5em } - -/* --------- Contents page ---------- */ - -DIV.node { - padding-left: 3em; -} - -DIV.cnode { - padding-left: 1.75em; -} - -SPAN.pkg { - position: absolute; - left: 50em; -} - -/* --------- Documentation elements ---------- */ - -TD.children { - padding-left: 25px; - } - -TD.synopsis { - padding: 2px; - background-color: #f0f0f0; - font-family: monospace - } - -TD.decl { - padding: 2px; - background-color: #f0f0f0; - font-family: monospace; - vertical-align: top; - } - -TD.topdecl { - padding: 2px; - background-color: #f0f0f0; - font-family: monospace; - vertical-align: top; -} - -TABLE.declbar { - border-spacing: 0px; - } - -TD.declname { - width: 100%; - } - -TD.declbut { - padding-left: 5px; - padding-right: 5px; - border-left-width: 1px; - border-left-color: #000099; - border-left-style: solid; - white-space: nowrap; - font-size: small; - } - -/* - arg is just like decl, except that wrapping is not allowed. It is - used for function and constructor arguments which have a text box - to the right, where if wrapping is allowed the text box squashes up - the declaration by wrapping it. -*/ -TD.arg { - padding: 2px; - background-color: #f0f0f0; - font-family: monospace; - vertical-align: top; - white-space: nowrap; - } - -TD.recfield { padding-left: 20px } - -TD.doc { - padding-top: 2px; - padding-left: 10px; - } - -TD.ndoc { - padding: 2px; - } - -TD.rdoc { - padding: 2px; - padding-left: 10px; - width: 100%; - } - -TD.body { - padding-left: 10px - } - -TD.pkg { - width: 100%; - padding-left: 10px -} - -TABLE.indexsearch TR.indexrow { - display: none; -} -TABLE.indexsearch TR.indexshow { - display: table-row; -} - -TD.indexentry { - vertical-align: top; - padding-right: 10px - } - -TD.indexannot { - vertical-align: top; - padding-left: 20px; - white-space: nowrap - } - -TD.indexlinks { - width: 100% - } - -/* ------- Section Headings ------- */ - -TD.section1 { - padding-top: 15px; - font-weight: bold; - font-size: 150% - } - -TD.section2 { - padding-top: 10px; - font-weight: bold; - font-size: 130% - } - -TD.section3 { - padding-top: 5px; - font-weight: bold; - font-size: 110% - } - -TD.section4 { - font-weight: bold; - font-size: 100% - } - -/* -------------- The title bar at the top of the page */ - -TD.infohead { - color: #ffffff; - font-weight: bold; - padding-right: 10px; - text-align: left; -} - -TD.infoval { - color: #ffffff; - padding-right: 10px; - text-align: left; -} - -TD.topbar { - background-color: #000099; - padding: 5px; -} - -TD.title { - color: #ffffff; - padding-left: 10px; - width: 100% - } - -TD.topbut { - padding-left: 5px; - padding-right: 5px; - border-left-width: 1px; - border-left-color: #ffffff; - border-left-style: solid; - white-space: nowrap; - } - -TD.topbut A:link { - color: #ffffff - } - -TD.topbut A:visited { - color: #ffff00 - } - -TD.topbut A:hover { - background-color: #6060ff; - } - -TD.topbut:hover { - background-color: #6060ff - } - -TD.modulebar { - background-color: #0077dd; - padding: 5px; - border-top-width: 1px; - border-top-color: #ffffff; - border-top-style: solid; - } - -/* --------- The page footer --------- */ - -TD.botbar { - background-color: #000099; - color: #ffffff; - padding: 5px - } -TD.botbar A:link { - color: #ffffff; - text-decoration: underline - } -TD.botbar A:visited { - color: #ffff00 - } -TD.botbar A:hover { - background-color: #6060ff - } - diff --git a/doc/hxt-filter/haskell_icon.gif b/doc/hxt-filter/haskell_icon.gif deleted file mode 100644 Binary files a/doc/hxt-filter/haskell_icon.gif and /dev/null differ diff --git a/doc/hxt-filter/hxt-filter.haddock b/doc/hxt-filter/hxt-filter.haddock deleted file mode 100644 Binary files a/doc/hxt-filter/hxt-filter.haddock and /dev/null differ diff --git a/doc/hxt-filter/index.html b/doc/hxt-filter/index.html deleted file mode 100644 --- a/doc/hxt-filter/index.html +++ /dev/null @@ -1,571 +0,0 @@ - - -hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).ContentsIndex
hxt-filter-8.3.0: A collection of tools for processing XML with Haskell (Filter variant).
The Haskell XML Toolbox bases on the ideas of HaXml and HXML. This package is a compatibitlity package for old software working with the filter approach like in HaXml. For new projects it's recomended to use the arrow based library (hxt). -
Modules
show/hideControl
show/hideMonad
Control.Monad.MonadStateIO
show/hideData
show/hideTree
show/hideNTree
Data.Tree.NTree.Filter
show/hideSystem
System.PipeOpen
show/hideText
show/hideXML
show/hideHXT
show/hideText.XML.HXT.DOM
Text.XML.HXT.DOM.EditFilters
Text.XML.HXT.DOM.Namespace
Text.XML.HXT.DOM.NamespaceFilter
Text.XML.HXT.DOM.XmlState
Text.XML.HXT.DOM.XmlTree
Text.XML.HXT.DOM.XmlTreeFilter
Text.XML.HXT.DOM.XmlTreeFunctions
Text.XML.HXT.DOM.XmlTreeTypes
show/hideText.XML.HXT.Parser
Text.XML.HXT.Parser.DTDProcessing
Text.XML.HXT.Parser.DefaultURI
Text.XML.HXT.Parser.HtmlParser
Text.XML.HXT.Parser.MainFunctions
Text.XML.HXT.Parser.ProtocolHandler
Text.XML.HXT.Parser.ProtocolHandlerFile
Text.XML.HXT.Parser.ProtocolHandlerHttpCurl
Text.XML.HXT.Parser.ProtocolHandlerHttpNative
Text.XML.HXT.Parser.ProtocolHandlerHttpNativeOrCurl
Text.XML.HXT.Parser.XmlInput
Text.XML.HXT.Parser.XmlOutput
Text.XML.HXT.Parser.XmlParser
show/hideValidator
Text.XML.HXT.Validator.AttributeValueValidation
Text.XML.HXT.Validator.DTDValidation
Text.XML.HXT.Validator.DocTransformation
Text.XML.HXT.Validator.DocValidation
Text.XML.HXT.Validator.IdValidation
Text.XML.HXT.Validator.RE
Text.XML.HXT.Validator.Validation
Text.XML.HXT.Validator.ValidationFilter
Text.XML.HXT.Validator.XmlRE
Produced by Haddock version 2.3.0
diff --git a/doc/hxt-filter/minus.gif b/doc/hxt-filter/minus.gif deleted file mode 100644 Binary files a/doc/hxt-filter/minus.gif and /dev/null differ diff --git a/doc/hxt-filter/plus.gif b/doc/hxt-filter/plus.gif deleted file mode 100644 Binary files a/doc/hxt-filter/plus.gif and /dev/null differ diff --git a/doc/hxt-filter/src/Control-Monad-MonadStateIO.html b/doc/hxt-filter/src/Control-Monad-MonadStateIO.html deleted file mode 100644 --- a/doc/hxt-filter/src/Control-Monad-MonadStateIO.html +++ /dev/null @@ -1,107 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- general usefull state monad for a local state and IO
---
--- This module is used for threading a state and io actions
--- through a computation.
--- Here the monad is constructed by hand.
--- It could easily be refactored with the use of the monad transformer library.
-
-
-module Control.Monad.MonadStateIO
-    ( module Control.Monad.MonadStateIO
-    )
-where
-
-import System.IO
-
--- ------------------------------------------------------------
-
-newtype StateIO state res = STIO { trans :: state -> IO (res, state) }
-
-instance Monad (StateIO state) where
-    return v
-	= STIO ( \s -> return (v, s))
-
-    STIO cmd >>= f
-	= STIO ( \s ->
-		  cmd s >>= \ (rl, s') ->
-		  (trans . f) rl s'
-		)
-
--- ------------------------------------------------------------
--- |
--- lift IO command to 'StateIO'
-
-io :: IO a -> StateIO state a
-io iocmd
-    = STIO ( \s ->
-	     do
-	     a <- iocmd
-	     return (a, s)
-	   )
-
--- ------------------------------------------------------------
-
--- |
--- state inspection command: a \"show\"-like function is applied to the state
--- and the result is written to stderr.
-
-trcState	:: (state -> String) -> StateIO state ()
-trcState fct
-    = STIO ( \s ->
-	      do
-	      hPutStr stderr $ fct s
-	      return ((), s)
-	    )
-
--- ------------------------------------------------------------
---
--- state access commands
-
--- |
--- change the state with a given function and return the new state
-
-changeState	:: (state -> state) -> StateIO state state
-changeState f
-    = STIO ( \s ->
-	     let s' = f s
-	     in
-	     return (s', s')
-	    )
-
--- |
--- set the state
-
-setState	:: state -> StateIO state state
-setState s
-    = changeState ( \_ -> s )
-
--- |
--- read the state
-
-getState	:: StateIO state state
-getState
-    = changeState id
-
--- ------------------------------------------------------------
--- |
--- run a 'StateIO' command with an initial state
-
-run :: state -> StateIO state res -> IO res
-run initialState (STIO cmd)
-    = do
-      (res, _finalState) <- cmd initialState
-      return res
-
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Data-Tree-NTree-Filter.html b/doc/hxt-filter/src/Data-Tree-NTree-Filter.html deleted file mode 100644 --- a/doc/hxt-filter/src/Data-Tree-NTree-Filter.html +++ /dev/null @@ -1,922 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
-
-{- |
-   Module     : Data.Tree.NTree.Filter
-   Copyright  : Copyright (C) 2005 Uwe Schmidt
-   License    : MIT
-
-   Maintainer : Uwe Schmidt (uwe\@fh-wedel.de)
-   Stability  : stable
-   Portability: portable
-
-   Filter for n-ary tree structure with filter combinators
-   copied and modified from HaXml (<http://www.cs.york.ac.uk/fp/HaXml/>)
-
-   Similar but more flexible functions for tree processing are defined in the
-   arrow classes "Control.Arrow.ArrowList", "Control.Arrow.ArrowIf", "Control.Arrow.ArrowTree" and "Control.Arrow.ArrowState".
-   For new applications, especially for XML processing, it's recommended to use the arrow interface
-   "Text.XML.HXT.Arrow" instead of this filter approach as part of the api "Text.XML.HXT.Parser"
-
--}
-
--- ------------------------------------------------------------
-
-module Data.Tree.NTree.Filter
-    ( module Data.Tree.NTree.TypeDefs
-    , TFilter
-    , TSFilter
-    , satisfies
-
-    -- * Filter
-    , none		-- simple filter
-    , this
-
-    , isOf
-    , isOfNode		-- predicate filter
-
-    , mkNTree		-- contructor filter
-
-    , replaceNode	-- simple editing
-    , replaceChildren
-
-    , modifyNode
-    , modifyNode0
-    , modifyChildren
-    , substChildren
-    , processChildren	-- filter combinators
-
-    , o
-    , (.>)
-    , seqF
-    , (..>)
-    , (+++)
-    , cat
-
-    , orElse		-- choices
-    , iff		-- if then else filter
-    , choice
-    , IfThen(..)
-    , when
-    , whenNot
-    , guards
-    , neg		-- negation
-    , containing	-- previous: with, but with is keyword in haskell extensions
-    , notContaining	-- previous: without
-
-    , (/>)		-- selectors
-    , (</)
-    , deep		-- recursive search
-    , deepest
-    , multi
-    , processBottomUp	-- recursive editing
-    , processBottomUpIfNot
-    , processTopDown
-    , processTopDownUntil
-    , insertChildrenAt
-    , insertChildrenAfter
-
-      -- * Monadic Filter
-    , thisM		-- monadic filter
-    , noneM
-    , (.>>)		-- monadic composition
-    , seqM		-- generalisation of .>>
-    , (+++>>)		-- monadic parallel combination, monadic +++
-    , catM		-- monadic form of cat
-    , ifM		-- monadic if then else
-    , choiceM		-- monadic choice
-    , whenM		-- special monadic ifs
-    , whenNotM
-    , guardsM
-    , containingM
-    , processChildrenM	-- monadic versions of recursive editing
-    , processTopDownM
-    , processBottomUpM
-    , liftMf		-- lift a normal filter to a monadic filter
-    , ($$)		-- apply a filter to a list
-    , ($$<)		-- apply a monad filter to a list
-    , performAction	-- run a command within a filter
-    )
-
-where
-
-
-import Data.Tree.NTree.TypeDefs
-
-infixl 6 `containing`, `notContaining`, `containingM`
-infixr 5 `o`, +++, +++>>
-infixl 5 />, </, `orElse`, .>, ..>, .>>
-infixr 4 `when`, `whenNot`, `guards`, `whenM`, `whenNotM`, `guardsM`
-infixr 3 :->
-infixr 0 $$, $$<
-
--- |
--- tree filter type: a function mapping a tree onto a list of trees
---
--- filter can be used in various ways, as predicates, selectors, transformers, ...
-
-type TFilter  node	= NTree  node -> NTrees node
-
--- |
--- a filter for sequences
-
-type TSFilter node	= NTrees node -> NTrees node
-
--- ------------------------------------------------------------
-
--- |
--- satisfies converts a result of a predicate filter into a boolean
---
--- is a shortcut for not . null
---
--- typical use in guards or ifs: @if (satisfies f) t then ... else ... @
---
---    * 1.parameter f :  the predicate filter
---
---    - 2.parameter t :  the tree to be tested
---
---    - returns : @b = not (null (f t))@
-
-satisfies	:: (a -> [b]) -> a -> Bool
-satisfies f	= not . null . f
-
--- ------------------------------------------------------------
---
--- simple filter
-
--- |
--- the null filter, returns the empty list
-
-none		:: a -> [b]
-none _		= []
-
--- |
--- the unit filter, returns the single element list containing the argument
-
-this		:: a -> [a]
-this n		= [n]
-
--- ------------------------------------------------------------
---
--- selecting filter
-
--- |
--- conversion from predicate function to filter
---
---    * 1.parameter p :  the predicate for testing the tree
---
---    - returns : 'this' or 'none' depending on the predicate
-
-isOf		:: (a -> Bool) -> (a -> [a])
-isOf p t
-    = if p t then [t] else []
-
--- |
--- select filter, selects trees with node values with a specific property
---
---    * 1.parameter p :  the predicate for testing the node value
---
---    - returns : @[]@ or @[t]@ depending on @p t@
---
--- a special case of 'isOf' filter
-
-isOfNode	:: (node -> Bool) -> TFilter node
-isOfNode p	= isOf (p . getNode)
-
--- ------------------------------------------------------------
---
--- simple editing filters
-
--- |
--- filter for substituting an arbitray tree by a constant
---
---    * 1.parameter t :  the result tree, the input tree is ignored
---
---    - returns : the filter
-
-mkNTree		:: NTree node -> TFilter node
-mkNTree t	= const [t]
-
--- |
--- filter for replacing the node
---
---    * 1.parameter n :  the new node
---
---    - returns : the editing filter
-
-replaceNode	:: node -> TFilter node
-replaceNode n (NTree _ cs)
-    = [NTree n cs]
-
--- |
--- filter for replacing the children
---
---    * 1.parameter cs :  cs the list of children
---
---    - returns : the filter
-
-replaceChildren	:: NTrees node -> TFilter node
-replaceChildren cs (NTree n _)
-    = [NTree n cs]
-
-modifyNode	:: (node -> Maybe node) -> TFilter node
-modifyNode tf (NTree n cs)
-    = maybe [] (\ n' -> [NTree n' cs]) (tf n)
-
--- |
--- filter for editing the node
---
---    * 1.parameter nf :  the XNode editing funtion
---
---    - returns : the filter
-
-modifyNode0	:: (node -> node) -> TFilter node
-modifyNode0 tf	= modifyNode (Just . tf)
-
--- |
--- filter for editing the children
---
--- all children are processed with a filter mapping lists to lists,
--- this enables not only elementwise editing by lifting a normal
--- filter to a list filter with @(f $$)@ (see '($$)') but also manipulation
--- of the order of the elements, e.g. "reverse" is an appropriate childen
--- editing function.
---
---    * 1.parameter csf :  the children editing function
---
---    - returns : the filter
---
--- see also : 'processChildren'
-
-modifyChildren	:: TSFilter node -> TFilter node
-modifyChildren f -- (NTree n cs)
-    -- = [NTree n (f cs)]
-    = substChildren (f . getChildren)
-
--- |
--- filter for substituting the children of a tree by
--- a new list of childen computed by applying a filter to the input tree.
--- 'modifyChildren' can be expressed by 'substChildren':
--- @modifyChildren f t@ is equal to @substChildren (f . getChildren)@
-
-substChildren	:: TFilter node -> TFilter node
-substChildren f t@(NTree n _cs)
-    = [NTree n (f t)]
-
--- ------------------------------------------------------------
---
--- combinators (copied from HaXml)
---
-
--- |
--- sequential composition of filters, usually written in infix notation f2 `o` f1.
---
--- for predicate filter the logical AND
---
---    * 1.parameter f2 :  the 2. filter
---
---    - 2.parameter f1 :  the 1. filter
---
---    - returns : the fiter applying first f1 to n and then f2 to the result (like function composition)
-
-o		:: (a -> [b]) -> (c -> [a]) -> (c -> [b])
-f `o` g		= concatMap f . g
-
--- |
--- pronounced \"followed by\", defined as: @f .> g = g \`o\` f@.
---
--- allows filter composition in a more readable way from left to right
---
---    * 1.parameter f1 :  the 1. filter
---
---    - 2.parameter f2 :  the 2. filter
---
---    - returns : the composition of f1 and f2
---
--- see also : 'o', '(..>)'
-
-(.>)		:: (a -> [b]) -> (b -> [c]) -> (a -> [c])
-f .> g		= g `o` f
-
--- |
--- apply a list of filters sequentially with '(.>)', for predicate filters the generalized AND
---
--- see also : '(.>)'
-
-seqF		:: [a -> [a]] -> (a -> [a])
-seqF		= foldl (.>) this
-
--- |
--- binary parallel composition, the logical OR for predicate filter
---
---    * 1.parameter f1 :  the 1. filter
---
---    - 2.parameter f2 :  the 2. filter
---
---    - returns : the filter for applying f1 and f2 both to an argument tree and concatenating the results
-
-(+++)		:: (a -> [b]) -> (a -> [b]) -> (a -> [b])
-f +++ g		= \ t -> f t ++ g t
-
--- |
--- special sequential composition.
---
--- filter f is applied to an argument t.
--- then filter g is applied to all elements of the result list,
--- but the argument t is also passed as extra parameter to g.
---
--- This allows for step by step transformations of a tree
--- with access to the original tree in every
--- transformation step.
---
--- see also : '(.>)', 'o'
-
-(..>)		:: (a -> [b]) -> (a -> b -> [d]) -> (a -> [d])
-f ..> g		= \ t -> (g t `o` f) t
-
--- |
--- apply a list of filters, a \"union\" for lists, for predicate filters the generalized OR
---
---    * 1.parameter fs :  the list of filters
---
---    - returns : the composing filter
-
-cat		:: [a -> [b]] -> (a -> [b])
-cat fs  t
-    = concat [ f t | f <- fs ]
-
--- |
--- Filter for editing the children of a tree element wise
---
---    * 1.parameter cf :  the filter applied to the children
---
---    - returns : the editing filter
---
--- see also : 'modifyChildren'
-
-processChildren	:: TFilter node -> TFilter node
-processChildren ft (NTree n cs)
-    = [NTree n (ft $$ cs)]
-
--- |
--- infix operator for applying a filter to a list of trees
---
---    * 1.parameter f :  the filter
---
---    - 2.parameter ts :  the list of trees
---
---    - returns : the concatenated list of results
-
-($$)		:: (a -> [b]) -> [a] -> [b]
-f $$ l
-    = concatMap f l
-
--- ------------------------------------------------------------
---
--- choices
---
-
--- |
--- directional choice, usually written in infix notation as f `orElse` g
---
---    * 1.parameter f :  the 1. filter
---
---    - 2.parameter g :  the 2. filter
---
---    - 3.parameter t :  the tree
---
---    - returns : the filter, that applies f to t, if the result is not the empty list, the result is found, else g t is the result
-
-orElse		:: (a -> [b]) -> (a -> [b]) -> (a -> [b])
-f `orElse` g
-    = \ t-> let
-	    res = f t
-	    in
-	    if null res
-	    then g t
-	    else res
-
--- |
--- if then else lifted to filters
---
---    * 1.parameter p :  the predicate filter
---
---    - 2.parameter t :  the \"then\" filter
---
---    - 3.parameter e :  the \"else\" filter
---
---    - returns : the resulting conditional filter
-
-iff		:: (a -> [c]) -> (a -> [b]) -> (a -> [b]) -> (a -> [b])
-iff p f g	= \ c -> if (satisfies p) c then f c else g c
-
--- |
--- when the predicate p holds, f is applied, else the identity filter this
---
---    * 1.parameter f :  the conditinally applied filter
---
---    - 2.parameter p :  the predicate
---
---    - returns : the conditional filter
---
--- see also : 'iff', 'whenNot', 'guards', 'whenM'
-
-when		:: (a -> [a]) -> (a -> [a]) -> (a -> [a])
-f `when` g	= iff g f this
-
--- |
--- the complementary filter of when
---
--- shortcut for f `when` neg g
---
--- see also : 'iff', 'when', 'whenNotM', 'neg'
-
-whenNot		:: (a -> [a]) -> (a -> [a]) -> (a -> [a])
-f `whenNot` g	= iff g this f
-
--- |
--- when the predicate p holds, f is applied, else the null filter none
---
---    * 1.parameter p :  the predicate filter
---
---    - 2.parameter f :  the conditionally applied filter
---
---    - returns : the conditional filter
---
--- see also : 'iff', 'when', 'guardsM'
-
-guards		:: (a -> [b]) -> (a -> [b]) -> (a -> [b])
-g `guards` f	= iff g f none
-
-
--- |
--- negation lifted to filters
---
---    * 1.parameter f :  the predicate filter
---
---    - returns : the filter, that succeeds, when f failed
-
-neg		:: (a -> [c]) -> a -> [a]
-neg f		= iff f none this
-
--- |
--- auxiliary datatype for cases within choice filter
-
-data IfThen a b = a :-> b
-
--- |
--- multiway branch. The list of cases @f :-> g@ is processed sequentially,
--- in the first case for that f holds g is applied, if no case matches, 'none' is
--- applied.
--- This filter can be used like a case expression: @choice [ p1 :-> f1, p2 :-> f2, ... , this :-> defaultFilter]@
---
--- see also : 'iff', 'choiceM'
-
-choice	:: [IfThen (a -> [c]) (a -> [b])] -> (a -> [b])
-choice []
-    = none
-
-choice ((g :-> f) : cs)
-    = iff g f (choice cs)
-
--- |
--- pruning: keep only those results from f for which g holds, usually written in infix notation as f `containing` g
---
---    * 1.parameter f :  the processing filter
---
---    - 2.parameter g :  the predicate filter
---
---    - 3.parameter t :  the tree
---
---    - returns : all trees r from f t, for which g r holds (is not the empty list)
---
--- see also : 'notContaining'
-
-containing		:: (a -> [b]) -> (b -> [c]) -> a -> [b]
-f `containing` g
-    = filter (satisfies g) . f
-
--- |
--- pruning: keep only those results from f for which g does not hold
---
--- see also : 'containing'
-
-notContaining		:: (a -> [b]) -> (b -> [c]) -> a -> [b]
-f `notContaining` g
-    = filter (null . g) . f
-
--- |
--- pruning: monadic version of containing, usually written in infix notation as f `containingM` g
---
---    * 1.parameter f :  the monadic processing filter
---
---    - 2.parameter g :  the predicate filter
---
---    - 3.parameter t :  the tree
---
---    - returns : all trees r from f t, for which g r holds (is not the empty list)
---
--- see also : 'notContaining'
-
-containingM		:: Monad m => (a -> m [b]) -> (b -> [c]) -> a -> m [b]
-f `containingM` g
-    = \ t -> do
-             res <- f t
-             return $ filter (satisfies g) res
-
--- |
--- pronounced \"slash\", meaning g inside f
-
-(/>)		:: TFilter node -> TFilter node -> TFilter node
-f /> g
-    = g `o` getChildren `o` f
-
--- |
--- pronounced \"outside\" meaning f containing g
-
-(</)		:: TFilter node -> TFilter node -> TFilter node
-f </ g
-    = f `containing` (g `o` getChildren)
-
--- ------------------------------------------------------------
---
--- recursive search filters
-
--- |
--- top down search.
---
--- search terminates, when filter f succeeds
--- can e.g. be used for finding all outermost tag node of a specific kind
-
-deep		:: TFilter node -> TFilter node
-deep f
-    = f `orElse` (deep f `o` getChildren)
-
--- |
--- bottom up search.
---
--- first the children are processed,
--- if this does not succeed, the node itself is processed
--- can e.g. be used for finding all innermost tag nodes of a specific kind
-
-deepest		:: TFilter node -> TFilter node
-deepest f
-    = (getChildren .> deepest f) `orElse` f
-
--- |
--- process all nodes of the whole tree.
---
--- can e.g. be used for finding all nodes of a specific kind
-
-multi		:: TFilter node -> TFilter node
-multi f
-    = f +++ (getChildren .> multi f)
-
--- ------------------------------------------------------------
---
--- recursive transformation filters
---
-
--- |
--- bottom up transformation
---
---    * 1.parameter f :  the /simple/ transforming filter
---
---    - returns : the filter that applies f to all subtrees and the tree itself in a deepth first left to right manner
---
--- see also : 'processTopDown', 'processBottomUpIfNot'
-
-processBottomUp	:: TFilter node -> TFilter node
-processBottomUp f
-    = processChildren (processBottomUp f) .> f
-
--- |
--- top down transformation
---
---    * 1.parameter f :  the /simple/ transforming filter
---
---    - returns : the filter that applies f first to the tree and then recursively to all subtrees of the result
---
--- see also : 'processBottomUp'
-
-processTopDown	:: TFilter node -> TFilter node
-processTopDown f
-    = f .> processChildren (processTopDown f)
-
--- |
--- guarded bottom up transformation, stops at subtrees for which a predicate p holds
---
---    * 1.parameter f :  the transforming filter
---
---    - 2.parameter p :  the predicate filter for the guard
---
---    - returns : the filter for processing all (sub-)trees
---
--- see also : 'processBottomUp'
-
-processBottomUpIfNot	:: TFilter node -> TFilter node -> TFilter node
-processBottomUpIfNot f p
-    = (processChildren (processBottomUpIfNot f p) .> f) `whenNot` p
-
--- |
--- top down transformation until a node to be transformed is found
---
---    * 1.parameter f :  the /simple/ transforming filter
---
---    - returns : the filter that applies f first to the tree and, if the filter does not succeed,
---		  recursively to all children of the input tree.
---
--- Example:
---
--- @processTopDownUntil none@
---
--- is the identity filter (maybe a bit more inefficient).
---
--- Example:
---
--- @processTopDownUntil (add1Attr \"border\" \"2\" \`containing\` isTag \"table\")@
---
--- is a filter for adding an attribute border=\"2\" in all top level table tags.
---		  The content of table tags will remain unchanged.
---
--- see also : 'processTopDown', 'processBottomUp'
-
-processTopDownUntil	:: TFilter node -> TFilter node
-processTopDownUntil f t
-    | null res
-	= processChildren (processTopDownUntil f) t
-    | otherwise
-	= res
-    where
-    res = f t
-
--- ------------------------------------------------------------
---
-
--- |
--- insertion of trees into the list of children at a given position
---
--- useful for inserting something into the list of children at a given position
--- the list of children is split with the @splitAt@ function
--- the nodes are inserted between these two sublists.
---
--- examples: @insertChildrenAt 0 ins t@ inserts all elements computed with @ins t@ in front
--- of the childen of @t@, @insertChildrenAt 1 ins t@ behind the first child
---
--- see also: 'insertChildrenAfter'
-
-
-insertChildrenAt	:: Int -> TFilter node -> TFilter node
-insertChildrenAt i ins t
-    = replaceChildren (cl1 ++ ins t ++ cl2) t
-    where
-    (cl1, cl2) = splitAt i $ getChildren t
-
--- |
--- insertion of trees into the list of children after specific elements
---
--- useful for inserting something into the list of children of a node
--- the list of children is split with the @span@ function and the filter p as predicate
--- the nodes are inserted between these two sublists
---
--- examples: @insertChildrenAfter none ins t@ inserts all elements computed with @ins t@ in front
--- of the childen of @t@, @insertChildrenAfter this ins t@ appends the elements to the children
---
--- see also: 'insertChildrenAt'
-
-insertChildrenAfter	:: TFilter node -> TFilter node -> TFilter node
-insertChildrenAfter p ins t
-    = replaceChildren (cl1 ++ ins t ++ cl2) t
-    where
-    (cl1, cl2) = span (not . null . p) $ getChildren t
-
--- ------------------------------------------------------------
---
--- monadic filter
-
--- |
--- the monadic version of the identity filter this.
---
--- see also : 'this'
-
-thisM		:: Monad m => (a -> m [a])
-thisM		= liftMf this
-
--- |
--- the monadic version of the null filter none.
---
--- see also : 'none'
-
-noneM		:: Monad m => (a -> m [b])
-noneM		= liftMf none
-
--- |
--- sequential composition of monadic filters, monadic version of \".>\".
---
---    * 1.parameter f1 :  the 1. monadic filter
---
---    - 2.parameter f2 :  the 2. monadic filter
---
---    - returns : the monadic fiter applying first f1 to n and then f2 to the result (like function composition)
---
--- see also : '(.>)'
-
-(.>>)	:: Monad m => (a -> m[b]) -> (b -> m [c]) -> (a -> m[c])
-cmd1 .>> cmd2
-    = \ t ->
-      do
-      r1 <- cmd1 t
-      r2 <- mapM cmd2 r1
-      return (concat r2)
-
--- |
--- generalized sequential composition of monadic filters
-
-seqM	:: Monad m => [a -> m[a]] -> (a -> m[a])
-seqM
-    = foldr (.>>) thisM
-
--- |
--- binary parallel composition, the logical OR for predicate filter
---
---    * 1.parameter f1 :  the 1. filter
---
---    - 2.parameter f2 :  the 2. filter
---
---    - returns : the filter for applying f1 and f2 both to an argument tree and concatenating the results
--- see also: 'cat', '+++', 'catM'
-
-(+++>>)		:: Monad m => (a -> m [b]) -> (a -> m [b]) -> (a -> m [b])
-f +++>> g	= \ t -> do
-			 r1 <- f t
-			 r2 <- g t
-			 return (r1 ++ r2)
-
--- |
--- apply a list of monadic filters
---
---    * 1.parameter fs :  the list of filters
---
---    - returns : the composing filter
--- see also: 'cat', '+++', '+++>>'
-
-catM	:: Monad m => [a -> m [b]] -> (a -> m [b])
-catM fs  t
-    = do
-      res <- sequence (map ($ t) fs)
-      return $ concat res
-
--- |
--- monadic if-then-else.
---
---    * 1.parameter p :  the predicate
---
---    - 2.parameter thenP :  the then part: the monadic filter, that is applied if p holds for the input tree
---
---    - 3.parameter elseP :  the else part
---
---    - returns : the monadic filter for the conditional
-
-ifM		:: Monad m => (a -> [b]) -> (a -> m [c]) -> (a -> m [c]) -> (a -> m [c])
-ifM p thenPart elsePart
-    = \ t ->
-      if (satisfies p) t
-      then thenPart t
-      else elsePart t
-
--- |
--- monadic version of multiway branch. The list of cases @f :-> g@ is processed sequentially,
--- in the first case for that f holds g is applied, if no case matches, 'noneM' is
--- applied.
--- This filter can be used like a case expression: @choiceM [ p1 :-> f1, p2 :-> f2, ... , thisM :-> defaultFilter]@
---
--- see also : 'choice', 'ifM'
-
-choiceM		:: Monad m => [IfThen (a -> [c]) (a -> m [b])] -> (a -> m [b])
-choiceM []
-    = noneM
-
-choiceM ((g :-> f) : cs)
-    = ifM g f (choiceM cs)
-
-
--- |
--- when the predicate p holds, the monadic filter f is applied, else the identity filter.
---
---    * 1.parameter f :  the conditinally applied monadic filter
---
---    - 2.parameter p :  the simple predicate
---
---    - returns : the conditional filter
---
--- see also : 'ifM', 'when', 'guardsM', 'whenNotM'
-
-whenM		:: Monad m => (a -> m [a]) -> (a -> [b]) -> (a -> m [a])
-f `whenM` g	= ifM g f thisM
-
--- |
--- the complementary filter of whenM.
---
--- see also : 'ifM', 'whenM', 'whenNot'
-
-whenNotM	:: Monad m => (a -> m [a]) -> (a -> [b]) -> (a -> m [a])
-f `whenNotM` g	= ifM g thisM f
-
--- |
--- when the predicate p holds, the monadic filter f is applied, else the null filter.
---
---    * 1.parameter p :  the simple predicate filter
---
---    - 2.parameter f :  the conditionally applied monadic filter
---
---    - returns : the conditional filter
---
--- see also : 'ifM', 'guards', 'whenM'
-
-guardsM		:: Monad m => (a -> [b]) -> (a -> m [c]) -> (a -> m [c])
-g `guardsM` f	= ifM g f noneM
-
--- |
--- Filter for editing the children of a tree with a monadic filter
---
---    * 1.parameter cf :  the monadic filter applied to the children
---
---    - returns : the monadic editing filter
---
--- see also : 'processChildren'
-
-processChildrenM	:: Monad m => (NTree node -> m [NTree node]) -> (NTree node -> m [NTree node])
-processChildrenM ft (NTree n cs)
-    = do
-      res <- ft $$< cs
-      return [NTree n res]
-
--- |
--- monadic variant of 'processTopDown'
-
-processTopDownM		:: Monad m => (NTree node -> m [NTree node]) -> (NTree node -> m [NTree node])
-processTopDownM f
-    = f .>> processChildrenM (processTopDownM f)
-
--- |
--- monadic variant of 'processBottomUp'
-
-processBottomUpM	:: Monad m => (NTree node -> m [NTree node]) -> (NTree node -> m [NTree node])
-processBottomUpM f
-    = processChildrenM (processBottomUpM f) .>> f
-
--- |
--- infix operator for applying a monadic filter to a list of trees,
--- typically used in do-notation for processing of intermediate results.
---
---    * 1.parameter f :  the monadic filter
---
---    - 2.parameter ts :  the list of trees
---
---    - returns : the concatenated list of results
---
--- see also : '($$)'
-
-($$<)	:: Monad m => (a -> m [b]) -> [a] -> m [b]
-cmd $$< l
-    = do
-      r <- mapM cmd l
-      return (concat r)
-
--- |
--- lift a filter to a monadic filter
---
---    * 1.parameter f :  the /simple/ filter
---
---    - returns : the lifted monadic version
-
-liftMf	:: Monad m => (a -> [b]) -> a -> m [b]
-liftMf f t
-    = return (f t)
-
--- |
--- run an arbitray command on a tree t and return the tree,
--- used for inserting arbitray commands in a filter pipeline
---
---    * 1.parameter cmd :  the command
---
---    - 2.parameter t :  the argument tree
---
---    - returns : the unchanged tree as a single element list
-
-performAction	:: Monad m => (a -> m b) -> a -> m [a]
-performAction cmd t
-    = do
-      cmd t
-      return [t]
-
--- eof ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/System-PipeOpen.html b/doc/hxt-filter/src/System-PipeOpen.html deleted file mode 100644 --- a/doc/hxt-filter/src/System-PipeOpen.html +++ /dev/null @@ -1,70 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
-
-{- |
-   Module     : System.PipeOpen
-   Copyright  : Copyright (C) 2005 Uwe Schmidt
-   License    : MIT
-
-   Maintainer : Uwe Schmidt (uwe\@fh-wedel.de)
-   Stability  : experimental
-   Portability: none portable
-   Version    : $Id: PipeOpen.hs,v 1.2 2005/09/02 17:09:39 hxml Exp $
-
-pipe open implemented with System.Process functions
-
--}
-
--- ------------------------------------------------------------
-
-module System.PipeOpen
-    ( popen )
-where
-
-import IO
-    ( hGetContents
-    , hClose
-    )
-
-import System.Exit
-    ( ExitCode(..)
-    )
-
-import System.Process
-    ( runInteractiveProcess
-    , waitForProcess
-    )
-
--- | call an external program with a list of command line arguments
--- and return content of stdout, content of stderr and return code
-
-popen	:: String -> [String] -> IO (String, String, Int)
-popen prg argl
-    = do
-      (inpH, outH, errH, pH) <- runInteractiveProcess prg argl Nothing Nothing
-      hClose inpH
-      res  <- hGetContents outH
-      errs <- hGetContents errH
-
-      -- hack: stdout and stderr must be read completely, otherwise waitForProcess blocks
-      if (length res  == 0) then return () else return ()
-      if (length errs == 0) then return () else return ()
-
-      rc <- waitForProcess pH
-      return ( res
-	     , errs
-	     , case rc of
-	       ExitSuccess -> 0
-	       ExitFailure i -> i
-	     )
-
--- eof ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-DOM-EditFilters.html b/doc/hxt-filter/src/Text-XML-HXT-DOM-EditFilters.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-DOM-EditFilters.html +++ /dev/null @@ -1,577 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- XML editing filters
-
-module Text.XML.HXT.DOM.EditFilters
-    ( canonicalizeTree
-    , canonicalizeAllNodes
-    , canonicalizeForXPath
-
-    , collapseXText
-    , collapseAllXText
-
-    , indentDoc
-
-    , removeWhiteSpace
-    , removeAllWhiteSpace
-    , removeDocWhiteSpace
-
-    , removeComment
-    , removeAllComment
-
-    , transfCdata		, transfAllCdata	-- CDATA to text
-    , transfCdataEscaped	, transfAllCdataEscaped	-- CDATA to text
-    , transfCharRef		, transfAllCharRef	-- &#nnn; to text
-
-    , escapeXmlDoc
-    , escapeXmlText
-    , escapeXmlAttrValue
-
-    , unparseXmlDoc
-    , numberLinesInXmlDoc	, numberLines
-    , treeRepOfXmlDoc
-    , haskellRepOfXmlDoc
-    , addHeadlineToXmlDoc
-    , addXmlPiToDoc
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.DOM.Unicode
-    ( getOutputEncodingFct)
-
-import Text.XML.HXT.DOM.FormatXmlTree
-    ( formatXmlContents )
-
-import Data.Maybe
-
--- ------------------------------------------------------------
-
--- |
--- remove Comments
-
-removeComment		:: XmlFilter
-removeComment		= none `when` isXCmt
-
--- |
--- remove all Comments recursively
-
-removeAllComment	:: XmlFilter
-removeAllComment	= processBottomUp removeComment
-
--- ------------------------------------------------------------
-
--- |
--- simple filter for removing whitespace.
---
--- no check on sigificant whitespace is done.
---
---
--- see also : 'removeAllWhiteSpace', 'removeDocWhiteSpace'
-
-removeWhiteSpace	:: XmlFilter
-removeWhiteSpace	= none `when` isWhiteSpace
-
--- |
--- simple recursive filter for removing all whitespace.
---
--- removes all text nodes in a tree that consist only of whitespace.
---
---
--- see also : 'removeWhiteSpace', 'removeDocWhiteSpace'
-
-removeAllWhiteSpace	:: XmlFilter
-removeAllWhiteSpace	= processBottomUp removeWhiteSpace
-
--- ------------------------------------------------------------
--- |
--- converts CDATA sections in whole document tree into normal text nodes
-
-transfAllCdataEscaped	:: XmlFilter
-transfAllCdataEscaped	= processBottomUp transfCdataEscaped
-
--- |
--- converts CDATA section in normal text nodes
-
-transfCdataEscaped	:: XmlFilter
-transfCdataEscaped (NTree (XCdata str) _)
-    = xtext str
-
-transfCdataEscaped n
-    = [n]
-
-
--- ------------------------------------------------------------
--- |
--- converts CDATA sections in whole document tree
-
-transfAllCdata		:: XmlFilter
-transfAllCdata		= processBottomUp transfCdata
-
--- |
--- converts CDATA section in normal text sections
-
-transfCdata		:: XmlFilter
-transfCdata (NTree (XCdata str) _)
-    = xtext str
-
-transfCdata n
-    = [n]
-
-
--- ------------------------------------------------------------
--- |
--- converts character references to normal text
-
-transfCharRef		:: XmlFilter
-transfCharRef (NTree (XCharRef i) _)
-    = xtext $ [toEnum i]
-
-transfCharRef n
-    = [n]
-
--- ------------------------------------------------------------
--- |
--- recursively converts all character references to normal text
-
-transfAllCharRef	:: XmlFilter
-transfAllCharRef	= processBottomUp transfCharRef
-
--- ------------------------------------------------------------
-
--- |
--- Applies some "Canonical XML" rules to the nodes of a tree.
---
--- The rule differ slightly for canonical XML and XPath in handling of comments
---
--- Note: This is not the whole canonicalization as it is specified by the W3C
--- Recommendation. Adding attribute defaults or sorting attributes in lexicographic
--- order is done by the @transform@ function of module @Text.XML.HXT.Validator.Validation@.
--- Replacing entities or line feed normalization is done by the parser.
---
---
--- Not implemented yet:
---
---  - Whitespace within start and end tags is normalized
---
---  - Special characters in attribute values and character content are replaced by character references
---
--- see 'canonicalizeAllNodes' and 'canonicalizeForXPath'
-
-canonicalizeTree	:: XmlFilter -> XmlFilter
-canonicalizeTree toBeRemoved
-    = processChildren (none `when` isXText)
-      .>
-      processBottomUp canonicalize1Node
-      where
-      canonicalize1Node	:: XmlFilter
-      canonicalize1Node
-	  = (deep isXPi `when` isXDTD)		-- remove DTD parts, except PIs
-	    .>
-	    (none `when` toBeRemoved)		-- remove unintersting nodes
-	    .>
-	    ( processAttr ( processChildren transfCharRef
-			    .>
-			    collapseXText
-			  ) `when` isXTag)
-	    .>
-	    transfCdata				-- CDATA -> text
-	    .>
-	    transfCharRef			-- Char refs -> text
-	    .>
-	    collapseXText			-- combine text
-
-
--- |
--- canonicalize tree and remove comments and \<?xml ... ?> declarations
---
--- see 'canonicalizeTree'
-
-canonicalizeAllNodes	:: XmlFilter
-canonicalizeAllNodes
-    = canonicalizeTree (isXCmt		-- remove comment
-			+++
-			isPi t_xml	-- remove xml declaration
-		       )
-
--- |
--- Canonicalize a tree for XPath
--- Comment nodes are not removed
---
--- see 'canonicalizeTree'
-
-canonicalizeForXPath	:: XmlFilter
-canonicalizeForXPath
-    = canonicalizeTree (isPi t_xml)
-
--- ------------------------------------------------------------
-
--- |
--- Collects sequences of child XText nodes into one XText node.
-
-collapseXText		:: XmlFilter
-collapseXText n
-    = replaceChildren (collapseXText' $ getChildren n) n
-    where
-    collapseXText' :: XmlSFilter
-    collapseXText' ((NTree n1 _) : (NTree n2 _) : zs)
-	| isXTextNode n1 && isXTextNode n2
-            = collapseXText' $ (xtext (t1 ++ t2)) ++ zs
-	      where
-	      t1 = textOfXNode n1
-	      t2 = textOfXNode n2
-
-    collapseXText' (x:xs)
-        = x : (collapseXText' xs)
-
-    collapseXText' []
-        = []
-
-
--- |
--- Applies collapseXText recursively.
---
---
--- see also : 'collapseXText'
-
-collapseAllXText	:: XmlFilter
-collapseAllXText	= processBottomUp collapseXText
-
-
--- ------------------------------------------------------------
---
-
--- |
--- filter for indenting a document tree for pretty printing.
---
--- the tree is traversed for inserting whitespace for tag indentation.
---
--- whitespace is only inserted or changed at places, where it isn't significant,
--- is's not inserted between tags and text containing non whitespace chars.
---
--- whitespace is only inserted or changed at places, where it's not significant.
--- preserving whitespace may be controlled in a document tree
--- by a tag attribute @xml:space@
---
--- allowed values for this attribute are @default | preserve@.
---
--- input is a complete document tree.
--- result the semantically equivalent formatted tree.
---
---
--- see also : 'removeDocWhiteSpace'
-
-indentDoc	:: XmlFilter
-indentDoc 
-    = modifyChildren (indentRootChildren $$)
-      `when`
-      isRoot
-      where
-      indentRootChildren	:: XmlFilter
-      indentRootChildren
-	  = insertNL `o` indentChild `o` removeText
-	    where
-	    removeText
-		= none `when` isXText
-	    insertNL
-		= this +++ txt "\n"
-	    indentChild
-		= modifyChildren (indentTrees (insertIndentation 2) False 1)
-		  `whenNot`
-		  isXDTD		-- DTD elements are not indented
-
--- |
--- filter for removing all not significant whitespace.
---
--- the tree traversed for removing whitespace between tags,
--- that was inserted for indentation and readability.
--- whitespace is only removed at places, where it's not significat
--- preserving whitespace may be controlled in a document tree
--- by a tag attribute @xml:space@
---
--- allowed values for this attribute are @default | preserve@
---
--- input is root node of the document to be cleaned up
--- output the semantically equivalent simplified tree
---
---
--- see also : 'indentDoc', 'removeAllWhiteSpace'
-
-removeDocWhiteSpace	:: XmlFilter
-removeDocWhiteSpace
-    =  processChildren processRootElement
-      `when`
-      isRoot
-      where
-      processRootElement	:: XmlFilter
-      processRootElement
-	  = removeText .> processChild
-	    where
-	    removeText
-		= none `when` isWhiteSpace
-	    processChild
-		= choice [ isXDTD
-			   :-> removeAllWhiteSpace			-- whitespace in DTD is redundant
-			 , this
-			   :-> modifyChildren				-- same strategie as for indentation
-			         (indentTrees insertNothing False 1)
-			 ]
-
-indentTrees	:: (Int -> XmlFilter) -> Bool -> Int -> XmlTrees -> XmlTrees
-indentTrees _ _ _ []
-    = []
-indentTrees indentFilter preserveSpace level ts
-    = (lsf $$ ls) ++ indentRest rs
-      where
-      (ls, rs)
-	  = break (satisfies isXTag) ts
-
-      isSignificant	:: Bool
-      isSignificant
-	  = preserveSpace
-	    ||
-	    any (satisfies isSignificantPart) ls
-
-      isSignificantPart	:: XmlFilter
-      isSignificantPart
-	  = cat [ isXText `guards` neg isWhiteSpace
-		, isXCdata
-		, isXCharRef
-		, isXEntityRef
-		]
-
-      lsf	:: XmlFilter
-      lsf
-	  | isSignificant
-	      = this
-	  | otherwise
-	      = (none `when` isWhiteSpace)
-                .>
-                (indentFilter level +++ this)
-
-      indentRest	:: XmlSFilter
-
-      indentRest []
-	  | isSignificant
-	      = []
-	  | otherwise
-	      = indentFilter (level - 1) (mkXTextTree "")
-
-      indentRest (t':ts')
-	      = ( (modifyChildren indentChildren .> lsf)
-		  `when`
-                  isXTag
-		  $ t'
-		)
-                ++
-		( if null ts'
-		  then indentRest ts'
-		  else indentTrees indentFilter preserveSpace level ts'
-		)
-		where
-		xmlSpaceAttrName  = "xml:space"
-		xmlSpaceAttrValue = valueOf xmlSpaceAttrName t'
-		preserveSpace'
-		    = fromMaybe preserveSpace
-		      .
-		      lookup xmlSpaceAttrValue
-                      $ [ ("preserve", True)
-			, ("default",  False)
-			]
-		indentChildren
-		    | all (satisfies isWhiteSpace) $ getChildren t'
-			= (none $$)
-		    | otherwise
-			= indentTrees indentFilter preserveSpace' (level + 1)
-
--- filter for indenting tags
-
-insertIndentation	:: Int -> Int -> XmlFilter
-insertIndentation indentWidth level
-    = txt ('\n' : replicate (level * indentWidth) ' ')
-
--- filter for removing all whitespace
-
-insertNothing		:: Int -> XmlFilter
-insertNothing _		= none
-
--- ------------------------------------------------------------
-
--- |
--- escape XmlText,
--- transform all special XML chars into CharRefs
-
-escapeString	:: (Char -> Bool) -> String -> XmlTrees
-escapeString _isEsc []
-    = []
-escapeString isEsc (c:s1)
-    | isEsc c
-	= mkXCharRefTree (fromEnum c) : escapeString isEsc s1
-escapeString isEsc s
-    = mkXTextTree s1 : escapeString isEsc s2
-      where
-      (s1, s2) = break isEsc s
-
-escapeText		:: (Char -> Bool) -> XmlFilter
-escapeText isEsc (NTree n _)
-    | isXTextNode n
-	= escapeString isEsc (textOfXNode n)
-
-escapeText isEsc (NTree (XCmt c) _)
-    = xcmt (xshow . escapeString isEsc $ c)
-
-escapeText _ t
-    = [t]
-
--- |
--- convert the special XML chars in a text or comment node
--- into character references
---
--- see also 'escapeXmlDoc'
- 
-escapeXmlText		:: XmlFilter
-escapeXmlText		= escapeText (`elem` "<&")	-- no escape for ", ' and > required: XML standard 2.4
-
--- |
--- convert the special XML chars in an attribute value into
--- charachter references. Not only the XML specials but also \\n, \\r and \\t are converted
---
--- see also: 'escapeXmlDoc', 'escapeXmlText'
-
-escapeXmlAttrValue	:: XmlFilter
-escapeXmlAttrValue	= escapeText (`elem` "<>\"\'&\n\r\t")
-
--- |
--- convert the special XML chars \", \<, \>, & and \' in a document to char references,
--- attribute values are converted with 'escapeXmlAttrValue'
---
--- see also: 'escapeXmlText', 'escapeXmlAttrValue'
-
-escapeXmlDoc		:: XmlFilter
-escapeXmlDoc
-    = choice [ isXTag  :-> (processChildren (escapeXmlDoc)
-			    .>
-			    processAttr escVal
-			   )
-	     , isXText :-> escapeXmlText
-	     -- , isXCmt  :-> escapeXmlText -- no escape in comments reqired: XML standard 2.4
-	     , isXDTD  :-> processTopDown escDTD
-	     , this    :-> this
-	     ]
-      where
-      escVal   = processChildren escapeXmlAttrValue
-      escDTD   = escVal `when` (isEntity +++ isParameterEntity)
-
--- ------------------------------------------------------------
-
--- |
--- convert a document tree into an output string representation
--- with respect to the output encoding.
---
--- The children of the document root are stubstituted by
--- a single text node for the text representation of the document.
---
--- Encoding of the document is performed with respect
--- to the @output-encoding@ attribute in the root node, or if not present,
--- of the @encoding@ attribute for the original input encoding.
--- If the encoding is not specified or not supported, UTF-8 is taken.
-
-unparseXmlDoc	:: XmlFilter
-unparseXmlDoc n
-    = modifyChildren ((modifyText encFct $$) . xmlTreesToText) n
-    where
-    encFct = fromMaybe id (getOutputEncodingFct (encSpec n))
-
-encSpec :: XmlTree -> String
-encSpec n
-    = head . filter (not . null)
-      $ [ valueOf a_output_encoding n
-	, valueOf a_encoding n
-	, utf8
-	]
-
--- ------------------------------------------------------------
---
--- add or modify a XML directive for a document
--- for specifying the encoding scheme
-
-addXmlPiToDoc		:: XmlFilter
-addXmlPiToDoc n
-    = ( modifyChildren addX				-- add <?xml ...>, if neccessary
-	`whenNot`
-	(getChildren .> isPi t_xml)
-      )
-      .>
-      processChildren ( addAttr a_encoding enc		-- set or replace encoding="..."
-			`when`
-			isPi t_xml
-		      )
-      $ n
-    where
-    enc = encSpec n
-    addX cs = mkXmlDeclTree (xattr a_version "1.0") : xtext "\n" ++ cs
-
--- ------------------------------------------------------------
-
--- |
--- convert a document into a text and add line numbers to the text representation.
--- 
--- Result is a root node with a single text node as child.
--- Useful for debugging and trace output.
--- see also : 'haskellRepOfXmlDoc', 'treeRepOfXmlDoc'
-
-numberLinesInXmlDoc	:: XmlFilter
-numberLinesInXmlDoc
-    = modifyChildren ((modifyText numberLines $$) . xmlTreesToText)
-
-numberLines	:: String -> String
-numberLines str
-    = concat $
-      zipWith (\ n l -> lineNr n ++ l ++ "\n") [1..] (lines str)
-      where
-      lineNr	:: Int -> String
-      lineNr n	= (reverse (take 6(reverse (show n) ++ replicate 6 ' '))) ++ "  "
-
--- ------------------------------------------------------------
-
--- |
--- convert a document into a text representation in tree form.
---
--- Useful for debugging and trace output.
--- see also : 'haskellRepOfXmlDoc', 'numberLinesInXmlDoc'
-
-treeRepOfXmlDoc		:: XmlFilter
-treeRepOfXmlDoc
-    = rootTag [getAttrl] [formatXmlContents]
-
--- |
--- convert a document into a Haskell representation (with show).
---
--- Useful for debugging and trace output.
--- see also : 'treeRepOfXmlDoc', 'numberLinesInXmlDoc'
-
-haskellRepOfXmlDoc	:: XmlFilter
-haskellRepOfXmlDoc n
-    = rootTag [getAttrl] [txt $ show n] n
-
--- ------------------------------------------------------------
-
-addHeadlineToXmlDoc	:: XmlFilter
-addHeadlineToXmlDoc n
-    = replaceChildren (xtext title ++ getChildren n ++ xtext "\n") n
-      where
-      headline  = "content of: " ++ valueOf a_source n
-      underline = map (\_ -> '=') headline
-      title     = "\n" ++ headline ++ "\n" ++ underline ++ "\n\n"
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-DOM-Namespace.html b/doc/hxt-filter/src/Text-XML-HXT-DOM-Namespace.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-DOM-Namespace.html +++ /dev/null @@ -1,62 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- main namespace filter for propagation, checking, tracing and error handling
-
-module Text.XML.HXT.DOM.Namespace
-    ( module Text.XML.HXT.DOM.Namespace
-    , module Text.XML.HXT.DOM.NamespaceFilter
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-import Text.XML.HXT.DOM.XmlState
-import Text.XML.HXT.DOM.NamespaceFilter
-
-import Text.XML.HXT.Parser.XmlOutput
-    ( traceTree
-    , traceSource
-    , traceMsg
-    )
-
--- -----------------------------------------------------------------------------
-
--- |
--- propagate all namespace declarations, check namespace constraints and issue errors.
--- If no error was found, result is the unchanged input tree, else the root node \"\/\" with an empty document is returned.
---
--- see also : 'propagateNamespaces', 'validateNamespaces'
-
-propagateAndValidateNamespaces	:: XmlStateFilter a
-propagateAndValidateNamespaces
-    = traceMsg 2 "propagating namespaces"
-      .>>
-      liftMf propagateNamespaces
-      .>>
-      traceTree
-      .>>
-      traceSource
-      .>>
-      traceMsg 2 "validating namespaces"
-      .>>
-      validate
-    where
-    validate	:: XmlStateFilter a
-    validate t
-	= let
-	  errs = validateNamespaces t
-	  in if null errs
-	     then thisM t
-	     else do
-		  liftF this $$< errs
-		  return (setStatus c_err "namespace propagation" t)
-	  
--- -----------------------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-DOM-NamespaceFilter.html b/doc/hxt-filter/src/Text-XML-HXT-DOM-NamespaceFilter.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-DOM-NamespaceFilter.html +++ /dev/null @@ -1,231 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- Namespace filter
---
--- Namespaces are processed with two main filter, 'propagateNamespaces'
--- and 'validateNamespaces'.
---
--- 'propagateNamespaces' takes a XML tree and
--- attaches extra namespace info at every tag name and attribute name.
--- So after processing a tree with 'propagateNamespaces', the access functions
--- "namespaceOf" and "universalNameOf" deliver the associated namespace (or \"\")
--- for tag names and attribute names.
---
--- 'validateNamespaces' checks whether names are wellformed related to the XML namespace definition.
--- whether a legal namespace is declared for all prefixes, and whether attribute names are unique
--- related to universal names.
-
-module Text.XML.HXT.DOM.NamespaceFilter
-    ( module Text.XML.HXT.DOM.NamespaceFilter
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.DOM.Util
-    ( doubles )
-
--- -----------------------------------------------------------------------------
---
-
--- |
--- Type for the namespace association list, used when propagating namespaces by
--- modifying the 'QName' values in a tree
-
-type NamespaceTable = NsEnv
-
--- -----------------------------------------------------------------------------
-
--- |
--- propagate all namespace declarations \"xmlns:ns=...\" to all
--- tag and attribute nodes of a document.
---
--- This filter does not check for illegal use of namespaces.
--- The real work is done by 'propagateNamespaceEnv'.
---
--- The filter may be applied repeatedly if neccessary.
-
-propagateNamespaces	:: XmlFilter
-propagateNamespaces	= propagateNamespaceEnv $ toNsEnv [ (a_xml, xmlNamespace), (a_xmlns, xmlnsNamespace) ]
-
--- |
--- attaches the namespace info given by the namespace table
--- to a tag node and its attributes and children.
-
-propagateNamespaceEnv	:: NamespaceTable -> XmlFilter
-propagateNamespaceEnv env n
-    = ( ( processAttr (attachNamespaceUrisToAttr newEnv)
-	  .>
-	  processChildren (propagateNamespaceEnv newEnv)
-	  .>
-	  modifyQName (setNamespace newEnv)
-	)
-	`when`
-	isXTag
-      )
-      $ n
-    where
-    nsAttrs	= getAttrl				-- scan all attributes
-		  .>
-		  isOfAttr ( (\ (px, lp)
-			     -> (px == a_xmlns		-- check for prefix or whole name is "xmlns"
-				 &&
-				 lp /= ":"		-- check for none empty local part, "xmlns:" is not a legal name
-				)
-			     )
-			     . span (/= ':')		-- break the name into a pair ("prefix", ":localPart")
-			     . qualifiedName		-- select attribute name
-			   )
-		  $ n
-    nsDecl	= zip (map (drop 1			-- drop the ":", empty local part represents default name space
-			    . snd			-- take the local part with leading ":"
-			    . span (/= ':')		-- break it like above
-			    . nameOf			-- select attribute name
-			   ) nsAttrs)
-		      (map (xshow
-			    .
-			    getChildren
-			   ) nsAttrs)
-    newEnv	= addEntries (toNsEnv nsDecl) env
-
-    attachNamespaceUrisToAttr	:: NamespaceTable -> XmlFilter
-    attachNamespaceUrisToAttr attrEnv
-	= ( isOfAttr ( (\ (px, lp)
-			-> ( (not . null . drop 1) lp	-- prefix and local part must not be empty
-			     &&
-			     (not . null) px
-			   )
-		       )
-		       . span (/= ':')			-- break the name into a pair ("prefix", ":localPart")
-		       . qualifiedName			-- select attribute name
-		     )
-	    `guards`
-	    modifyQName (setNamespace attrEnv)
-	  )
-          `orElse`
-	  ( modifyQName (const xmlnsQN)			-- "xmlns" ist the only attr name without prefix but with an associated namespace URI
-	    `when`
-	    isAttr a_xmlns
-	  )
-
--- -----------------------------------------------------------------------------
-
--- |
--- validate the namespace constraints in a whole tree.
--- result is the list of errors concerning namespaces.
--- Work is done by applying 'validate1Namespaces' to all nodes.
--- Predicates 'isWellformedQName', 'isWellformedQualifiedName', 'isDeclaredNamespace'
--- and 'isWellformedNSDecl' are applied to the appropriate tags and attributes.
-
-validateNamespaces	:: XmlFilter
-validateNamespaces
-    = choice [ isRoot
-               :-> getChildren .> validateNamespaces		-- root is correct by definition
-	     , this
-	       :-> multi validate1Namespaces
-	     ]
-
--- |
--- a single node for namespace constrains.
-
-validate1Namespaces	:: XmlFilter
-validate1Namespaces
-    = choice [ isXTag
-	       :->
-	       cat [ isOfTag ( not . isWellformedQName )
-		     `guards`
-		     (\ n -> err ("tag name " ++ show (nameOf n) ++ " is not a wellformed qualified name") n )
-
-		   , isOfTag ( not . isDeclaredNamespace )
-		     `guards`
-		     (\ n -> err ("namespace for prefix in tag name " ++ show (nameOf n) ++ " is undefined") n )
-
-                   , (\ n -> ( let
-		               dbls = doubles ((map universalNameOf . getAttrl) n)
-		               in
-		               if null dbls
-		               then none
-                               else err ( "multiple occurences of universal names for attributes of tag "
-					  ++ show (nameOf n)
-					  ++ " : " ++ foldr1 (\ x y -> x ++ ", " ++ y) (map show dbls)
-					)
-			     ) $ n
-		     )
-
-		   , getAttrl .> validate1Namespaces
-		   ]
-
-	     , isXAttr
-	       :->
-	       cat [ isOfAttr ( not . isWellformedQName )
-		     `guards`
-		     (\ n -> err ("attribute name " ++ show (nameOf n) ++ " is not a wellformed qualified name") n )
-
-		   , isOfAttr ( not . isDeclaredNamespace )
-	             `guards`
-		     (\ n -> err ("namespace for prefix in attribute name " ++ show (nameOf n) ++ " is undefined") n )
-
-                   , ( hasPrefix a_xmlns .> neg (xmlTreesToText . getChildren) )
-		     `guards`
-		     (\ n -> err ("namespace value of namespace declaration for " ++ show (nameOf n) ++ " has no value") n )
-
-                   , isOfAttr ( not . isWellformedNSDecl )
-		     `guards`
-		     (\ n -> err ("illegal namespace declaration with reserved prefix " ++ show (localPartOf n) ++ " starting with \"xml\"") n )
-	           ]
-
-             , isXDTD
-	       :->
-	       cat [ ( ( isDoctype +++ isAttlist +++ isElement +++ isDTDName )
-		       .>
-		       isOf ( not . isWellformedQualifiedName . valueOfDTD a_name )
-		     )
-		     `guards`
-                     (\ n -> err ("a DTD part contains a not wellformed qualified Name: " ++ show (valueOfDTD a_name n)) n )
-
-		   , ( isAttlist
-		       .>
-		       isOf ( not . isWellformedQualifiedName . valueOfDTD a_value )
-		     )
-		     `guards`
-                     (\ n -> err ("an ATTLIST declaration contains as attribute name a not wellformed qualified Name: " ++ show (valueOfDTD a_value n)) n )
-
-                   , ( ( isEntity +++ isParameterEntity +++ isNotation )
-		       .>
-		       isOf ( not . isNCName . valueOfDTD a_name )
-		     )
-                     `guards`
-                     (\ n -> err ("an entity or notation declaration contains a not wellformed NCName: " ++ show (valueOfDTD a_name n)) n )
-		   ]
-             , isXPi
-	       :->
-	       ( isOf ( not . isNCName . nameOf )
-	         `guards`
-                 (\ n -> err ("a PI contains a not wellformed NCName: " ++ show (nameOf n)) n )
-	       )
-	     ]
-
--- -----------------------------------------------------------------------------
-
-isNamespaceDecl	:: XmlFilter
-isNamespaceDecl
-    = isOfAttr xmlnsName
-      where
-      xmlnsName	:: AttrName -> Bool
-      xmlnsName a
-	  = px == a_xmlns
-	    &&
-	    ( null ln || head ln == ':')
-	  where
-	  (px, ln) = splitAt 5 . qualifiedName $ a
-
--- -----------------------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlState.html b/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlState.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlState.html +++ /dev/null @@ -1,697 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- This module provides a Monad for an internal state and IO commands.
--- The state consists of two parts, the user state and the system state
--- user state ist a type parameter, the system state is a list
--- name-value pair. If the user state is not needed, the type parameter
--- can be instantiated with @()@.
---
--- Furthermore there are types for Xml filter working on this monad
--- and functions for manipulating the state components
--- and for lifting i\/o commands and XmlFilter to monad filters.
---
--- Error reporting functions are also located in this module.
-
-module Text.XML.HXT.DOM.XmlState
-    ( module Text.XML.HXT.DOM.XmlState
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import qualified Control.Monad.MonadStateIO as MonadStateIO
-
-import System.IO
-import Data.Maybe
-
--- ------------------------------------------------------------
-
--- |
--- The internal system state consists of a list of name-value pairs
--- of type @(String, XmlTrees)@, so arbitrary lists of trees can be stored.
--- For options, often only strings are used as values, so a set of access
--- functions with string values is available
--- The error handling method can be controlled by an error handler filter,
--- the default filter issues the errors on stderr
-
-data SysState			= SysState { sysStateAttrs		:: ! SysStateAttrs
-					   , sysStateErrorHandler	:: ! (XmlStateFilter ())
-					   }
-
-type SysStateAttrs		= AssocList String XmlTrees
-
--- |
--- The State has a system and a user part
--- the user state is a type parameter
-
-data XmlState state		= XmlState { sysState	:: ! SysState
-					   , userState	:: ! state
-					   }
-
--- |
--- The monad type for commands. It is an instance of "StateIO" from the
--- general module "Control.Monad.MonadStateIO".
-
-type XState state res		= MonadStateIO.StateIO (XmlState state) res
-
--- |
--- The "XmlFilter" type for filters working on a state
-
-type XmlStateFilter state	= XmlTree -> XState state XmlTrees
-
--- ------------------------------------------------------------
---
--- user defined state
--- access functions
-
--- |
--- change the user state
---
---    * 1.parameter fct :  the user state change function
---
---    - returns : the new state
-
-changeState	:: (state -> state) -> XState state state
-changeState f
-    = do
-      ns <- MonadStateIO.changeState f'
-      return (userState ns)
-      where
-      f' s = s { userState = f (userState s) }
-
--- |
--- set the user state.
---
---    * 1.parameter s :  the new state
---
---    - returns : the new state
-
-setState	:: state -> XState state state
-setState s
-    = changeState ( \_ -> s )
-
--- |
--- read the user state
---
---    - returns : the current state
-
-getState	:: XState state state
-getState
-    = changeState id
-
--- ------------------------------------------------------------
-
--- |
--- change the system part of the state.
---
--- see also : 'changeState'
-
-changeSysState	:: (SysState -> SysState) -> XState state SysState
-changeSysState f
-    = do
-      ns <- MonadStateIO.changeState f'
-      return (sysState ns)
-      where
-      f' s = s { sysState = f (sysState s) }
-
--- |
--- set the system part of the state.
---
--- see also : 'setState'
-
-setSysState		:: SysState -> XState state SysState
-setSysState s
-    = changeSysState ( \_ -> s )
-
--- |
--- read the system part of the state.
---
--- see also : 'getState'
-
-getSysState		:: XState state SysState
-getSysState
-    = changeSysState id
-
--- |
--- the initial system state
---
--- an empty list of attribute value pairs
-
-initialSysState		:: SysState
-initialSysState
-    = SysState { sysStateAttrs        = []
-	       , sysStateErrorHandler = errorMsgToStderr
-	       }
-
--- |
--- change the attributes in the system state
-
-changeSysStateAttrs		:: (SysStateAttrs -> SysStateAttrs) -> (SysState -> SysState)
-changeSysStateAttrs cf sstate
-    = sstate { sysStateAttrs = cf (sysStateAttrs sstate) }
-
-
--- |
--- set the error message handler
-
-setSysErrorHandler		:: XmlStateFilter () -> XState state ()
-setSysErrorHandler ehf
-    = do
-      changeSysState (\ s -> s { sysStateErrorHandler = ehf })
-      return ()
-
--- |
--- get the error handler
-
-getSysErrorHandler		:: XState state (XmlStateFilter ())
-getSysErrorHandler
-    = do
-      s <- getSysState
-      return (sysStateErrorHandler s)
-
--- ------------------------------------------------------------
-
--- |
--- set or change a single system parameter.
---
---    * 1.parameter name :  the name of the parameter
---
---    - 2.parameter value :  the list of associated trees
---
---    - returns : nothing
---
--- see also : 'setSysParam', 'setSysParamInt'
-
-setSysParamTree		:: String -> XmlTrees -> XState state ()
-setSysParamTree name val
-    = do
-      changeSysState (changeSysStateAttrs (addEntry name val))
-      return ()
-
--- |
--- set or change a single system parameter of type string.
---
---    * 1.parameter name :  the name of the parameter
---
---    - 2.parameter value :  the (new) string value
---
---    - returns : nothing
---
--- see also : 'setSysParamTree', setSysParamInt
-
-setSysParam		:: String -> String -> XState state ()
-setSysParam name val
-    = setSysParamTree name (xtext val)
-
--- |
--- set or change a single integer type system parameter
---
--- see also : 'setSysParam'
-
-setSysParamInt		:: String -> Int -> XState state ()
-setSysParamInt name val	= setSysParam name (show val)
-
--- |
--- add (or change) all attributes of the document root to the system state
---     - returns : this
-
-setSystemParams	:: XmlStateFilter state
-setSystemParams t
-    = do
-      changeSysState (changeSysStateAttrs (addEntries (toTreel . getAttrl $ t)))
-      thisM t
-
--- ------------------------------------------------------------
-
--- |
--- read a system parameter
---
---    * 1.parameter name :  the name of the parameter
---
---    - returns : the list of tres associated with the key, or the empty list for unknown parameters
-
-getSysParamTree		:: String -> XState state XmlTrees
-getSysParamTree name
-    = do
-      s <- getSysState
-      return (lookup1 name (sysStateAttrs s))
-
--- |
--- read a system string parameter
---
---    * 1.parameter name :  the name of the parameter
---
---    - returns : the value, or the empty string for unknown parameters
-
-getSysParam		:: String -> XState state String
-getSysParam name
-    = do
-      ts <- getSysParamTree name
-      return (xshow ts)
-
--- |
--- read a system parameter or return a default value
---
---    * 1.parameter name :  the name of the parameter
---
---    - 2.parameter default :  the default value
---
---    - returns : the value if found, else the default
-
-getSysParamWithDefault	:: String -> String -> XState state String
-getSysParamWithDefault name def
-    = do
-      val <- getSysParam name
-      return ( if null val
-	       then def
-	       else val
-	     )
-
--- |
--- read an integer system parameter
---
---    * 1.parameter name : 
---
---    - 2.parameter default : 
---
--- see also : 'getSysParamWithDefault'
-
-getSysParamInt	:: String -> Int -> XState state Int
-getSysParamInt var def
-    = do
-      val <- getSysParamWithDefault var (show def)
-      return (read val)
-
--- ------------------------------------------------------------
-
--- |
--- exec a XState command with initial state.
---
---    * 1.parameter initalState :  the inital user state
---
---    - 2.parameter cmd :  the command
---
---    - returns : the i\/o command with result and user state
-
-run0		:: XmlState state -> XState state res -> IO (res, XmlState state)
-run0 initialState (MonadStateIO.STIO cmd)
-    = do
-      (res, finalState) <- cmd initialState
-      return (res, finalState)
-
--- |
--- exec a XState command with initial user state.
--- ignore final user state.
--- like run0, but ignore the resulting user state
-
-run		:: state -> XState state res -> IO res
-run initialUserState cmd
-    = do
-      (res, _finalState) <- run0 (XmlState initialSysState initialUserState) cmd
-      return res
-
--- |
--- exec a XState command in th IO monad.
--- like run with the empty state ().
-
-run'		:: XState () res -> IO res
-run'		= run ()
-
--- ------------------------------------------------------------
-
--- |
--- run a command in a new user state.
--- chain the system state part,
--- init new system state with the current one, run the command and
--- update the old system state with the resulting new system state
---
---    * 1.parameter initialUserState :  the initial user state
---
---    - 2.parameter cmd :  the command
---
---    - returns : the result of executing cmd and the final state
-
-chain'		:: state1 -> XState state1 res -> XState state0 (res, state1)
-chain' initialUserState1 cmd1
-    = do
-      sysState0 <- getSysState
-      (res, finalState1) <- io $ run0 (XmlState sysState0 initialUserState1) cmd1
-      setSysState (sysState finalState1)
-      return (res, (userState finalState1))
-
--- |
--- like chain' but forget the final user state
---
---    * 1.parameter initialUserState :  the initial user state
---
---    - 2.parameter cmd :  the command
---
---    - returns : only the result of executing cmd
-
-chain		:: state1 -> XState state1 res -> XState state0 res
-chain initialUserState1 cmd1
-    = do
-      (res, _) <- chain' initialUserState1 cmd1
-      return res
-
--- ------------------------------------------------------------
---
--- lift functions
-
--- |
--- lift a XmlFilter to a XmlStateFilter filter
--- issue all error nodes as error messages
--- and remove the error nodes from the result
---
---    * 1.parameter f :  the filter
---
---    - returns : the filter running in the state monad
---
---		  all errors are filtered from the result and issued on stderr
-
-liftF		:: XmlFilter -> XmlStateFilter state
-liftF f		= liftMf f .>> issueError
-
--- |
--- lift an I\/O command
---
---    * 1.parameter cmd :  the i\/o command
---
---    - returns : the i\/o command lifted to the XML state monad
-
-io		:: IO a -> XState state a
-io		= MonadStateIO.io
-
--- ------------------------------------------------------------
---
-
--- |
--- set the trace level.
---
--- convention:
---
--- 0: no trace output (default)
---
--- 1: trace important computation steps, e.g. accessing a document
---
--- 2: trace small computation steps
---
--- 3: output an intermediate result XmlTree in XML source format
---
--- 4: output an intermediate result XmlTree in tree representation
---
---    * 1.parameter level :  the trace level
---
---    - returns : nothing
-
-setTraceLevel	:: Int -> XState state ()
-setTraceLevel l	= setSysParamInt a_trace l
-
--- |
--- get the current trace level.
---
---    - returns : the current trace level
-
-getTraceLevel	:: XState state Int
-getTraceLevel	= getSysParamInt a_trace 0
-
--- |
--- trace output for arbitray commands.
---
---    * 1.parameter level :  the trace level,
---			  for which the command will be execuded
---			  if level \<= current trace level
---
---    - 2.parameter cmd :  the command to be executed
---
---    - returns : nothing
-
-traceCmd	:: Int -> XState state a -> XState state ()
-traceCmd level cmd
-    = do
-      trcLevel <- getTraceLevel
-      if level <= trcLevel
-        then do
-	     _ <- cmd
-	     return ()
-        else return ()
-
--- |
--- trace output function for simple text.
---
---    * 1.parameter level :  like in traceCmd
---
---    - 2.parameter str :  the test
---
---    - returns : nothing
-
-trace		:: Int -> String -> XState state ()
-trace level str
-    = traceCmd level
-      $ do
-	io $ hPutStrLn stderr ("-- (" ++ show level ++ ") " ++ str)
-
--- |
--- trace output of the user part of the program state.
---
---    * 1.parameter level :  like in traceCmd
---
---    - 2.parameter showFct :  the toString function
---
---    - returns : nothing
-
-traceState	:: Int -> (state -> String) -> XState state ()
-traceState level fct
-    = traceCmd level
-      $ do
-	s <- getState
-	io $ hPutStrLn stderr (fct s)
-
--- ------------------------------------------------------------
---
--- error functions
-
--- |
--- filter to reset the state attribute 'a_status'
---    - returns : this
-
-clearStatus	:: XmlStateFilter state
-clearStatus t
-    = do
-      setSysParamInt a_status c_ok
-      thisM t
-
--- |
--- report an error message.
---
---    - returns : if the input tree n represents an error, @res = []@
---		  and the error is processed by the errror handler filter (default: error is issued on stderr)
---		  else @res = [n]@
---
--- see also : 'issueErr'
-
-issueError	:: XmlStateFilter state
-issueError
-    = (setErrorMsgLevel .>> errorMsgHandler .>> noneM)
-      `whenM`
-      isXError
-
-errorMsgHandler	:: XmlStateFilter state
-errorMsgHandler
-    = performAction
-      ( \ t -> chain' () ( do
-			   ehf <- getSysErrorHandler
-			   ehf t
-			   return ()
-			 )
-      )
-
--- |
--- set the error level in system state
-
-setErrorMsgLevel	:: XmlStateFilter state
-setErrorMsgLevel
-    = performAction
-      ( \ (NTree (XError level _str) _cs) ->
-	do
-	errLevel <- getSysParamInt a_status 0
-	setSysParamInt a_status (max errLevel level)
-      )
-
--- |
--- default error handler for writing errors to stderr
-
-errorMsgToStderr	:: XmlStateFilter state
-errorMsgToStderr
-    = performAction
-      ( \ (NTree (XError level str) _cs) ->
-	io $ hPutStrLn stderr ("\n" ++ errClass level ++ ": " ++ str)
-      )
-
--- |
--- error message handler for collecting all error messages
--- all messages are stored under attribute 'a_error_log'
--- they can be read with @getSysParamTree a_error_log@ or by
--- applying the filter 'getErrorMsg' to the root node
-
-errorMsgLogging		:: XmlStateFilter state
-errorMsgLogging
-    = performAction
-      ( \ t ->
-	do
-	errLog <- getSysParamTree a_error_log
-	setSysParamTree a_error_log (t : errLog)
-      )
-
-errorMsgLoggingAndToStderr      :: XmlStateFilter state
-errorMsgLoggingAndToStderr	= errorMsgLogging.>> errorMsgToStderr
-
--- |
--- the filter for reading all collected error mesages
---
--- result is the list of error messages, the input tree is ignored
-
-getErrorMsg	:: XmlStateFilter state
-getErrorMsg _t
-    = do
-      el <- getSysParamTree a_error_log
-      setSysParamTree a_error_log []
-      return (reverse el)
-
--- |
--- error level translation
--- 'c_warn' (1) : warning,
--- 'c_err' (2): error (e.g. parse error, validation error, ...),
--- 'c_fatal' (3) : fatal error (document access error, internal error, ...)
-
-errClass	:: Int -> String
-errClass l
-    = fromMaybe "fatal error" . lookup l $ msgList
-      where
-      msgList	= [ (c_ok,	"no error")
-		  , (c_warn,	"warning")
-		  , (c_err,	"error")
-		  , (c_fatal,	"fatal error")
-		  ]
-
--- |
--- short cut for issuing a warning
---
--- see also : 'issueError', 'issueErr'
-
-issueWarn	:: String -> XmlStateFilter state
-issueWarn msg	= liftMf (warn msg) .>> issueError
-
--- |
--- short cut for issuing an error
---
--- see also : 'issueError'
-
-issueErr	:: String -> XmlStateFilter state
-issueErr msg	= liftMf (err msg) .>> issueError
-
--- |
--- short cut for issuing a fatal error
---
--- see also : 'issueError', 'issueErr'
-
-issueFatal	:: String -> XmlStateFilter state
-issueFatal msg	= liftMf (fatal msg) .>> issueError
-
-
--- ------------------------------------------------------------
---
--- issue an error, add the error to the document root tree
--- and return the tree
-
-addFatal	:: String -> XmlStateFilter state
-addFatal msg
-    = liftF ( fatal msg
-	      +++
-	      setStatus c_fatal "accessing documents"
-	    )
-
--- ------------------------------------------------------------
-
--- |
--- checks the value of the attribute 'a_status' in a document root.
--- if it contains a value greater or equal to 'c_err', an error with error message
--- stored in attribute 'a_module' is issued and the filter acts as the 'noneM' filter
--- else its the 'thisM' filter
-
-checkStatus	:: XmlStateFilter state
-checkStatus t
-    = if status >= c_err
-      then do
-	   errorMsgHandler (mkXErrorTree c_warn (errClass status ++ "s detected in " ++ msg) [])
-	   noneM t
-	else
-           thisM t
-    where
-    status = intValueOf a_status t
-    msg    =    valueOf a_module t
-
--- |
--- add the error level and the module where the error occured
--- to the attributes of a document root node and remove the children when level is greater or equal to 'c_err'
-
-setStatus	:: Int -> String -> XmlFilter
-setStatus level msg
-    = ( addAttrInt a_status level
-	.>
-	addAttr a_module msg
-	.>
-	( if level >= c_err
-	  then replaceChildren []
-	  else this
-	)
-      )
-      `when` isRoot
-
--- |
--- check whether tree is a document root and the status attribute has a value less than 'c_err'
-
-statusOk	:: XmlFilter
-statusOk
-    = isRoot
-      .>
-      isOf (\ t -> not (intValueOf a_status t >= c_err))
--- |
--- check whether the error level attribute in the system state
--- is set to error, in this case the children of the document root are
--- removed and error info is added as attributes with 'setStatus'
--- else nothing is changed
-
-checkResult	:: String -> XmlStateFilter state
-checkResult msg t
-    = do
-      level <- getSysParamInt a_status 0
-      ( if level <= c_warn
-	then thisM
-	else liftMf ( setStatus level msg )
-        ) t
-
--- |
--- monadic filter for processing the attribute list of a tag.
--- for other trees this filter acts like 'noneM'
---
--- see also : 'processAttr', 'processAttrl'
-
-processAttrM				:: XmlStateFilter a -> XmlStateFilter a
-processAttrM f t
-    = do
-      res <- f $$< al
-      return $ replaceAttrl res t
-    where
-    al = getAttrl t
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTree.html b/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTree.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTree.html +++ /dev/null @@ -1,29 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- This helper module exports elements from the basic libraries:
--- XmlTreeTypes, XmlKeywords, XNodeFunctions, XmlTreeFunctions and XmlTreeFilter
-
-module Text.XML.HXT.DOM.XmlTree
-    ( module Text.XML.HXT.DOM.XmlTreeTypes
-    , module Text.XML.HXT.DOM.XmlKeywords
-    , module Text.XML.HXT.DOM.XmlTreeFunctions
-    , module Text.XML.HXT.DOM.XmlTreeFilter
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlTreeTypes		-- NTree and XNode types
-import Text.XML.HXT.DOM.XmlKeywords		-- keywords for DTD
-import Text.XML.HXT.DOM.XmlTreeFunctions	-- tree constructors and selector
-import Text.XML.HXT.DOM.XmlTreeFilter		-- basic filter
-
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTreeFilter.html b/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTreeFilter.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTreeFilter.html +++ /dev/null @@ -1,965 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- basic XmlTree filter
-
-module Text.XML.HXT.DOM.XmlTreeFilter
-    ( module Text.XML.HXT.DOM.XmlTreeFilter
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTreeTypes
-import Text.XML.HXT.DOM.XmlTreeFunctions
-import Text.XML.HXT.DOM.XmlKeywords
-import Text.XML.HXT.DOM.Unicode	( isXmlSpaceChar	)
-import Text.XML.HXT.DOM.Util	( decimalStringToInt	)
-
-import Data.List		( partition	)
-
-infixl 7 += , ++=
-
--- -----------------------------------------------------------------------------
---
--- filter predicates
-
--- |
--- test whether the root of a tree contains a document root node.
-
-isRoot			:: XmlFilter
-isRoot			= isOfNode (isTagNode t_root)
-
--- |
--- test whether the root of a tree contains a tag node.
---
--- see also: 'isNsTag'
-
-isTag			:: String -> XmlFilter
-isTag tn		= isOfNode (isTagNode tn)
-
--- |
--- namespace aware test whether the root of a tree contains a tag node. Parameters are the local part and namespace.
--- Only usable after namespace propagation.
---
--- see also: 'isTag'
-
-isNsTag			:: String -> String -> XmlFilter
-isNsTag lp ns		= isOfTag (\ t -> localPart t == lp && namespaceUri t == ns)
-
--- |
--- test whether the root of a tree has a given local name
--- see also : 'hasNamespace', 'hasPrefix', 'isTag', 'isAttr'
-
-hasLocalPart		:: String -> XmlFilter
-hasLocalPart lp		= isOf ((== lp) . localPartOf)
-
--- |
--- test whether the root of a tree has a given prefix name
--- see also : 'hasNamespace', 'hasLocalPart', 'isTag', 'isAttr'
-
-hasPrefix		:: String -> XmlFilter
-hasPrefix px		= isOf ((== px) . prefixOf)
-
--- |
--- test whether the root of a tree belongs to a given namespace
--- see also : 'isTag', 'isAttr', 'hasLocalPart', 'hasPrefix'
-
-hasNamespace		:: String -> XmlFilter
-hasNamespace ns		= isOf ((== ns) . namespaceOf)
-
--- |
--- test whether the root of a tree contains a tag node with a special name.
-
-isOfTag			:: (TagName -> Bool) -> XmlFilter
-isOfTag			= isOfNode . isOfTagNode
-
--- |
--- test whether the node of a tree is a XTag node or a XPi node with an attibute of a specific name
---
--- see also: 'isAttr', 'hasNsAttr'
-
-hasAttr			:: String -> XmlFilter
-hasAttr an		= (getAttrl .> isAttr an) `guards` this
-
--- |
--- test whether the tree is a XTag node with an attibute of a specific local name and namespace uri
---
--- see also: 'hasAttr', 'isNsAttr'
-
-hasNsAttr		:: String -> String -> XmlFilter
-hasNsAttr an ns		= (getAttrl .> isNsAttr an ns) `guards` this
-
--- |
--- test whether the given node is a XTag node or a XPI node with an attribute with a value with a specific property.
--- In case of a match, the attribute value represented by a text node is returned as single element list,
--- else the empty list is the result.
---
--- see also : 'getValue'
-
-hasValue		:: String -> (String -> Bool) -> XmlFilter
-hasValue a p t
-   | (not . null) att
-     &&
-     p val
-       = xtext val
-   | otherwise
-       = []
-   where
-   att = getAttrl .> isAttr a $ t
-   val = xshow . getChildren $$ att
-
--- |
--- test whether the tree is a processing instruction with a given name.
-
-isPi			:: String -> XmlFilter
-isPi pn			= isOfNode (isPiNode pn)
-
--- |
--- test whether the tree is a \<?xml ... ?\> declaration
-
-isXmlPi			:: XmlFilter
-isXmlPi			= isPi t_xml
-
--- |
--- test whether the root of a tree contains a processing instruction of a special name.
-
-isOfPi			:: (TagName -> Bool) -> XmlFilter
-isOfPi			= isOfNode . isOfPiNode
-
--- -----------------------------------------------------------------------------
-
--- simple XNode Filter predicates
---
-
--- |
--- test whether the root of a tree contains a CDATA node.
-
-isXCdata		:: XmlFilter
-isXCdata		= isOfNode isXCdataNode
-
--- |
--- test whether the root of a tree contains a character reference node.
-
-isXCharRef		:: XmlFilter
-isXCharRef		= isOfNode isXCharRefNode
-
--- |
--- test whether the root of a tree contains a comment node.
-
-isXCmt			:: XmlFilter
-isXCmt			= isOfNode isXCmtNode
-
--- |
--- test whether the root of a tree contains a DTD part.
-
-isXDTD			:: XmlFilter
-isXDTD			= isOfNode isXDTDNode
-
--- |
--- test whether the root of a tree contains an entity reference node.
-
-isXEntityRef		:: XmlFilter
-isXEntityRef		= isOfNode isXEntityRefNode
-
--- |
--- test whether the root of a tree contains an error node.
-
-isXError		:: XmlFilter
-isXError		= isOfNode isXErrorNode
-
--- |
--- test whether the root of a tree contains a processing instruction node.
-
-isXPi			:: XmlFilter
-isXPi			= isOfNode isXPiNode
-
--- |
--- test whether the root of a tree contains a tag node.
-
-isXTag			:: XmlFilter
-isXTag			= isOfNode isXTagNode
-
--- |
--- test whether the root of a tree contains an attribute node.
-
-isXAttr			:: XmlFilter
-isXAttr			= isOfNode isXAttrNode
-
--- |
--- test whether the root of a tree is an attribute node for a given attribute name
-
-isAttr			:: String -> XmlFilter
-isAttr an		= isOfNode (isAttrNode an)
-
--- |
--- namespace aware test whether the tree contains an attribute node. Parameters are the local part of the atribute name and the namespace.
--- Only usable after namespace propagation.
---
--- see also: 'isNsTag', 'isAttr', 'hasNsAttr'
-
-isNsAttr		:: String -> String -> XmlFilter
-isNsAttr lp ns		= isOfAttr (\ a -> localPart a == lp && namespaceUri a == ns)
-
--- |
--- general test for an attribute name
-
-isOfAttr		:: (AttrName -> Bool) -> XmlFilter
-isOfAttr		= isOfNode . isOfAttrNode
-
--- |
--- test whether the root of a tree contains a text node.
-
-isXText			:: XmlFilter
-isXText			= isOfNode isXTextNode
-
--- |
--- test whether the root of a tree contains a special text.
-
-isText			:: String -> XmlFilter
-isText t		= isOfNode (isTextNode t)
-
--- |
--- test whether the root of a tree contains a text node with a special property
-
-isOfText		:: (String -> Bool) -> XmlFilter
-isOfText		= isOfNode . isOfTextNode
-
--- |
--- test whether the root of a tree contains a text node only with whitespace.
-
-isWhiteSpace		:: XmlFilter
-isWhiteSpace
-    = isOfNode isWS
-      where
-      isWS n
-	  = isXTextNode n
-	    && all isXmlSpaceChar (textOfXNode n)
-
--- ------------------------------------------------------------
---
--- XDTD Predicates
-
--- |
--- test whether the root of a tree contains a DOCTYPE DTD part.
-
-isDoctype			:: XmlFilter
-isDoctype			= isOfNode (isDTDElemNode DOCTYPE)
-
--- |
--- test whether the root of a tree contains an ATTLIST DTD part.
-
-isAttlist			:: XmlFilter
-isAttlist			= isOfNode (isDTDElemNode ATTLIST)
-
--- |
--- test whether the root of a tree contains an ELEMENT DTD part.
-
-isElement			:: XmlFilter
-isElement			= isOfNode (isDTDElemNode ELEMENT)
-
--- |
--- test whether the root of a tree contains an ENTITY DTD part.
-
-isEntity			:: XmlFilter
-isEntity			= isOfNode (isDTDElemNode ENTITY)
-
--- |
--- test whether the root of a tree contains a parameter ENTITY reference.
-
-isPeRef				:: XmlFilter
-isPeRef				= isOfNode (isDTDElemNode PEREF)
-
--- |
--- test whether the root of a tree contains a DTD name part.
-
-isDTDName			:: XmlFilter
-isDTDName			= isOfNode (isDTDElemNode NAME)
-
--- |
--- test whether the root of a tree contains a conditional section DTD part.
-
-isCondSect			:: XmlFilter
-isCondSect			= isOfNode (isDTDElemNode CONDSECT)
-
--- |
--- test whether the root of a tree contains a parameter entity declaration.
-
-isParameterEntity		:: XmlFilter
-isParameterEntity		= isOfNode (isDTDElemNode PENTITY)
-
--- |
--- test whether the root of a tree contains a NOTATION DTD part.
-
-isNotation			:: XmlFilter
-isNotation			= isOfNode (isDTDElemNode NOTATION)
-
--- ATTLIST predicates
-
-isDefaultAttrKind		:: XmlFilter
-isDefaultAttrKind		= isOf (a_kind `ofDTDequals` k_default)
-
-isEnumAttrType			:: XmlFilter
-isEnumAttrType			= isOf (a_type `ofDTDequals` k_enumeration)
-
-isFixedAttrKind			:: XmlFilter
-isFixedAttrKind			= isOf (a_kind `ofDTDequals` k_fixed)
-
-isIdAttrType			:: XmlFilter
-isIdAttrType			= isOf (a_type `ofDTDequals` k_id)
-
-isIdRefAttrType			:: XmlFilter
-isIdRefAttrType			= isOf ((`elem` [k_idref, k_idrefs]) . valueOfDTD a_type)
-
-isNotationAttrType		:: XmlFilter
-isNotationAttrType		= isOf (a_type `ofDTDequals` k_notation)
-
-isRequiredAttrKind		:: XmlFilter
-isRequiredAttrKind		= isOf (a_kind `ofDTDequals` k_required)
-
-isAttlistParameterEntity	:: XmlFilter
-isAttlistParameterEntity	= isAttlist .> isOf (a_type `ofDTDequals` k_peref)
-
--- ELEMENT predicates
-
-isEmptyElement			:: XmlFilter
-isEmptyElement			= isOf (a_type `ofDTDequals` k_empty)
-
-isMixedContentElement		:: XmlFilter
-isMixedContentElement		= isOf (a_type `ofDTDequals` v_mixed)
-
-isElemWithContent		:: XmlFilter
-isElemWithContent		= isElement
-				  .>
-				  isOf ((`elem` [v_mixed, v_children]) . valueOfDTD a_type)
-
-isAttlistOfElement		:: String -> XmlFilter
-isAttlistOfElement el		= isAttlist
-				  .>
-				  isOf (a_name `ofDTDequals` el)
-
-isElemContentParamEntity	:: XmlFilter
-isElemContentParamEntity	= isElement
-				  .>
-				  isOf (a_type `ofDTDequals` k_peref)
-
--- ENTITY predicates
-
-isUnparsedEntity		:: XmlFilter
-isUnparsedEntity		= isOf (hasEntry k_ndata . attrlOfDTD)
-
-isExternalParameterEntity	:: XmlFilter
-isExternalParameterEntity	= isParameterEntity
-				  .>
-				  isOf (hasEntry k_system . attrlOfDTD)
-
-isInternalParameterEntity	:: XmlFilter
-isInternalParameterEntity	= isParameterEntity
-				  .> isOf (not . hasEntry k_system . attrlOfDTD)
-
--- -----------------------------------------------------------------------------
-
--- |
--- test whether the root of a tree contains an error node for a warning.
-
-isWarning 			:: XmlFilter
-isWarning			= isOfNode $ isErrorNode c_warn
-
--- |
--- test whether the root of a tree contains an error node for an error.
-
-isError 			:: XmlFilter
-isError				= isOfNode $ isErrorNode c_err
-
--- |
--- test whether the root of a tree contains an error node for a fatal error.
-
-isFatalError 			:: XmlFilter
-isFatalError			= isOfNode $ isErrorNode c_fatal
-
--- -----------------------------------------------------------------------------
---
--- constructor filter
-
--- |
--- constructor filter for a tag node.
--- a new tree is constructed.
--- the attributes and the children are computed by applying the aproprate filter to the input tree
---
---    * 1.parameter n :  the tag name
---
---    - 2.parameter af :  the filter for the attribute list
---
---    - 3.parameter cf :  the filter for the children
---
---    - returns : the constructor filter
-
-mkXTag		:: String -> XmlFilter -> XmlFilter -> XmlFilter
-mkXTag n af cf
-    = \ t -> [ mkXTagTree n (af t) (cf t) ]
-
--- | Version with qualified names of 'mkXTag'
-
-mkQTag		:: QName -> XmlFilter -> XmlFilter -> XmlFilter
-mkQTag q af cf
-    = \ t -> [ mkQTagTree q (af t) (cf t) ]
-
--- |
--- constructor filter for a tag node.
--- a new tree is constructed.
--- the attributes and the children are computed by applying the aproprate filter to the input tree
---
---    * 1.parameter n :  the tag name in form of prefix:localpart
---
---    - 2.parameter ns:   the namespace uri
---
---    - 3.parameter af :  the filter for the attribute list
---
---    - 4.parameter cf :  the filter for the children
---
---    - returns : the constructor filter
-
-mkXNsTag	:: String -> String -> XmlFilter -> XmlFilter -> XmlFilter
-mkXNsTag n ns af cf
-    = \ t -> [ mkXNsTagTree n ns (af t) (cf t) ]
-
--- |
--- filter for attribute construction.
--- a new tree with attribute name and a value computed by a filter
--- is build.
-
-mkXAttr		:: String -> XmlFilter -> XmlFilter
-mkXAttr n af
-    = \ t -> [ mkXAttrTree n (af t) ]
-
--- | Qualified version 'mkXAttr'
-
-mkQAttr		:: QName -> XmlFilter -> XmlFilter
-mkQAttr q af
-    = \ t -> [ mkQAttrTree q (af t) ]
-
--- |
--- filter for attribute construction.
--- a new tree with attribute name and namespace and a value computed by a filter
--- is build.
-
-mkXNsAttr	:: String -> String -> XmlFilter -> XmlFilter
-mkXNsAttr n ns af
-    = \ t -> [ mkXNsAttrTree n ns (af t) ]
-
--- |
--- constructor filter for a text node.
--- a new tree is constructed.
--- the input tree is ignored.
-
-mkXText		:: String                          -> XmlFilter
-mkXText		= mkNTree . mkXTextTree
-
--- |
--- constructor filter for a character reference node.
--- a new tree is constructed.
--- the input tree is ignored.
-
-mkXCharRef	:: Int                             -> XmlFilter
-mkXCharRef	= mkNTree . mkXCharRefTree
-
--- |
--- constructor filter for an entity reference node.
--- a new tree is constructed.
--- the input tree is ignored.
-
-mkXEntityRef	:: String                          -> XmlFilter
-mkXEntityRef	= mkNTree . mkXEntityRefTree
-
--- |
--- constructor filter for a comment node.
--- a new tree is constructed.
--- the xml string representation of the filter result
--- forms the comment
-
-mkXCmt		:: XmlFilter -> XmlFilter
-mkXCmt cf
-    = \ t -> [ mkXCmtTree ((xshow . cf) t) ]
-
--- |
--- constructor filter for a DTD part.
--- a new tree is constructed.
--- the input tree is ignored.
-
-mkXDTD		:: DTDElem -> Attributes -> XmlTrees -> XmlFilter
-mkXDTD n al	= mkNTree . mkXDTDTree n al
-
--- |
--- constructor filter for a CDATA section node.
--- a new tree is constructed.
--- the input tree is ignored.
-
-mkXCdata	:: XmlFilter -> XmlFilter
-mkXCdata cf
-    = \ t -> [ mkXCdataTree ((xshow . cf) t) ]
-
--- |
--- constructor filter for a processing instruction
--- a new tree is constructed from the text representation
--- of the input tree
-
-mkXPi		:: String -> XmlFilter -> XmlFilter
-mkXPi piName cf
-    = \ t -> [ mkXPiTree piName ((xshow . cf) t) ]
-
--- |
--- constructor filter for an error message node.
--- a new tree is constructed.
--- the input tree is ignored.
-
-mkXError	:: Int -> String                   -> XmlFilter
-mkXError l s	= this . mkXErrorTree l s . this
-
--- -----------------------------------------------------------------------------
---
--- selector filters
-
--- |
--- filter for selecting the name of a tag node, an attribute node or a pi node.
--- Result of the filter is a single element list with a text node or the empty list
-
-getName	::             XmlFilter
-getName t
-    | null s    = []
-    | otherwise = xtext s
-    where
-    s = nameOf t
-
--- |
--- filter for selecting the attibute list
-
-getAttrl	:: XmlFilter
-getAttrl
-    = selAttrl . getNode
-    where
-    selAttrl (XTag _ al) = al
-    selAttrl (XPi  _ al) = al
-    selAttrl _           = []
-
--- |
--- filter for selecting the value of an attribute in a tag node.
--- Result of the filter is a single element list with a text node or the empty list
---
--- see also : 'hasValue', 'getNsValue'
-
-getValue		:: String -> XmlFilter
-getValue a		= xmlTreesToText . (getAttrl .> isAttr a .> getChildren)
-
--- |
--- filter for selecting the value of an attribute with namespace in a tag node.
--- Result of the filter is a single element list with a text node or the empty list
---
--- see also : 'getValue', 'isNsAttr'
-
-getNsValue		:: String -> String -> XmlFilter
-getNsValue lp ns	= xmlTreesToText . (getAttrl .> isNsAttr lp ns .> getChildren)
-
--- |
--- filter for selecting an attribute of a DTD node.
--- Result of the filter is a single element list with a text node or the empty list
-
-getDTDValue		:: String -> XmlFilter
-getDTDValue a		= xtext . valueOfDTD a
-
--- |
--- filter for selecting content of a comment.
--- Result of the filter is a single element list with a text node or the empty list
-
-getXCmt			:: XmlFilter
-getXCmt
-    = selCmt . getNode
-      where
-      selCmt (XCmt c)	= xtext c
-      selCmt _          = []
-
--- |
--- filter for selecting the CDATA content.
--- Result of the filter is a single element list with a text node or the empty list
-
-getXCdata		:: XmlFilter
-getXCdata
-    = selData . getNode
-      where
-      selData (XCdata d)	= xtext d
-      selData _			= []
-
--- -----------------------------------------------------------------------------
---
--- edit filter
-
--- |
--- edit filter for changing the name of a tag node, an attribute or a pi.
--- result of the filter is a single element list with a tag node or the empty list
-
-replaceQName				:: String -> XmlFilter
-replaceQName n				= modifyQName (const (mkName n))
-
--- |
--- edit filter for changing the text of a text node.
--- result of the filter is a single element list with a text node or the empty list
---
--- example for editing all text nodes of a tree with an edit function @f@:
---
--- @processBottomUp (modifyText f \`when\` isXText)@
-
-modifyText				:: (String -> String) -> XmlFilter
-modifyText f t@(NTree n _)
-    | isXTextNode n			= replaceNode (XText (f (textOfXNode n))) t
-modifyText _ _				= []
-
--- |
--- edit filter for changing the name of a tag node.
--- result of the filter is a single element list with a text node or the empty list
-
-modifyQName				::  (TagName -> TagName) -> XmlFilter
-modifyQName f (NTree (XTag n al) cs)	= [NTree (XTag (f n) al) cs]
-modifyQName f (NTree (XPi  n al) cs)	= [NTree (XPi  (f n) al) cs]
-modifyQName f (NTree (XAttr n)   cs)	= [NTree (XAttr (f n)  ) cs]
-modifyQName _ _			= []
-
--- -----------------------------------------------------------------------------
-
--- |
--- process the attribute list of a tag node with a tree list filter.
--- for other trees this filter acts like 'none'
-
-processAttrl				:: XmlSFilter -> XmlFilter
-processAttrl f t
-    = replaceAttrl (f al) t
-      where
-      al = getAttrl t
-
--- |
--- elementwise processing of the attributes of a tag.
--- for other trees this filter acts like 'none'
---
--- see also : 'processAttrl'
-processAttr				:: XmlFilter -> XmlFilter
-processAttr f
-    = processAttrl (f $$)
-
--- |
--- replace an attribute list
--- to be renamed when replaceAttrl is eliminated
-
-replaceAttrl				:: XmlTrees -> XmlFilter
-replaceAttrl al (NTree (XTag n _al) cs)	= [ NTree (XTag n al) cs ]
-replaceAttrl al (NTree (XPi  n _al) cs)	= [ NTree (XPi  n al) cs ]
-replaceAttrl _ _			= []
-
--- |
--- delete an attribute from the attribute list of a tag tree
-
-del1Attr				:: String -> XmlFilter
-del1Attr an				= processAttr (none `when` isAttr an)
-
--- |
--- add an attribute to the attribute list of a tag.
--- If the attribute already exists, it\'s substituted,
---
--- see also: 'sattr', '+='
-
-add1Attr				:: XmlTree -> XmlFilter
-add1Attr a@(NTree (XAttr an) _av) t
-    = replaceAttrl (replace al) t
-      where
-      al = getAttrl t
-      replace [] = [a]
-      replace (a1 : as)
-	  | satisfies (isAttr (qualifiedName an)) a1
-	      = a : as
-	  | otherwise
-	      = a1 : replace as
-
-add1Attr _ t
-    = this t
-
--- |
--- adds an attribute list computed by a filter, uses 'add1Attr'.
---
--- see also: '+='
-
-addAttrl				:: XmlFilter -> XmlFilter
-addAttrl attrFilter t
-    = ((foldl (.>) this . map add1Attr) al) t
-      where
-      al = attrFilter t
-
--- |
--- add or change an attribute with a given string as value for a XTag or XPi tree,
--- uses 'add1Attr'.
-
-addAttr					:: String -> String -> XmlFilter
-addAttr an av
-    = add1Attr (mkXAttrTree an (if null av then [] else xtext av))
-
--- |
--- add or change an attribute with an Int value.
--- uses 'addAttr'.
-
-addAttrInt				:: String -> Int -> XmlFilter
-addAttrInt an av
-    = addAttr an (show av)
-
--- |
--- edit filter for changing the value of an attribute in a tag node.
--- result of the filter is a single element list with the tag node or the empty list.
---
---    * 1.parameter n :  the name of the attribute
---
---    - 2.parameter f :  the edit function for the attribute value
---
---    - returns : the edit filter
-
-modifyAttr				:: String -> (String -> String) -> XmlFilter
-modifyAttr an f
-    = processAttr (modifyValue `when` isAttr an)
-      where
-      modifyValue = modifyChildren ((modifyText f $$) . xmlTreesToText)
-
--- |
--- add or change an attribute of a DTD tree
-
-addDTDAttr				:: String -> String -> XmlFilter
-addDTDAttr an av (NTree (XDTD e al) cs)
-    = [NTree (XDTD e (addEntry an av al)) cs]
-
-addDTDAttr _ _ _
-    = []
-
-
--- -----------------------------------------------------------------------------
---
-
--- |
--- convenient function for tag node tree construction
---
--- infixl 7
---
--- filter combinator for tag tree constrcution
--- take a 1. filter for computing a tag node tree (or a whole list of tag node trees)
--- then add all trees computed by the 2. filter to the attribute list when they represent attributes
--- else append them to the list of children.
---
--- if the 1. filter computes a list of tag nodes, the results of the 2. filter are added to all trees
---
--- example: @ etag \"a\" += sattr \"href\" \"\#42\" += txt \"the answer\" @
--- gives the tree @ \<a href=\"\#42\"\>the answer\<\/a\> @
---
--- example: @ ( etag \"a\" +++ etag \"b\" ) += sattr \"x\" \"42\" @
--- gives the tree @ \<a x=\"42\"\/\>\<b x=\"42\"\/\> @
---
--- see also : 'etag', 'tag', 'add1Attr', 'modifyChildren', '++='
-
-(+=)	:: XmlFilter -> XmlFilter -> XmlFilter
-(+=) tf cf t
-    = concat
-      [ ( isXTag `guards` ( addaf .> addcf )) $ t'
-	| t' <- tf t
-      ]
-    where
-    (as, cs) = partition (satisfies isXAttr) . cf $ t
-
-    addaf | null as   = this
-          | otherwise = addAttrl (const as)
-
-    addcf | null cs   = this
-          | otherwise = modifyChildren (++ cs)
-
--- |
--- convenient filter function adding a whole list of trees, just for not writing to many ( ... ).
---
--- infixl 7
---
--- @ f ++= gl  == f += cat gl @
---
--- see also : '+='
-
-(++=)	:: XmlFilter -> [XmlFilter] -> XmlFilter
-tf ++= cfs
-    = tf += cat cfs
-
--- -----------------------------------------------------------------------------
---
--- string access functions
-
--- |
--- combination of 'getValue' and conversion into a String
-
-valueOf			:: String -> XmlTree -> String
-valueOf a		= xshow . getValue a
-
--- |
--- combination of 'getValue' and conversion to a Int
-
-intValueOf		:: String -> XmlTree -> Int
-intValueOf a		= decimalStringToInt . valueOf a
-
--- -----------------------------------------------------------------------------
---
--- convenient filter (short cuts)
-
--- |
--- variant of mkXTag with a list of filters for the attributes and a list of filters for the children.
--- this variant leads to a more readable source for a complicated construction filter
--- than the simple solution with a combination of 'mkXTag' and 'cat'.
---
--- see also : 'mkXTag', 'stag', 'etag', 'cat', '+='
-
-tag		:: String -> [XmlFilter] -> [XmlFilter] -> XmlFilter
-tag n afs cfs	= mkXTag n (cat afs) (cat cfs)
-
--- |
--- variant of tag, useful for tags without attributes and with a list of filters for
--- constructing the children
---
--- see also : 'mkXTag', 'tag', 'etag', 'cat', '+='
-
-stag		:: String -> [XmlFilter] -> XmlFilter
-stag n cfs	= mkXTag n none (cat cfs)
-
--- |
--- variant of tag, useful for tags with attributes but without children
---
--- see also : 'mkXTag', 'tag', 'stag', 'etag', 'cat'
-
-atag		:: String -> [XmlFilter] -> XmlFilter
-atag n cfs	= mkXTag n (cat cfs) none
-
--- |
--- Short cut for empty tags without attributes
---
--- see also : 'tag', 'atag', 'stag', 'mkXTag' and '+='
-
-etag		:: String -> XmlFilter
-etag n		= mkXTag n none none
-
--- | Qualified version of etag
-
-qetag		:: QName -> XmlFilter
-qetag q		= mkQTag q none none
-
--- | Alias for mkQTag
-
-qtag		:: QName -> XmlFilter -> XmlFilter -> XmlFilter
-qtag = mkQTag
-
-
--- |
--- filter for creating a document root node with a list of filters for the attributes and a list of filters for the document.
---
--- see also : 'tag'
-
-rootTag		:: [XmlFilter] -> [XmlFilter] -> XmlFilter
-rootTag afs cfs	= mkXTag t_root (cat afs) (cat cfs)
-
--- |
--- Alias for 'mkXAttr'
-
-attr		:: String -> XmlFilter -> XmlFilter
-attr		= mkXAttr
-
--- | Alias for mkQAttr
-qattr		:: QName -> XmlFilter -> XmlFilter
-qattr = mkQAttr
-
--- |
--- short cut for attribute construction with string constants
---
--- set also : 'attr', 'mkXAttr' and 'mkXText'
-
-sattr		:: String -> String -> XmlFilter
-sattr a v	= mkXAttr a (mkXText v)
-
--- |
--- short cut for 'mkXText'
-
-txt		:: String  -> XmlFilter
-txt		= mkXText
-
--- |
--- short cut for simple comment
--- the input tree is ignored
---
--- see also : 'mkXCmt'
-
-cmt		:: String  -> XmlFilter
-cmt c		= mkXCmt (txt c)
-
--- |
--- short cut for generating simple processing instructions (spi)
--- the input tree is ignored
---
--- @spi \"xyz\" \"abc\"@ is equal to @mkXPi \"xyz\" (txt \"abc\")@
--- (the name pi is already used in prelude)
-
-spi		:: String -> String -> XmlFilter
-spi n c		= mkXPi n (txt c)
-
--- |
--- short cut for generating simple cdata sections,
--- the input tree is ignored
-
-cdata		:: String -> XmlFilter
-cdata s		= mkXCdata (txt s)
-
--- |
--- DTD part generation with filter for attributes and children
--- see also: 'mkXDTDTree'
-
-dtd		:: DTDElem -> [XmlFilter] -> [XmlFilter] -> XmlFilter
-dtd dtdpart afs cfs t
-    = mkXDTD dtdpart (toAttrl . cat afs $ t) (cat cfs t) $ t
-
--- |
--- short cut for mkXError c_warn.
---
--- see also : 'mkXError'
-
-warn		:: String -> XmlFilter
-warn		= mkXError c_warn
-
--- |
--- short cut for mkXError c_fatal.
---
--- see also : 'mkXError'
-
-err		:: String -> XmlFilter
-err		= mkXError c_err
-
--- |
--- short cut for mkXError c_fatal.
---
--- see also : 'mkXError'
-
-fatal		::  String -> XmlFilter
-fatal		= mkXError c_fatal
-
--- |
--- check whether an option is set
---
--- reads the value of an attribute, usually applied to a document root node,
--- and checks if the value represents True. The following strings are interpreted
--- as true: \"1\", \"True\", \"true\", \"yes\", \"Yes\".
-
-hasOption	:: String -> XmlFilter
-hasOption opt
-    = getValue opt .> isOfText isSet
-      where
-      isSet x
-	  = x `elem` ["1", "True", "true", "yes", "Yes"]
-
-
--- -----------------------------------------------------------------------------
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTreeFunctions.html b/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTreeFunctions.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTreeFunctions.html +++ /dev/null @@ -1,561 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
-
-{- |
-   Module     : Text.XML.HXT.DOM.XmlTreeFunctions
-   Copyright  : Copyright (C) 2008 Uwe Schmidt
-   License    : MIT
-
-   Maintainer : Uwe Schmidt (uwe@fh-wedel.de)
-   Stability  : stable
-   Portability: portable
-
-   Basic XmlTree functions
-
--}
-
--- ------------------------------------------------------------
-
-module Text.XML.HXT.DOM.XmlTreeFunctions
-    ( module Text.XML.HXT.DOM.XmlTreeFunctions
-    , module Text.XML.HXT.DOM.ShowXml
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTreeTypes
-import Text.XML.HXT.DOM.XmlKeywords
-import Text.XML.HXT.DOM.ShowXml
-
-import Data.Maybe
-
--- -----------------------------------------------------------------------------
---
--- XNode Predicates
---
-
-isXCdataNode			:: XNode -> Bool
-isXCdataNode (XCdata _)		= True
-isXCdataNode _			= False
-
-isXCharRefNode			:: XNode -> Bool
-isXCharRefNode (XCharRef _)	= True
-isXCharRefNode _		= False
-
-isXCmtNode			:: XNode -> Bool
-isXCmtNode (XCmt _)		= True
-isXCmtNode _			= False
-
-isXDTDNode			:: XNode -> Bool
-isXDTDNode (XDTD _ _)		= True
-isXDTDNode _			= False
-
-isXAttrNode			:: XNode -> Bool
-isXAttrNode (XAttr _)		= True
-isXAttrNode _			= False
-
-isXEntityRefNode		:: XNode -> Bool
-isXEntityRefNode (XEntityRef _)	= True
-isXEntityRefNode _		= False
-
-isXErrorNode			:: XNode -> Bool
-isXErrorNode (XError _ _)	= True
-isXErrorNode _			= False
-
-isXPiNode			:: XNode -> Bool
-isXPiNode (XPi _ _)		= True
-isXPiNode _			= False
-
-isXTagNode			:: XNode -> Bool
-isXTagNode  (XTag _ _)		= True
-isXTagNode _			= False
-
-isXTextNode			:: XNode -> Bool
-isXTextNode (XText _)		= True
-isXTextNode _			= False
-
--- -----------------------------------------------------------------------------
-
-isRootNode			:: XNode -> Bool
-isRootNode			= isTagNode t_root
-
-isTagNode			:: String -> XNode -> Bool
-isTagNode n			= isOfTagNode ((== n) . qualifiedName)
-
-isOfTagNode			:: (TagName -> Bool) -> XNode -> Bool
-isOfTagNode p (XTag n _)	= p n
-isOfTagNode _ _			= False
-
-isAttrNode			:: String -> XNode -> Bool
-isAttrNode n			= isOfAttrNode ((== n) . qualifiedName)
-
-isOfAttrNode			:: (AttrName -> Bool) -> XNode -> Bool
-isOfAttrNode p (XAttr n)	= p n
-isOfAttrNode _ _		= False
-
-isTextNode			:: String -> XNode -> Bool
-isTextNode t			= isOfTextNode (== t)
-
-isOfTextNode			:: (String -> Bool) -> XNode -> Bool
-isOfTextNode p (XText t)	= p t
-isOfTextNode _ _		= False
-
-isPiNode			:: String -> XNode -> Bool
-isPiNode n			= isOfPiNode ((== n) . qualifiedName)
-
-isOfPiNode			:: (TagName -> Bool) -> XNode -> Bool
-isOfPiNode p (XPi n _)		= p n
-isOfPiNode _ _			= False
-
-isDTDElemNode 			:: DTDElem -> XNode -> Bool
-isDTDElemNode e	(XDTD n _)	= n == e
-isDTDElemNode _ _		= False
-
-isErrorNode 			:: Int -> XNode -> Bool
-isErrorNode l (XError l'  _)    = l == l'
-isErrorNode _ _  = False
-
--- -----------------------------------------------------------------------------
-
-textOfXNode			:: XNode -> String
-textOfXNode (XText t)		= t
-textOfXNode _			= ""
-
--- -----------------------------------------------------------------------------
---
--- XmlTree constructors
-
--- |
--- Create a tree with a tag node.
---
---    * 1.parameter n :  the name of the tag
---
---    - 2.parameter al :  the tag attribte list
---
---    - 3.parameter cs :  the list of children
---
---    - returns : the new tree
-
-mkXTagTree		:: String -> XmlTrees -> XmlTrees -> XmlTree
-mkXTagTree n al cs	= mkNode (XTag (mkName n) al) cs
-
--- | Version with qualified name of 'mkXTagTree'
-
-mkQTagTree		:: QName -> XmlTrees -> XmlTrees -> XmlTree
-mkQTagTree q al cs	= mkNode (XTag q al) cs
-
--- |
--- create a tree with a namespace aware tag node.
---
---    * 1.parameter n :  the prefix:localpart of the tag
---
---    - 2.parameter ns:  the namespace uri
---
---    - 3.parameter al :  the tag attribte list
---
---    - 4.parameter cs :  the list of children
---
---    - returns : the new tree
---
--- see also: 'mkXTagTree'
-
-mkXNsTagTree		:: String -> String -> XmlTrees -> XmlTrees -> XmlTree
-mkXNsTagTree n ns al cs	= mkNode (XTag (mkNsName n ns) al) cs
-
--- |
--- creates a new document tree with empty contents.
---
---   * 1.parameter al : the attribute list for the root node
---
--- returns a single node tree with tag name \"\/\" indicating a root and
--- with empty list of children
---
--- see also : 'emptyRoot'
-
-newRoot			:: XmlTrees -> XmlTree
-newRoot al		= mkXTagTree t_root al []
-
--- | the empty document tree
---
--- see also : 'newRoot'
-
-emptyRoot		:: XmlTree
-emptyRoot		= newRoot []
-
--- |
--- create a new empty document with source name as parameter
-
-newDocument		:: String -> XmlTree
-newDocument n
-    = newDocument' [(a_source, n), (a_status, show c_ok)]
-
--- |
--- create a new empty document with a list of attributes for source location and options
---
--- see also : 'newDocument'
-
-newDocument'		:: Attributes -> XmlTree
-newDocument' al
-    = newRoot (fromAttrl al)
-
--- |
--- create a document root tree.
---
---    * 1.parameter al :  the attribute list for the root. This list must contain at
---		  least an attribute \"source\" that contains the URI of the document to be processed
---
---    - 2.parameter cs :  the list for the document content
---
---    - returns : the document root
-
-mkRootTree		:: XmlTrees -> XmlTrees -> XmlTree
-mkRootTree al cs	= mkXTagTree t_root al cs
-
--- |
--- create a leaf for a text element.
---
---    * 1.parameter txt :  the text
---
---    - returns : the tree with the single node containing the text
-
-mkXTextTree		:: String -> XmlTree
-mkXTextTree s		= mkLeaf (XText s)
-
--- |
--- create a leaf for a char reference.
---
---    * 1.parameter i :  the integer representing the Unicode char
---
---    - returns : the tree with the single node containing the char reference
-
-mkXCharRefTree		:: Int -> XmlTree
-mkXCharRefTree s	= mkLeaf (XCharRef s)
-
--- |
--- create a leaf for an entity reference.
---
---    * 1.parameter n :  the name of the entity reference
---
---    - returns : the tree with the single node containing the entity reference
-
-mkXEntityRefTree	:: String -> XmlTree
-mkXEntityRefTree s	= mkLeaf (XEntityRef s)
-
--- |
--- create a leaf for a comment,
---
---    * 1.parameter c :  the comment text
---
---    - returns : the tree with the single node containing the comment
-
-mkXCmtTree		:: String -> XmlTree
-mkXCmtTree c		= mkLeaf (XCmt c)
-
--- |
--- create a tree for a part of a DTD
---
---    * 1.parameter d :  the type of the DTD part
---
---    - 2.parameter al :  the attribute list for the DTD part
---
---    - 3.parameter ds :  the possibly empty list of components for the DTD part
---
---    - returns : the tree with the composed DTD part
-
-mkXDTDTree		:: DTDElem -> Attributes -> XmlTrees -> XmlTree
-mkXDTDTree d al	ds	= mkNode (XDTD d al) ds
-
-
--- |
--- create an attribute tree as part of a tag attribute list of tag nodes
---
---    * 1.parameter al : the attribute name
---
---    - 2.parameter av : the attribute value as tree list, usually containing a single text node
-
-mkXAttrTree		:: String -> XmlTrees -> XmlTree
-mkXAttrTree an av	= mkNode (XAttr (mkName an)) av
-
--- | Qualified version of 'mkXAttrTree'
-
-mkQAttrTree		:: QName -> XmlTrees -> XmlTree
-mkQAttrTree aq av	= mkNode (XAttr aq) av
-
-
--- |
--- create an attribute tree with a namespace
---
---    * 1.parameter al : the attribute name
---
---    - 2.parameter ns : namespace uri
---
---    - 3.parameter av : the attribute value as tree list, usually containing a single text node
---
--- see also: 'mkXAttrTree', 'mkXNsTagTree'
-
-mkXNsAttrTree		:: String -> String -> XmlTrees -> XmlTree
-mkXNsAttrTree an ns av	= mkNode (XAttr (mkNsName an ns)) av
-
--- |
--- create a parameter entity reference DTD part.
---
---    * 1.parameter ref :  the name of the reference
---
---    - returns : the DTD part for a PERef
-
-mkXPERefTree		:: String -> XmlTree
-mkXPERefTree ref	= mkLeaf (XDTD PEREF [(a_peref, ref)])
-
--- |
--- create a processing instruction tree.
---
---    * 1.parameter n :  the name of the PI
---
---    - 2.parameter str :  the content of a PI
---
---    - returns : the processing instruction tree with a single attribute \"value\"
---      with the str parameter as attribute value, with @valueOf a_value@ applied to the result tree
---      the content of the PI can be selected
-
-mkXPiTree	:: String -> String -> XmlTree
-mkXPiTree n str	= mkLeaf (XPi (mkName n) (xattr a_value str))
-
--- |
--- create xml declaration
-
-mkXmlDeclTree	:: XmlTrees -> XmlTree
-mkXmlDeclTree al = mkLeaf (XPi (mkName t_xml) al)
-
--- |
--- create a CDATA section tree.
---
---    * 1.parameter s :  the content of the CDATA section
---
---    - returns : the tree for the CDATA section
-
-mkXCdataTree		:: String -> XmlTree
-mkXCdataTree s		= mkLeaf (XCdata s)
-
--- |
--- create an error tree.
---
---    * 1.parameter l :  the level of the error (warning, error fatal)
---
---    - 2.parameter msg :  the error message
---
---    - 3.parameter cs :  the context, where the error was detected
-
-mkXErrorTree		:: Int -> String -> XmlTrees -> XmlTree
-mkXErrorTree l s cs	= mkNode (XError l s) cs
-
-maybeString2XText	:: Maybe String -> XmlTrees
-maybeString2XText	= map mkXTextTree . maybeToList
-
--- ------------------------------------------------------------
---
--- text selection
-
-showXText	:: XmlTrees -> String
-showXText
-    = concatMap showT
-      where
-      showT (NTree (XText      t) _) = t
-      showT _                        = ""
-
-showXCharRef	:: XmlTrees -> String
-showXCharRef
-    = concatMap showT
-      where
-      showT (NTree (XCharRef   r) _) = "&#" ++ show r ++ ";"
-      showT _                        = ""
-
-showXEntityRef	:: XmlTrees -> String
-showXEntityRef
-    = concatMap showT
-      where
-      showT (NTree (XEntityRef r) _) = "&" ++ r ++ ";"
-      showT _                        = ""
-
-showXErrors	:: XmlTrees -> String
-showXErrors
-    = concatMap showE
-      where
-      showE (NTree (XError level str) _) = msg level ++ ": " ++ str ++ "\n"
-      showE _                            = ""
-
-      msg :: Int -> String
-      msg l
-          | l == c_warn = "Warning"
-          | l == c_err  = "Error"
-          | otherwise   = "Fatal error"
-
--- ------------------------------------------------------------
---
--- the toString conversion functions
-
--- |
--- old name for 'xshow' (deprecated)
-
-xmlTreesToString	:: XmlTrees -> String
-xmlTreesToString	= xshow
-
--- |
--- conversion of a filter result into a text node
---
--- see also : 'xshow'
-
-xmlTreesToText		:: XmlSFilter
-xmlTreesToText ts@[(NTree (XText _) _)]	= ts		-- special case optimisation
-xmlTreesToText ts@[]			= ts
-xmlTreesToText ts			= xtext . xshow $ ts
-
--- ------------------------------------------------------------
-
-xmlContentModelToString	:: XmlTree -> String
-xmlContentModelToString (NTree (XDTD ELEMENT al) cs)
-    = showElemType (lookup1 a_type al) cs ""
-
-xmlContentModelToString _
-    = ""
-
--- -----------------------------------------------------------------------------
---
--- string access functions
-
--- |
--- select the name of a node. For tags, attributes and pi\'s the name string
--- is returned, else the empty string.
-
-nameOf				:: XmlTree -> String
-nameOf
-    = selName . getNode
-      where
-      selName (XTag  n _)	= qualifiedName n
-      selName (XAttr n  )	= qualifiedName n
-      selName (XPi   n _)	= qualifiedName n
-      selName _			= ""
-
--- |
--- select the local part of a name of a node. For tags, attributes the name string
--- is returned, for pi's the whole name, else the empty string.
-
-localPartOf				:: XmlTree -> String
-localPartOf
-    = selName . getNode
-      where
-      selName (XTag  n _)	= localPart n
-      selName (XAttr n  )	= localPart n
-      selName (XPi   n _)	= qualifiedName n
-      selName _			= ""
-
--- |
--- select the namespace URI of a tag or an attribute tree, else the empty string is returned
--- see also : 'nameOf'
-
-namespaceOf				:: XmlTree -> String
-namespaceOf
-    = selName . getNode
-      where
-      selName (XTag n _)	= namespaceUri n
-      selName (XAttr n )	= namespaceUri n
-      selName _			= ""
-
--- |
--- select the namespace prefix of a tag or an attribute tree, else the empty string is returned
--- see also : 'nameOf', 'localPartOf'
-
-prefixOf				:: XmlTree -> String
-prefixOf
-    = selName . getNode
-      where
-      selName (XTag n _)	= namePrefix n
-      selName (XAttr n )	= namePrefix n
-      selName _			= ""
-
--- |
--- select the universal name (namespace uri ++ localPart) of a tag or an attribute tree, else the empty string is returned
--- see also : 'nameOf', 'namespaceOf'
-
-universalNameOf				:: XmlTree -> String
-universalNameOf
-    = selName . getNode
-      where
-      selName (XTag n _)	= universalName n
-      selName (XAttr n )	= universalName n
-      selName _			= ""
-
--- |
--- select the attributes of a dtd tree
-
-attrlOfDTD				:: XmlTree -> Attributes
-attrlOfDTD (NTree (XDTD _ al) _)	= al
-attrlOfDTD _				= []
-
-
--- |
--- select a special attribute of a DTD part
-
-valueOfDTD		:: String -> XmlTree -> String
-valueOfDTD n		= lookup1 n . attrlOfDTD
-
--- |
--- test an attribute of a DTD part
-
-ofDTDequals	:: String -> String -> XmlTree -> Bool
-ofDTDequals n v	= (== v) . valueOfDTD n
-
--- -----------------------------------------------------------------------------
---
--- convenient functions
-
-xcmt		:: String -> XmlTrees
-xcmt cmt	= [ mkXCmtTree cmt ]
-
-xerr		:: String -> XmlTrees
-xerr msg	= [ mkXErrorTree c_err msg []]
-
-xwarn		:: String -> XmlTrees
-xwarn msg	= [ mkXErrorTree c_warn msg []]
-
-xtext		:: String -> XmlTrees
-xtext t		= [ mkXTextTree t]
-
-xtag		:: String -> XmlTrees -> XmlTrees -> XmlTrees
-xtag t al cl	= [ mkXTagTree t al cl ]
-
-xattr		:: String -> String -> XmlTrees
-xattr n v	= [ mkXAttrTree n (xtext v) ]
-
--- -----------------------------------------------------------------------------
---
--- conversion functions: XmlTrees <-> Attributes
-
-toTreel		:: XmlTrees -> AssocList String XmlTrees
-toTreel
-    = concatMap toTree
-      where
-      toTree (NTree (XAttr n) cs) = [(qualifiedName n, cs)]
-      toTree _			  = []
-
-toAttrl		:: XmlTrees -> Attributes
-toAttrl
-    = map (\ (k,tl) -> (k, xshow tl)) . toTreel
-
-
-fromTreel	:: AssocList String XmlTrees -> XmlTrees
-fromTreel
-    = map (\ (k,tl) -> mkXAttrTree k tl)
-
-fromAttrl	:: Attributes -> XmlTrees
-fromAttrl
-    = fromTreel . map (\ (k,v) -> (k, xtext v))
-
--- -----------------------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTreeTypes.html b/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTreeTypes.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-DOM-XmlTreeTypes.html +++ /dev/null @@ -1,87 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- exports the core data types
--- and some additional types and functions
--- for compatibility with none arrow modules
---
--- Version : $Id: XmlTreeTypes.hs,v 1.6 2006/05/09 15:30:43 hxml Exp $
-
-module Text.XML.HXT.DOM.XmlTreeTypes
-    ( module Data.Tree.NTree.Filter
-    , module Text.XML.HXT.DOM.TypeDefs
-    , module Text.XML.HXT.DOM.XmlTreeTypes
-    )
-
-where
-
-import Data.Tree.NTree.Filter
-import Text.XML.HXT.DOM.TypeDefs
-
--- aliases for compatiblility reasons
-
-mkNode		:: node -> NTrees node -> NTree node
-mkNode		= mkTree
-
-formatNTree	:: (node -> String) -> NTree node -> String
-formatNTree	= formatTree
-
-foldNTree	:: (a -> [b] -> b) -> NTree a -> b
-foldNTree 	= foldTree
-
-mapNTree	:: (a -> b) -> NTree a -> NTree b
-mapNTree 	= fmap
-
-nTreeToList	:: NTree a -> [a]
-nTreeToList	= nodesTree
-
-depthNTree	:: NTree a -> Int
-depthNTree	= depthTree
-
-cardNTree	:: NTree a -> Int
-cardNTree	= cardNTree
-
--- -----------------------------------------------------------------------------
---
--- Basic types for filters
-
--- | A functions that takes a node and returns a list of nodes
-
-type XmlFilter	= TFilter  XNode
-
--- | A function that takes a list of nodes and returns a list of nodes
-
-type XmlSFilter	= TSFilter XNode
-
-
--- -----------------------------------------------------------------------------
---
-
--- | Tag name
-type TagName	= QName
-
--- | Attribute name
-type AttrName	= QName
-
--- -----------------------------------------------------------------------------
-
--- | shortcut for 'qualifiedName'
-
-tName	:: QName -> String
-tName	= qualifiedName
-
--- | shortcut for 'qualifiedName'
-
-aName	:: QName -> String
-aName	= qualifiedName
-
--- -----------------------------------------------------------------------------
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-DOM.html b/doc/hxt-filter/src/Text-XML-HXT-DOM.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-DOM.html +++ /dev/null @@ -1,34 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- DOM data types and functions
---
--- export of all basic datatypes and functions of the toolbox DOM.
-
-module Text.XML.HXT.DOM
-    ( module Text.XML.HXT.DOM.XmlTree
-    , module Text.XML.HXT.DOM.XmlState
-    , module Text.XML.HXT.DOM.EditFilters
-    , module Text.XML.HXT.DOM.FormatXmlTree
-    , module Text.XML.HXT.DOM.Namespace
-    , module Text.XML.HXT.DOM.XmlOptions
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-import Text.XML.HXT.DOM.XmlState
-import Text.XML.HXT.DOM.EditFilters
-import Text.XML.HXT.DOM.FormatXmlTree
-import Text.XML.HXT.DOM.Namespace
-import Text.XML.HXT.DOM.XmlOptions
-
--- ------------------------------------------------------------
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-DTDProcessing.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-DTDProcessing.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-DTDProcessing.html +++ /dev/null @@ -1,941 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
-
-{- |
-   Module     : Text.XML.HXT.Parser.DTDProcessing
-   Copyright  : Copyright (C) 2005 Uwe Schmidt
-   License    : MIT
-
-   Maintainer : Uwe Schmidt (uwe@fh-wedel.de)
-   Stability  : experimental
-   Portability: portable
-
-   DTD processing function for
-   including external parts of a DTD
-   parameter entity substitution and general entity substitution
-
--}
-
--- ------------------------------------------------------------
-
-module Text.XML.HXT.Parser.DTDProcessing
-    ( getWellformedDoc
-    , checkWellformedDoc
-    , processDTD
-    , processGeneralEntities
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.Parser.XmlOutput
-    ( traceTree
-    , traceSource
-    , traceMsg
-    )
-
-import Text.XML.HXT.Parser.XmlParser
-    ( parseXmlDoc
-    , parseXmlDTDPart
-    , parseXmlAttrValue
-    , parseXmlGeneralEntityValue
-    )
-
-import Text.XML.HXT.Parser.XmlDTDParser
-    ( parseXmlDTDdecl
-    , parseXmlDTDdeclPart
-    , parseXmlDTDEntityValue
-    )
-
-import Text.XML.HXT.Parser.XmlInput
-    ( getXmlContents
-    , getXmlEntityContents
-    , runInLocalURIContext
-    , runInNewURIContext
-    , getBaseURI
-    , setBaseURI
-    , getAbsolutURI
-    , isStandaloneDocument
-    )
-
-import Text.XML.HXT.DOM.EditFilters
-    ( transfCharRef
-    , transfAllCharRef
-    )
-
-import Text.XML.HXT.DOM.XmlState
-
-import Data.Maybe
-
-import qualified Data.Map as M
-    ( Map
-    , empty
-    , lookup
-    , insert
-    -- , foldWithKey
-    )
-
--- ------------------------------------------------------------
---
--- the "main" building blocks
-
--- |
--- monadic filter for reading, parsing and checking a wellformed document.
--- the input tree must consist of a root node with a source attribute
--- in its attribute list.
---
--- All attributes from the document root are copied into the system state,
--- and may be queried by the monadic filters, e.g. trace options.
---
--- Result is the single element list containing the well-formed document tree
--- or, in case of errors, the document root with an empty list as children
--- and attributes 'a_status' and 'a_module' for error level and the module,
--- where the error occured.
---
--- this is a shortcut for 'getXmlContents' .\>\> 'checkWellformedDoc'
---
--- example for a main program:
---
--- @
--- main =
---   run\' \$
---   do
---   res  \<- getWellformedDoc \$ newDocument \"myfile.xml\"
---   ...
--- @
-
-getWellformedDoc	:: XmlStateFilter state
-getWellformedDoc
-    = setSystemParams
-      .>>
-      getXmlContents
-      .>>
-      checkWellformedDoc
-
--- |
--- parses a text node with 'parseXmlDoc', processes the DTD and general entities
--- and transforms all char references into characters
-
-checkWellformedDoc		:: XmlStateFilter state
-checkWellformedDoc
-    = parseXmlDoc
-      .>>
-      processDTD
-      .>>
-      processGeneralEntities
-      .>>
-      liftMf transfAllCharRef
-
--- ------------------------------------------------------------
---
-
-type RecList		= [String]
-
-type DTDState res	= XState PeEnv res
-
-type DTDStateFilter	= XmlTree -> DTDState XmlTrees
-
-data DTDPart		= Internal
-			| External
-			  deriving (Eq)
-
--- ------------------------------------------------------------
-
-type PeEnv		= M.Map String XmlTree
-
-emptyPeEnv	:: PeEnv
-emptyPeEnv	= M.empty
-
-lookupPeEnv	:: String -> PeEnv -> Maybe XmlTree
-lookupPeEnv	= M.lookup
-
-addPeEntry	:: String -> XmlTree -> PeEnv -> PeEnv
-addPeEntry	= M.insert
-
--- ------------------------------------------------------------
-
--- |
--- a filter for DTD processing
---
--- inclusion of external parts of DTD,
--- parameter entity substitution
--- conditional section evaluation
---
--- input tree must represent a complete document including root node
-
-processDTD		:: XmlStateFilter a
-processDTD
-    = runInLocalURIContext
-         ( processRoot
-	   .>>
-	   traceTree
-	   .>>
-	   traceSource
-	 )
-      `whenM` ( isRoot .> getChildren )
-      where
-
-      processRoot	:: XmlStateFilter a
-      processRoot t
-	  = do
-	    sequence_ . map (\ (a, ts) -> setSysParamTree a ts) . toTreel . getAttrl $ t
-	    setSysParam a_standalone ""
-	    ( traceMsg 1 ("processDTD: process parameter entities")
-	      .>>
-	      liftMf (modifyChildren addDoctype)
-	      .>>
-	      processChildrenM substParamEntities
-	      .>>
-	      checkResult "in XML DTD processing"
-	      ) `whenM` statusOk
-	      $ t
-
-      -- Adds an empty DOCTYPE node to document. Needed for documents without a DTD.
-      -- Otherwise processor can not substitute predefined entities. If an xml declaration
-      -- is present, the node is inserted after this node.
-      addDoctype :: XmlSFilter
-      addDoctype docChilds
-          = if null doctype
-            then if null xmlDecl
-                 then [mkXDTDTree DOCTYPE [] []] ++ docChilds
-                 else (head docChilds) : [mkXDTDTree DOCTYPE [] []] ++ (tail docChilds)
-            else docChilds
-            where
-            doctype = isDoctype $$ docChilds
-            xmlDecl = isPi t_xml $$ isXPi $$ docChilds
-
-
-substParamEntities	:: XmlStateFilter a
-substParamEntities
-    = processParamEntities
-      `whenM`
-      isDoctype
-      where
-
-      processParamEntities	:: XmlStateFilter a
-      processParamEntities t'
-	  = do
-	    (dtdPre, envPre) <- processPredef
-
-	    -- process internal part of DTD with initial empty env for parameter entities
-	    (dtdInt, envInt) <- processInt envPre t'
-
-	    -- process external part of DTD with resulting env from internal DTD
-	    dtdExt <- runInLocalURIContext (processExt envInt) t'
-
-	    -- merge predefined, internal and external part
-	    trace 2 "substParamEntities: merge internal and external DTD parts"
-	    return (replaceChildren (foldl1 mergeDTDs [dtdPre, dtdInt, dtdExt]) t')
-
-      processPredef
-	  = do
-	    trace 2 "substParamEntities: substitute predefined entities"
-	    chain' emptyPeEnv (substParamEntity Internal $$< predefDTDPart)
-
-      processInt env' n'
-	  = do
-	    trace 2 "substParamEntities: substitute parameter entities in internal DTD part"
-	    chain' env' (substParamEntity Internal $$< getChildren n')
-
-      processExt env' n'
-	  = do
-	    trace 2 "substParamEntities: process external part of DTD"
-            extDtd <- processExternalDTD n'
-	    trace 2 "substParamEntities: substitute parameter entities in external DTD part"
-	    chain env' ( (substParamEntity External) $$< extDtd)
-
--- ------------------------------------------------------------
--- |
--- substitute parameter entities
--- result is the input tree with the list of text nodes as children or an error message
-
-substPEref'	:: DTDPart -> PeEnv -> XmlFilter
-
-substPEref' loc env n@(NTree (XDTD PEREF al) _)
-    | isInternalRef	= xerr ("a parameter entity reference of " ++ peName' ++ " occurs in the internal subset of the DTD")
-
-    | isUndefinedRef	= xerr ("parameter entity " ++ peName' ++ " not found (forward reference?)")
-
-    | null baseUri	= [setChildren peContent n]
-
-    | otherwise		= [(NTree (XDTD PEREF ((a_url,baseUri):al)) peContent)]
-    where
-    peName		= lookup1 a_peref al
-    peName'		= show peName
-    peVal		= lookupPeEnv peName env
-    isInternalRef	= loc == Internal
-    isUndefinedRef	= isNothing peVal
-
-    (NTree (XDTD PENTITY peAl) peContent) = fromJust peVal
-    baseUri		= lookup1 a_url peAl
-
-    -- peContent		= getChildren $ fromJust peVal
-
-substPEref' _ _ n
-    = [n]
-
--- ------------------------------------------------------------
-
-{-
-dumpPE	:: DTDStateFilter
-dumpPE t
-    = do
-      env <- getState
-      ( traceMsg 2 ("dumpPE: parameter entity environment\n" ++ M.foldWithKey showPE "" env)
-	.>>
-	thisM ) t
-    where
-    showPE k v b = k ++ "\t" ++ show v ++ "\n" ++ b
--}
-
-traceDTD	:: String -> XmlStateFilter a
-traceDTD msg	= traceMsg 4 msg .>> traceTree
-
--- ------------------------------------------------------------
-
-getExternalParamEntityValue	:: DTDStateFilter
-getExternalParamEntityValue n@(NTree (XDTD PENTITY al) _cl)
-    = do
-      rl <- ( getXmlEntityContents
-	      .>>
-	      liftMf getChildren
-	    )
-	    $ newDocument' ((a_source, sysVal) : al)
-      base <- getBaseURI
-      if null rl
-	 then issueErr ("illegal external parameter entity value for entity %" ++ peName ++";") n
-	 else thisM (NTree (XDTD PENTITY ((a_url, base) : al)) rl)
-    where
-    sysVal = lookup1 k_system al
-    peName = lookup1 a_name   al
-
-getExternalParamEntityValue n
-    = error ("getExternalParamEntityValue: illegal argument: " ++ show n)
-
--- ------------------------------------------------------------
-
--- |
--- the dtd parameter entity substitution filter
-
-substParamEntity	:: DTDPart -> DTDStateFilter
-
-substParamEntity loc n@(NTree xn _cs)
-    | isDTDElemNode ENTITY xn					-- ENITITY and parameter ENTITY decl
-	= traceDTD ("ENTITY declaration before DTD declaration parsing")
-	  .>>
-	  processChildrenM (substPeRefsInDTDdecl [])
-          .>>
-	  liftF parseXmlDTDdecl
-          .>>
-	  substRefsInEntityValue
-          .>>
-	  processEntityDecl
-          .>>
-          traceDTD ("ENTITY declaration after DTD declaration parsing")
-          $ n
-
-    | isDTDElemNode PEREF xn					-- parameter entity ref in DTD
-	= substPeRefsInDTDpart [] n
-
-    | isDTDElemNode ELEMENT xn					-- ELEMENT, ATTLIST, NOTATION
-      ||
-      isDTDElemNode ATTLIST xn
-      ||
-      isDTDElemNode NOTATION xn
-	= traceDTD  "DTD declaration before PE substitution"
-	  .>>
-	  processChildrenM (substPeRefsInDTDdecl [])
-          .>>
-	  liftF parseXmlDTDdecl
-          .>>
-	  traceDTD "DTD declaration after DTD declaration parsing"
-	  $ n
-
-    | isDTDElemNode CONDSECT xn					-- conditional section
-      &&
-      loc == Internal
-	  = do
-	    issueErr "conditional sections in internal part of the DTD is not allowed" n
-            return []
-
-    | isDTDElemNode CONDSECT xn					-- conditional section
-      &&
-      loc == External
-	  = let
-	    (XDTD _ al) = xn
-	    content	= mkXTextTree (lookup1 a_value al)
-	    in
-	    traceDTD "substParamEntity: process conditional section"
-	    .>>
-	    processChildrenM (substPeRefsInCondSect [])
-            .>>
-	    liftF parseXmlDTDdecl
-	    .>>
-            evalCond content
-	    $ n
-
-    | isXCmtNode xn						-- remove comments
-	= noneM n
-
-    | otherwise							-- default: keep things unchanged (should not occur)
-	= thisM n
-    where
-
-    processEntityDecl	:: DTDStateFilter
-    processEntityDecl n'@(NTree (XDTD ENTITY al) cs)	= if isExtern
-	  then ( do
-		 url <- getAbsolutURI sysVal			-- add the absolute URI
-		 return [NTree (XDTD ENTITY ((a_url, url) : al)) cs]
-	       )
-	  else liftMf (substChildren (xmlTreesToText . getChildren)) n'
-	where
-	isExtern = hasEntry k_system al
-	sysVal   = lookup1  k_system al
-      
-    processEntityDecl n'@(NTree (XDTD PENTITY al) _)
-	= do
-	  env <- getState
-	  if (isJust . lookupPeEnv peName) $ env
-	     then
-	     issueWarn ("parameter entity " ++ show peName ++ " already defined") n
-	     else
-	     ( ifM isExternalParameterEntity
-	           ( runInLocalURIContext getExternalParamEntityValue )
-                   ( liftMf (substChildren (xmlTreesToText . getChildren)) )
-	       .>>
-	       addPE peName
-	     ) n'
-	  where
-	  peName = lookup1 a_name al
-
-    processEntityDecl n'
-	= error ("processEntityDecl called with wrong argument" ++ show n')
-
-    addPE	:: String -> DTDStateFilter
-    addPE name t
-	= do
-	  trace 2 ("substParamEntity: add entity to env: " ++ xshow [t])
-	  changeState $ addPeEntry name t
-	  return []
-
-    substPEref	:: DTDStateFilter
-    substPEref n'
-	= do
-	  env <- getState
-	  liftF (substPEref' loc env) $ n'
-
-    substPeRefsInValue	:: [String] -> DTDStateFilter
-    substPeRefsInValue recList n'@(NTree (XDTD PEREF al) _cl)
-	= ( if peName `elem` recList
-	    then issueErr ("recursive call of parameter entity " ++ show peName ++ " in entity value")
-	    else ( substPEref
-		   .>>
-		   liftF parseXmlDTDEntityValue
-		   .>>
-		   liftF transfCharRef
-		   .>>
-		   ( substPeRefsInValue (peName : recList)
-		     `whenM`
-		     isPeRef
-		   )
-		 )
-	  ) $ n'
-	where
-	peName = lookup1 a_peref al
-
-    substPeRefsInValue _ n'
-	= thisM n'
-
-    substRefsInEntityValue	:: DTDStateFilter
-    substRefsInEntityValue n'@(NTree (XDTD decl al) _cl)
-	| decl `elem` [ENTITY, PENTITY]
-	    = ( if hasEntry k_system al
-		then thisM							-- externals not yet handled ??? really
-		else processChildrenM ( liftF transfCharRef
-					.>>
-					substPeRefsInValue []
-				      )
-	      ) n'
-    substRefsInEntityValue  n'
-	= error ("substRefsInEntityValue called with wrong argument" ++ show n')
-
-    runInPeContext	:: DTDStateFilter -> DTDStateFilter
-    runInPeContext f n'@(NTree (XDTD PEREF al) _)
-	| null base
-	    = f n'
-	| otherwise
-	    = runInNewURIContext base f n'
-	where
-	base = lookup1 a_url al
-
-    runInPeContext f n'
-	= f n'
-
-    substPeRefsInDTDdecl	:: [String] -> DTDStateFilter
-    substPeRefsInDTDdecl recList n'@(NTree (XDTD PEREF al) _cl)
-	= ( if peName `elem` recList
-	    then issueErr ("recursive call of parameter entity " ++ show peName ++ " in DTD declaration")
-	    else ( substPEref
-		   .>>
-		   traceDTD "substPeRefsInDTDdecl: parseXmlDTDdeclPart"
-		   .>>
-		   ( runInPeContext
-		     ( liftF ( parseXmlDTDdeclPart )
-		       .>>
-		       traceDTD "substPeRefsInDTDdecl: after parseXmlDTDdeclPart"
-		       .>>
-		       processChildrenM ( substPeRefsInDTDdecl (peName : recList) )
-		     )
-		     `whenM`
-		     isPeRef
-		   )
-		 )
-	  ) $ n'
-	where
-	peName = lookup1 a_peref al
-
-    substPeRefsInDTDdecl _ n'
-	= thisM n'
-
-    substPeRefsInDTDpart	:: [String] -> DTDStateFilter
-    substPeRefsInDTDpart recList n'@(NTree (XDTD PEREF al) _cl)
-	= ( if peName `elem` recList
-	    then issueErr ("recursive call of parameter entity " ++ show peName ++ " in DTD part")
-	    else ( substPEref
-		   .>>
-		   traceDTD "substPeRefsInDTDpart: parseXmlDTDPart"
-		   .>>
-		   runInPeContext
-		   ( liftF (getChildren .> parseXmlDTDPart ("parameter entity " ++ show peName))
-		     .>>
-		     traceDTD "substPeRefsInDTDdecl: after parseXmlDTDPart"
-		     .>>
-		     substParamEntity loc -- cyclic check not yet done (peName : recList)
-		   )
-		 )
-	  ) $ n'
-	where
-	peName = lookup1 a_peref al
-
-    substPeRefsInDTDpart _ n'
-	= thisM n'
-
-    substPeRefsInCondSect	:: [String] -> DTDStateFilter
-    substPeRefsInCondSect recList n'@(NTree (XDTD PEREF al) _cl)
-	= ( if peName `elem` recList
-	    then issueErr ("recursive call of parameter entity " ++ show peName ++ " in conditional section")
-	    else ( substPEref
-		   .>>
-		   traceDTD "substPeRefsInCondSect: parseXmlDTDdeclPart"
-		   .>>
-		   ( runInPeContext
-		     ( liftF ( parseXmlDTDdeclPart )
-		       .>>
-		       traceDTD "substPeRefsInCondSect: after parseXmlDTDdeclPart"
-		       .>>
-		       processChildrenM ( substPeRefsInCondSect (peName : recList) )
-		     )
-		     `whenM`
-		     isPeRef
-		   )
-		 )
-	  ) $ n'
-	where
-	peName = lookup1 a_peref al
-
-    substPeRefsInCondSect _ n'
-	= thisM n'
-
-
-evalCond :: XmlTree -> DTDStateFilter
-evalCond content (NTree n _)
-    | c == k_include
-	= liftF (parseXmlDTDPart "conditional section")
-	  .>>
-	  traceDTD "evalCond: DTD part"
-	  .>>
-	  substParamEntity External
-          $ content 
-    | otherwise
-	= return []
-    where
-    c = textOfXNode n
-
--- ------------------------------------------------------------
-
-processExternalDTD	:: XmlStateFilter a
-processExternalDTD n@(NTree (XDTD DOCTYPE al) _dtd)
-    | null sysVal
-	= return []
-    | otherwise
-	= do
-	  checkStandalone
-	  dtdContent <- ( getXmlEntityContents
-			  .>>
-			  traceMsg 2 ("processExternalDTD: parsing DTD part for " ++ show sysVal)
-			  .>>
-			  liftMf getChildren
-			  .>>
-			  liftF (parseXmlDTDPart sysVal)
-			)
-		       $ newDocument sysVal
-	  trace 2 "processExternalDTD: parsing DTD part done"
-	  traceTree $ mkRootTree [] dtdContent
-	  return dtdContent
-    where
-    sysVal		= lookup1 k_system al
-    checkStandalone	= do
-			  _isAlone <- isStandaloneDocument
-			  if False -- isAlone
-			     then issueErr ("external DTD " ++ show sysVal ++ " specified for standalone document") n
-			     else return []
-
-processExternalDTD  _
-    = return []
-
--- ------------------------------------------------------------
--- |
--- merge the external and the internal part of a DTD into one internal part.
--- parameter entity substitution should be made before applying this filter
--- internal definitions shadow external ones
---
---
--- preliminary: no real merge is done
-
-mergeDTDs	:: XmlTrees -> XmlTrees -> XmlTrees
-mergeDTDs dtdInt dtdExt
-    = dtdInt ++ (mergeDTDentry dtdInt $$ dtdExt)
-
-mergeDTDentry	:: XmlTrees -> XmlFilter
-mergeDTDentry dtdPart
-    = none `when` found
-      where
-      filterList = map filterDTDNode dtdPart	-- construct the list of filters
-      found      = cat filterList		-- concatenate the filters (set union)
-
-
-filterDTDNode	:: XmlTree -> XmlFilter
-
-filterDTDNode (NTree (XDTD dtdElem al) _)
-    | dtdElem `elem` [ELEMENT, NOTATION, ENTITY]
-	= filterElement
-	  where
-	  filterElement n@(NTree (XDTD dtdElem' al') _cl')
-	      | dtdElem == dtdElem' &&
-		lookup a_name al' == lookup a_name al
-		  = [n]
-	      | otherwise
-		  = []
-	  filterElement _
-	      = []
-
-filterDTDNode (NTree (XDTD ATTLIST al) _)
-    = filterAttlist
-      where
-      filterAttlist n@(NTree (XDTD ATTLIST al') _cl')
-	  | lookup a_name  al' == lookup a_name  al &&
-	    lookup a_value al' == lookup a_value al
-		= [n]
-      filterAttlist _
-	  = []
-
-filterDTDNode _
-    =  none
-
--- ------------------------------------------------------------
-
-predefinedEntities	:: String
-predefinedEntities
-    = concat [ "<!ENTITY lt   '&#38;#60;'>"
-	     , "<!ENTITY gt   '&#62;'>"
-	     , "<!ENTITY amp  '&#38;#38;'>"
-	     , "<!ENTITY apos '&#39;'>"
-	     , "<!ENTITY quot '&#34;'>"
-	     ]
-
-predefDTDPart		:: XmlTrees
-predefDTDPart
-    = parseXmlDTDPart "predefined entities" $ mkXTextTree predefinedEntities
-
--- ------------------------------------------------------------
---
--- 4.4 XML Processor Treatment of General Entities and References
-
-data GeContext
-    = ReferenceInContent
-    | ReferenceInAttributeValue
-    | ReferenceInEntityValue
-    -- or OccursInAttributeValue				-- not used during substitution but during validation
-    -- or ReferenceInDTD					-- not used: syntax check detects errors
-
-type GeFct		= GeContext -> RecList -> GeStateFilter
-
-type GeState res	= XState GeEnv res
-
-type GeStateFilter	= XmlTree -> GeState XmlTrees
-
--- ------------------------------------------------------------
-
-newtype GeEnv	= GeEnv (M.Map String GeFct)
-
-emptyGeEnv	:: GeEnv
-emptyGeEnv	= GeEnv M.empty
-
-lookupGeEnv		:: String -> GeEnv -> Maybe GeFct
-lookupGeEnv k (GeEnv env)
-    = M.lookup k env
-
-addGeEntry	:: String -> GeFct -> GeEnv -> GeEnv
-addGeEntry k a (GeEnv env)
-    = GeEnv $ M.insert k a env
-
--- ------------------------------------------------------------
-
--- |
--- substitution of general entities
---
--- input: a complete document tree including root node
-
-processGeneralEntities	:: XmlStateFilter a
-processGeneralEntities
-    = ( traceMsg 1 "processGeneralEntities: collect and substitute general entities"
-	.>>
-	processEntities
-	.>>
-	checkResult "in general entity processing"
-	.>>
-	traceTree
-	.>>
-	traceSource
-      )
-      `whenM` statusOk
-      where
-      processEntities t'
-	  = do
-	    res <- chain initialEnv (processGeneralEntity ReferenceInContent [] $$< getChildren t')
-	    return $ replaceChildren res t'
-	    where
-	    initialEnv = emptyGeEnv
-
--- ------------------------------------------------------------
-
-processGeneralEntity	:: GeContext -> RecList -> GeStateFilter
-processGeneralEntity cx rl n@(NTree (XDTD DOCTYPE _) dtdPart)
-    = do
-      res <- processGeneralEntity cx rl $$< dtdPart
-      return $ replaceChildren res n
-
-processGeneralEntity cx rl n@(NTree (XDTD ENTITY al) cl)
-    | isIntern
-	= do
-	  trace 2 ("processGeneralEnity: general entity definition for " ++ show name)
-	  value <- liftF (parseXmlGeneralEntityValue ("general internal entity " ++ show name)) $ mkXTextTree (xshow cl)
-	  res   <- processGeneralEntity ReferenceInEntityValue (name:rl) $$< value
-	  insertEntity name (substInternal res)
-    | isExtern
-	= do
-	  baseUri <- getBaseURI
-	  insertEntity name (substExternalParsed1Time baseUri)
-
-    | isUnparsed
-	= do
-	  trace 2 ("processGeneralEnity: unparsed entity definition for " ++ show name)
-	  insertEntity name (substUnparsed [])
-    where
-    isUnparsed	= not isIntern && not isExtern
-    isExtern	= not isIntern && not (hasEntry k_ndata al)
-    isIntern	= not (hasEntry k_system al)
-
-    name	= lookup1 a_name   al
-    -- sysVal	= lookup1 k_system al
-    url		= lookup1 a_url    al		-- a_url contains absolut url for k_system
-    context	= addEntry a_source url al
-
-    processExternalEntityContents	:: XmlTrees -> GeState XmlTrees
-    processExternalEntityContents cl'
-	| null cl'						-- reading content did not succeed
-	    = return []
-	| null txt'						-- something weird in entity content
-	    = do
-	      issueErr ("illegal external parsed entity value for entity " ++ show name) n
-	      return []
-	| otherwise						-- o.k.: parse the contents
-	    = do
-	      res' <- liftF (parseXmlGeneralEntityValue ("external parsed entity " ++ show name)) $$< txt'
-	      ( traceSource
-		.>>
-		traceTree ) $ mkRootTree (fromAttrl context) res'
-	      return res'
-	where
-	txt' = (getChildren .> isXText) $$ cl'
-
-    insertEntity	:: String -> GeFct -> GeState XmlTrees
-    insertEntity name' fct'
-	= do
-	  geEnv' <- getState
-	  case lookupGeEnv name' geEnv' of
-	    Just _fct
-		-> do
-		   issueWarn ("entity " ++ show name ++ " already defined, repeated definition ignored") n
-		   return []
-            Nothing
-		-> do
-		   changeState $ addGeEntry name' fct' 
-		   return $ this n
-
-    -- --------
-    --
-    -- 4.4 XML Processor Treatment of Entities and References
-
-    substInternal	:: XmlTrees -> GeContext -> RecList -> GeStateFilter
-    substInternal nl ReferenceInContent rl' _n'
-	= included nl rl'
-
-    substInternal nl ReferenceInAttributeValue rl' _n'
-	= includedInLiteral nl rl'
-
-    substInternal _nl ReferenceInEntityValue _rl n'
-	= bypassed n'
-
-    -- --------
-
-    substExternalParsed1Time	:: String -> GeContext -> RecList -> GeStateFilter
-    substExternalParsed1Time baseUri' cx' rl' n'
-	= do
-	  trace 2 ("substExternalParsed1Time: read and parse external parsed entity " ++ show name)
-	  res  <- runInLocalURIContext getContents' $ newDocument' context
-	  changeState $ addGeEntry name (substExternalParsed res)
-	  substExternalParsed res cx' rl' n' 
-	  where
-	  getContents'	:: GeStateFilter
-	  getContents' t''
-	      = do
-		setBaseURI baseUri'
-		rs' <- getXmlEntityContents t''
-		processExternalEntityContents rs'
-
-
-    substExternalParsed	:: XmlTrees -> GeContext -> RecList -> GeStateFilter
-    substExternalParsed  nl ReferenceInContent rl' _n'
-	= includedIfValidating nl rl'
-
-    substExternalParsed _nl ReferenceInAttributeValue _rl _n'
-	= forbidden "external parsed general" "in attribute value"
-
-    substExternalParsed _nl ReferenceInEntityValue _rl n'
-	= bypassed n'
-
-    -- --------
-
-    substUnparsed	:: XmlTrees -> GeContext -> RecList -> GeStateFilter
-    substUnparsed _nl ReferenceInContent _rl _n'
-	= forbidden "unparsed" "content"
-    substUnparsed _nl ReferenceInAttributeValue _rl _n'
-	= forbidden "unparsed" "attribute value"
-    substUnparsed _nl ReferenceInEntityValue _rl _n'
-	= forbidden "unparsed" "entity value"
-
-    -- --------
-							-- see XML 1.0 chapter:
-
-    included nl	rl'					-- 4.4.2
-	= processGeneralEntity cx (name:rl') $$< nl
-
-    includedIfValidating				-- 4.4.3
-	= included
-
-    includedInLiteral					-- 4.4.5
-	= included
-
-    bypassed n'						-- 4.4.7
-	= return $ this n'
-
-    forbidden msg' cx'					-- 4.4.4
-	= do
-	  issueErr ("reference of " ++ msg' ++ show name ++ " forbidden in " ++ cx') n
-          return []
-
-							-- normalize default value in ATTLIST
-processGeneralEntity _cx rl n@(NTree (XDTD ATTLIST al) _cl)
-    | hasDefaultValue
-	= do
-	  res <- ( liftF (parseXmlAttrValue "default value of attribute ")
-                   .>>
-		   substGeneralEntityInAValue rl
-		 ) $ mkXTextTree defaultValue
-	  return $ addDTDAttr a_default (xshow res) n
-    | otherwise
-	= return $ this n
-    where
-    hasDefaultValue = hasEntry  a_default al
-    defaultValue    = lookup1   a_default al
-
-processGeneralEntity cx rl n@(NTree (XEntityRef name) _)
-    = do
-      trace 2 ("processGeneralEnity: entity reference for entity " ++ show name)
-      trace 3 ("recursion list = " ++ show rl)
-      geEnv <- getState
-      case lookupGeEnv name geEnv of
-        Just fct
-	  -> if name `elem` rl
-	     then do
-		  issueErr ("recursive substitution of general entity reference " ++ show ref ++ " not processed") n
-		  return nl
-	     else do
-		  fct cx rl n
-        Nothing
-	  -> do
-	     issueErr ("general entity reference " ++ show ref ++ " not processed, no definition found, (forward reference?)") n
-	     return nl
-      where
-      nl  = this n
-      ref = xshow nl
-
-
-processGeneralEntity cx rl n@(NTree (XTag _tagName al) cl)
-    = do
-      al' <- substGeneralEntityInAttr rl $$< al
-      cl' <- processGeneralEntity cx rl  $$< cl
-      return $ (replaceAttrl al' .> replaceChildren cl') n
-
-processGeneralEntity _cx _rl n
-    = return $ this n
-
--- ------------------------------------------------------------
-
-substGeneralEntityInAttr	:: RecList -> XmlTree -> GeState XmlTrees
-substGeneralEntityInAttr rl a@(NTree (XAttr _) aValue)
-    = do
-      nv <- substGeneralEntityInAValue rl $$< aValue
-      return (replaceChildren nv a)
-
-substGeneralEntityInAttr _ _
-    = return []
-
-substGeneralEntityInAValue	:: RecList -> GeStateFilter
-substGeneralEntityInAValue rl
-    = ( processGeneralEntity ReferenceInAttributeValue rl
-	`whenM`
-	isXEntityRef
-      )
-      .>>
-      liftMf ( ( modifyText normalizeWhiteSpace `when` isXText)
-	      .>
-	      (transfCharRef `when` isXCharRef)
-	    )
-      where
-      normalizeWhiteSpace
-	  = map ( \c -> if c `elem` "\n\t\r" then ' ' else c )
-
--- ------------------------------------------------------------
-
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-DefaultURI.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-DefaultURI.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-DefaultURI.html +++ /dev/null @@ -1,57 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
---
--- defaut uri computation
--- this routine is platform dependent
--- and must be exchanged when porting the toolbox e.g. to windows
-
-module Text.XML.HXT.Parser.DefaultURI
-    ( setDefaultURI
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.DOM.XmlState
-
-import System.Directory
-    ( getCurrentDirectory
-    )
-
-import Network.URI
-    ( escapeURIChar
-    , isUnescapedInURI
-    )
-
-setDefaultURI   :: XState state ()
-setDefaultURI
-     = do
-       wd <- io getCurrentDirectory
-       setSysParam transferDefaultURI ("file://" ++ normalize wd ++ "/")
-
-       where
-
-       -- under Windows getCurrentDirectory returns something like: "c:\path\to\file"
-       -- backslaches are not allowed in URIs and paths must start with a /
-       -- so this is transformed into "/c:/path/to/file"
-
-       normalize wd'@(d : ':' : _)
-	   | d `elem` ['A'..'Z'] || d `elem` ['a'..'z']
-	       = '/' : concatMap win32ToUriChar wd'
-       normalize wd'
-	   = concatMap escapeNonUriChar wd'
-				 
-       win32ToUriChar '\\' = "/"
-       win32ToUriChar c    = escapeNonUriChar c
-
-       escapeNonUriChar c  = escapeURIChar isUnescapedInURI c   -- from Network.URI
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-HtmlParser.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-HtmlParser.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-HtmlParser.html +++ /dev/null @@ -1,180 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
-
-{- |
-   Module     : Text.XML.HXT.Parser.HtmlParser
-   Copyright  : Copyright (C) 2005 Uwe Schmidt
-   License    : MIT
-
-   Maintainer : Uwe Schmidt (uwe@fh-wedel.de)
-   Stability  : stable
-   Portability: portable
-
-   This parser tries to interprete everything as HTML
-   no errors are emitted during parsing. If something looks
-   weired, warning messages are inserted in the document tree.
-  
-   Module contains state filter for easy parsing and error handling
-   real work is done in 'Text.XML.HXT.Parser.HtmlParsec'
-
--}
-
--- ------------------------------------------------------------
-
-module Text.XML.HXT.Parser.HtmlParser
-    ( getHtmlDoc
-    , parseHtmlDoc
-    , runHtmlParser
-    , substHtmlEntities
-    , module Text.XML.HXT.Parser.HtmlParsec
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlTree
-import Text.XML.HXT.DOM.XmlState
-import Text.XML.HXT.Parser.HtmlParsec
-
-import Text.XML.HXT.Parser.XmlInput
-    ( getXmlContents
-    )
-
-import Text.XML.HXT.Parser.XmlOutput
-    ( traceTree
-    , traceSource
-    , traceMsg
-    )
-
-import Text.XML.HXT.Parser.XhtmlEntities
-    ( xhtmlEntities
-    )
-
--- ------------------------------------------------------------
-
--- |
--- read a document and parse it with 'parseHtmlDoc'. The main entry point of this module
---
--- The input tree must be a root tree like in '	Text.XML.HXT.Parser.MainFunctions.getXmlDoc'. The content is read with 'Text.XML.HXT.Parser.XmlInput.getXmlContents',
--- is parsed with 'parseHtmlDoc' and canonicalized (char refs are substituted in content and attributes,
--- but comment is preserved)
---
--- see also : 'Text.XML.HXT.Parser.DTDProcessing.getWellformedDoc'
-
-getHtmlDoc	:: XmlStateFilter state
-getHtmlDoc
-    = setSystemParams
-      .>>
-      getXmlContents
-      .>>
-      parseHtmlDoc
-
--- | The HTML parsing filter
---
--- The input is parsed with 'runHtmlParser', everything is interpreted as HTML,
--- if errors ocuur, the parser will try to do some meaningfull action and continues
--- parsing. Afterwards the entitiy references for defined for XHTML are resovled,
--- any unresolved reference is transformed into plain text.
---
--- Error messages
--- during parsing and entity resolving are added as warning nodes into the resulting tree.
---
--- The warnings are issued, if the 1. parameter noWarnings is set to True,
--- afterwards all are removed from the resulting tree.
-
-parseHtmlDoc	:: XmlStateFilter a
-parseHtmlDoc
-    = parseDoc
-      `whenM` ( isRoot .> getChildren .> isXText )
-      where
-      parseDoc t'
-	  = ( traceMsg 2 ("parseHtmlDoc: parse HTML document " ++ show loc)
-	      .>>
-	      runHtmlParser
-	      .>>
-	      liftMf (processTopDown substHtmlEntities)
-	      .>>
-	      removeWarnings
-	      .>>
-	      traceTree
-	      .>>
-	      traceSource
-              ) $ t'
-	  where
-	  loc    = valueOf a_source t'			-- get document source uri
-
-      removeWarnings	:: XmlStateFilter a
-      removeWarnings t'
-	  = let
-	    noWarnings  = not (satisfies (hasOption a_issue_warnings) t')
-	    selWarnings = deep
-			  ( choice [ isWarning :-> this
-				   , isXTag    :-> (getAttrl .> selWarnings)
-				   ]
-			  )
-	    remWarnings = processTopDown
-			  ( choice [ isWarning :-> none
-				   , isXTag    :-> (processAttrl (remWarnings $$))
-				   , this      :-> this
-				   ]
-			  )
-	    warnings = selWarnings t'
-	    in do 
-	       if null warnings
-		  then thisM t'
-		  else do
-		       if noWarnings
-			  then return []
-			  else do
-			       issueError $$< warnings
-		       return (remWarnings t')
-
--- | The pure HTML parser, usually called via 'parseHtmlDoc'.
---
-
-runHtmlParser	:: XmlStateFilter a
-runHtmlParser t
-    = if null errs
-      then do
-	   return (replaceChildren res t)
-      else do
-	   issueError $$< errs
-	   return (setStatus c_err "parsing HTML" t)
-      where
-      res  = getChildren .> parseHtmlText loc $ t
-      errs = isXError .> neg isWarning $$ res
-      loc  = valueOf a_source t
-
-
--- ------------------------------------------------------------
---
--- XHTML entities
-
-substHtmlEntities	:: XmlTree -> XmlTrees
-substHtmlEntities
-    = choice [ isXEntityRef	:-> substEntity
-	     , isXTag		:-> processAttr (processChildren substHtmlEntities)
-	     , this		:-> this
-	     ]
-      where
-      substEntity t'@(NTree (XEntityRef en) _)
-	  = case (lookup en xhtmlEntities) of
-	    Just i
-		-> [mkXCharRefTree i]
-	    Nothing
-		-> xwarn ("no XHTML entity found for reference: \"&" ++ en ++ ";\"")
-		   ++
-		   (xmlTreesToText [t'])
-
-      substEntity _
-	  = error "substHtmlEntities: illegal argument"
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-MainFunctions.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-MainFunctions.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-MainFunctions.html +++ /dev/null @@ -1,465 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- Simple parse functions.
---
--- the main building blocks for an application.
--- this module exports complex filters and functions for
--- common tasks for input and parsing, output and option handling.
---
-
-module Text.XML.HXT.Parser.MainFunctions
-    ( getXmlDocument
-    , putXmlDocument
-
-    , parseDocument
-    , writeDocument
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-import Text.XML.HXT.DOM.XmlState
-import Text.XML.HXT.Parser.HtmlParser
-import Text.XML.HXT.Parser.XmlInput
-import Text.XML.HXT.Parser.XmlOutput
-import Text.XML.HXT.Parser.DTDProcessing
-import Text.XML.HXT.Validator.Validation
-import Text.XML.HXT.DOM.EditFilters
-import Text.XML.HXT.DOM.Namespace
-
-import System.IO
-
--- ------------------------------------------------------------
-
--- |
--- convenient function for reading a XML document without
--- dealing with state monads, error messages collection and other details
---
--- getXmlDocument calls 'parseDocument' with the list of parsing options
--- and an url or filename as document source.
---
--- result is a triple
---
--- * the resulting document tree with a root node containing all
---   meta info about the document (options, status info, http header, ...)
---
--- - the list of errors and warnings
---
--- - the error level: one of 'c_ok', 'c_warn', 'c_err', 'c_fatal'
---
--- example for input (see also example in 'putXmlDocument' and example in 'writeDocument')
---
--- > main :: IO ()
--- > main
--- >   = do
--- >     (res, errs, rc) <- getXmlDocument [] "test.xml"
--- >     if rc >= c_err
--- >       then issueErrors errs
--- >       else processTree res
--- >
--- > issueErrors :: XmlTrees -> IO ()
--- >
--- > processTree :: XmlTree  -> IO ()
---
--- for options see 'parseDocument', 'a_collect_errors' is set implicitly
-
-getXmlDocument	:: Attributes -> String -> IO (XmlTree, XmlTrees, Int)
-getXmlDocument options url
-    = do
-      let options' = [ (a_collect_errors, v_1)		-- collect errors
-		     , (a_issue_errors,   v_0)		-- but don't issue
-		     ]					-- can be overwritten by supporting other values in options
-	             ++
-		     options
-		     ++
-		     [ (a_source, url)			-- set the source url
-		     ]
-      res <- run' $ parseDocument options' emptyRoot
-      let root = head res
-      let errs = tail res
-      let elvl = intValueOf a_status root
-      return (root, errs, elvl)
-
-
--- |
--- the inverse operation to 'getXmlDocument'
---
--- writes a complete document tree to a file, writing can be
--- controlled by options, the real work is done with filter 'writeDocument'.
--- useful options are the options of 'writeDocument'.
---
--- result is a pair: 1.part is a list of error messages, 2. part is the return code,
--- the status info of the write filter
---
--- this filter is useful, when processing XML in an arbitray context in the IO monad
---
--- an example main program for such an application is:
---
--- > main :: IO ()
--- > main
--- >   = do
--- >     (input, readErrs, rc) <- getXmlDocument [...] "test.xml"
--- >     if rc >= c_err
--- >       then issueErrors readErrs
--- >       else processTree input
--- >
--- > processTree :: XmlTree -> IO ()
--- > processTree t
--- >   = let res = computeNewTree input
--- >     in do
--- >        (writeErrs, rc2) <- putXmlDocument [...] "out.xml" res
--- >        if rc2 >= c_err
--- >          then issueErrors writeErrs
--- >          else return ()
--- >
--- > issueErrors :: XmlTrees -> IO ()
--- >
--- > computeNewTree :: XmlTree -> XmlTree
-
-
-putXmlDocument	:: Attributes -> String -> XmlTree -> IO (XmlTrees, Int)
-putXmlDocument options fileName t
-    = do
-      let options' = [ (a_collect_errors, v_1)		-- collect errors
-		     , (a_issue_errors,   v_0)		-- but don't issue
-		     ]					-- can be overwritten by supporting other values in options
-	             ++
-		     options
-		     ++
-		     [ (a_output_file, fileName)	-- set the source url
-		     ]
-      res <- run' $ writeDocument options' t
-      let root = head res
-      let errs = tail res
-      let elvl = intValueOf a_status root
-      return (errs, elvl)
-
--- ------------------------------------------------------------
-
--- |
--- the main parsing filter
---
--- this filter can be configured by an option list, a list of
--- option name, option value pairs.
--- the input tree must be a possibly empty document root tree.
--- all the options are stored as attributes in this root node to control processing.
---
--- available options:
---
--- * 'a_parse_html': use HTML parser, else use XML parser (default)
---
--- - 'a_validate' : validate document (default), else skip validation
---
--- - 'a_check_namespaces' : check namespaces, else skip namespace processing (default)
---
--- - 'a_canonicalize' : canonicalize document (default), else skip canonicalization
---
--- - 'a_preserve_comment' : preserve comments during canonicalization, else remove comments (default)
---
--- - 'a_remove_whitespace' : remove all whitespace, used for document indentation, else skip this step (default)
---
--- - 'a_indent' : indent document by inserting whitespace, else skip this step (default)
---
--- - 'a_issue_warnings' : issue warnings, when parsing HTML (default), else ignore HTML parser warnings
---
--- - 'a_issue_errors' : issue all error messages on stderr (default), or ignore all error messages
---
--- - 'a_collect_errors' : all error messages are collected during processing and appended to the result document
--- 			  for further processing within the calling modules
---
--- - 'a_trace' : trace level: values: 0 -4
---
--- - 'a_proxy' : proxy for http access, e.g. www-cache:3128
---
--- - 'a_use_curl' : for http access via external programm curl, default is native HTTP access
---
--- - 'a_options_curl' : more options for external program curl
---
--- - 'a_source' : the document source url
---
--- - 'a_encoding' : default document encoding ('utf8', 'isoLatin1', 'usAscii', ...)
---
--- examples:
---
--- > parseDocument [ (a_source,   "test.xml")
--- >               , (a_validate, "0")
--- >               , (a_encoding, isoLatin1)
--- >               ] emptyRoot
---
--- reads document \"test.xml\" without validation and default encoding 'isoLatin1'
---
--- > parseDocument [ (a_source,         "http://www.haskell.org/")
--- >               , (a_parse_html,     "1")
--- >               , (a_proxy,          "www-cache:3128")
--- >               , (a_curl,           "1")
--- >               , (a_issue_warnings, "0")
--- >               ] emptyRoot
---
--- reads Haskell homepage with HTML parser ignoring any warnings and with http access via external program curl and proxy \"www-cache\" at port 3128
---
--- > parseDocument [ (a_source,            "http://www.w3c.org/")
--- >               , (a_parse_html,        "0")                       -- default
--- >               , (a_validate,          "1")                       -- default
--- >               , (a_check_namespace,   "1")
--- >               , (a_remove_whitespace, "1")
--- >               , (a_trace,             "2")
--- >               ] emptyRoot
---
--- read w3c home page, validate and chech namespaces, remove whitespace between tags, trace activities with level 2
---
--- > parseDocument [ (a_source,   "test.xml")
--- >               , (a_validate,        "1")
--- >               , (a_check_namespace, "1")
--- >               , (a_collect_errors,  "1")
--- >               , (a_issue_errors,    "0")
--- >               ] emptyRoot
---
--- reads file \"test.xml\", validates it, checks namespaces, does not issue any erros
--- but collects errors and appends the list of errors to the single element list for the document.
--- this enables the calling application to define own error handlers.
-
-parseDocument	:: Attributes -> XmlStateFilter state
-parseDocument userOptions
-    = processDocument userOptions defaultOptions
-      ( traceMsg 1 "parseDocument: options added, start processing"
-	.>>
-	traceTree
-	.>>
-	getXmlContents					-- get the content as text
-	.>>
-	choiceM						-- select parser
-	[ hasOption a_parse_html
-		:-> parseHtmlDoc			-- parse everything as HTML
-	, this
-		:-> checkWellformedDoc			-- parse XML and process entities
-	            .>>
-                    ( getValidatedDoc			-- validate
-		      `whenM`
-		      hasOption a_validate
-		    )
-	]
-	.>>
-	( propagateAndValidateNamespaces			-- namespace processing
-	  `whenM`
-	  hasOption a_check_namespaces
-	)
-	.>>
-	liftMf						-- canonicalization
-	( choice
-	  [ hasOption a_preserve_comment		-- don't remove comments (in XPath required)
- 	  	:-> canonicalizeForXPath
-	  , this
-		:-> canonicalizeAllNodes		-- do normal canonicaliazion
-	  ]
-	  `when`
-	  hasOption a_canonicalize			-- caconicalization can be switched off
-	)
-	.>>
-	liftMf
-	( removeDocWhiteSpace				-- remove all whitespace between tags
-	  `when`
-	  hasOption a_remove_whitespace
-	)
-	.>>
-	traceMsg 1 "parseDocument: document processed"	-- trace output
-	.>>
-	traceSource
-	.>>
-	traceTree
-      )
-    where
-    defaultOptions
-	= [ ( a_parse_html,		v_0 )
-	  , ( a_validate,		v_1 )
-	  , ( a_issue_errors,		v_1 )
-	  , ( a_issue_warnings,		v_1 )
-	  , ( a_check_namespaces,	v_0 )
-	  , ( a_canonicalize,		v_1 )
-	  , ( a_preserve_comment,	v_0 )
-	  , ( a_remove_whitespace,	v_0 )
-	  ]
-
--- ------------------------------------------------------------
-
-addOptions		:: Attributes -> XmlFilter
-addOptions
-    = seqF . map (\ (n,v) -> addAttr n v )
-
-addDefaultOptions	:: Attributes -> XmlFilter
-addDefaultOptions
-    = seqF . map (\ (n,v) -> addAttr n v `whenNot` hasAttr n)
-
--- ------------------------------------------------------------
-
--- |
--- the main filter for writing documents
---
--- this filter can be configured by an option list like 'getXmlDocument'
---
--- available options are
---
--- * 'a_indent' : indent document for readability, (default: no indentation)
---
--- - 'a_remove_whitespace' : remove all redundant whitespace for shorten text (default: no removal)
---
--- - 'a_output_file' : destination file for document, default is \"-\" for stdout
---
--- - 'a_output_encoding' : encoding of document, default is 'a_encoding' or 'utf8'
---
--- - 'a_output_xml' : (default) issue XML: quote special XML chars \>,\<,\",\',&
---                    add XML processing instruction
---                    and encode document with respect to 'a_output_encoding',
---                    if explizitly switched of, the plain text is issued, this is useful
---                    for non XML output, e.g. generated Haskell code, LaTex, Java, ...
---
--- - 'a_show_tree' : show tree representation of document (for debugging)
---
--- - 'a_show_haskell' : show Haskell representaion of document (for debugging)
---
--- - 'a_issue_errors', 'a_collect_errors' : see 'parseDocument'
---
---  a typical main program running in the XmlState monad
---  has the following structure:
---
--- >
--- > main :: IO ()
--- > main
--- >     = do
--- >       argv <- getArgs                                              -- get the commandline arguments
--- >       (inp, outp, options) <- cmdlineOpts argv                     -- and evaluate them, return a key-value list
--- >                                                                    -- and input and output
--- >       res  <- run' $ application inp outp options $ emptyRoot      -- run the application
--- > 
--- >       exitWith (if null res
--- >                 then ExitFailure (-1)
--- >                 else exitSuccess
--- >                )
--- >
--- > application :: String -> String -> Attributes -> XmlStateFilter ()
--- > application inp outp al
--- >   = parseDocument (al ++ [(a_source, inp)])                        -- set options and source
--- >     .>>                                                            -- and parse document
--- >     processDocument                                                -- the hard work
--- >     .>>
--- >     writeDocument [(a_output_file, outp)]                          -- issue results
--- >     .>>
--- >     checkStatus                                                    -- check errors
--- >
-
-
-writeDocument	:: Attributes -> XmlStateFilter state
-writeDocument userOptions
-    = processDocument userOptions defaultOptions
-      ( traceMsg 1 "writeDocument: options added, start processing"
-	.>>
-	liftMf
-	( choice
-	  [ hasOption a_indent			:-> indentDoc			-- document indentation
-	  , hasOption a_remove_whitespace	:-> removeDocWhiteSpace		-- remove all whitespace between tags
-	  , this				:-> this
-	  ]
-	)
-	.>>
-	liftMf
-	( choice
-	  [ hasOption a_show_tree	:-> treeRepOfXmlDoc
-	  , hasOption a_show_haskell	:-> haskellRepOfXmlDoc
-	  , hasOption a_output_xml	:-> ( escapeXmlDoc		-- escape lt, gt, amp, quot, 
-					      .>
-					      addXmlPiToDoc		-- add <?xml ... > pi
-					      .>
-					      unparseXmlDoc		-- convert doc into text with respect to output encoding
-					    )
-	  , this			:-> this
-	  ]
-	)
-	.>>
-	writeXmlDoc
-	.>>
-	traceMsg 1 "writeDocument: finished"
-      )
-    where
-    defaultOptions
-	= [ ( a_output_file,		"-" )
-	  , ( a_indent,			v_0 )
-	  , ( a_remove_whitespace,	v_0 )
-	  , ( a_output_xml,		v_1 )
-	  , ( a_output_encoding,       utf8 )
-	  , ( a_show_tree,		v_0 )
-	  , ( a_show_haskell,		v_0 )
-	  ]
-
-writeXmlDoc	:: XmlStateFilter state
-writeXmlDoc t'
-    = put t'
-    where
-    put
-	| null fn || fn == "-"	= putXmlDoc
-	| otherwise		= putXmlDocToFile fn
-
-    fn = xshow . getValue a_output_file $ t'
-
-
--- ------------------------------------------------------------
---
-
--- |
--- wrapper filter for running a monadic filter
--- controlled by common options
---
--- input tree must be a complete document
--- parameters and default parameters can be used to contol
--- the filer and common tasks like error message handling
-
-processDocument	:: Attributes -> Attributes -> XmlStateFilter state -> XmlStateFilter state
-processDocument userOptions defaultOptions processFilter
-    = liftMf isRoot
-      .>>
-      liftMf (addOptions userOptions
-	      .>
-	      addOptions [(a_status, show c_ok)]
-	     )
-      .>>
-      liftMf (addDefaultOptions defaultOptions)
-      .>>
-      setSystemParams							-- store options in system state
-      .>>
-      choiceM
-      [ hasOption a_propagate_errors					-- error handling is set by calling environment
-		:-> thisM
-
-      , hasOption a_collect_errors
-	.>
-	hasOption a_issue_errors
-		:-> performAction (\ _ -> setSysErrorHandler (errorMsgLogging.>> errorMsgToStderr)	)
-
-      , hasOption a_collect_errors
-		:-> performAction (\ _ -> setSysErrorHandler errorMsgLogging	)
-
-      , hasOption a_issue_errors
-		:-> performAction (\ _ -> setSysErrorHandler errorMsgToStderr	)
-
-      , this
-		:-> performAction (\ _ -> setSysErrorHandler noneM		)
-      ]
-      .>>
-      processFilter
-      .>>
-      ( thisM
-        +++>>
-	( hasOption a_collect_errors
-          `guardsM`
-	  getErrorMsg
-	)
-      )
-
--- ------------------------------------------------------------
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandler.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandler.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandler.html +++ /dev/null @@ -1,93 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
{-# LINE 1 "ProtocolHandler.hs" #-}
--- ------------------------------------------------------------
---
--- protocol handler functions
--- configuration file
--- real handler is generated with cpp
-
-module Text.XML.HXT.Parser.ProtocolHandler
-    ( getProtocolHandler
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlState
-
--- ------------------------------------------------------------
---
--- file io and network
-
-import Data.Maybe
-    ( fromMaybe
-    )
-
-import Network.URI
-    ( URI
-    , uriScheme
-    )
-
-import Text.XML.HXT.Parser.ProtocolHandlerFile
-    ( getFileContents
-    )
-
-
-import Text.XML.HXT.Parser.ProtocolHandlerHttpNativeOrCurl
-    ( getHttpContentsNativeOrWithCurl
-    )
-
-
-
-
-
--- ------------------------------------------------------------
---
-
-getProtocolHandler	:: String -> (URI -> XmlStateFilter a)
-getProtocolHandler proto
-    = fromMaybe getUnsupported handler
-      where
-      handler  = lookup proto protocolHandler
-
---
--- the fall back protocol handler
-
-getUnsupported	:: URI -> XmlStateFilter a
-getUnsupported uri
-    = addFatal ( "unsupported protocol "
-		 ++ show (uriScheme uri)
-		 ++ " in URI: "
-		 ++ show uri
-	       )
-
--- ------------------------------------------------------------
---
--- the table of potocol handlers
--- looked up in getProtocolHandler
-
-protocolHandler	:: [(String, URI -> XmlStateFilter a)]
-protocolHandler
-    = [ ("file", getFileContents)
-      , ("http",
-
-
-	 getHttpContentsNativeOrWithCurl
-
-
-
-
-	)
-      ]
-
--- ------------------------------------------------------------
-
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerFile.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerFile.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerFile.html +++ /dev/null @@ -1,87 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
---
--- protocol handler function for file protocol
--- implemented as filer
-
-module Text.XML.HXT.Parser.ProtocolHandlerFile
-    ( getFileContents
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.DOM.XmlState
-
-import System.Directory
-    ( doesFileExist
-    , getPermissions
-    , readable
-    )
-
-import Network.URI
-    ( URI
-    , unEscapeString
-    , uriPath
-    )
-
-import System.IO
-import System.IO.Error
-
--- ------------------------------------------------------------
---
--- the file protocol handler
-
-getFileContents	:: URI -> XmlStateFilter a
-getFileContents uri n
-    = do
-      trace 2 ("getFileContent: reading file " ++ show source)
-      exists <- io $ doesFileExist source
-      if exists
-	 then do
-	      perm <- io $ getPermissions source
-	      if readable perm
-		 then do
-		      h <- io $ try ( openFile source ReadMode )
-		      case h of
-			     Left e
-				 -> readErr ( "system error when reading file "
-					      ++ show source
-					      ++ ": "
-					      ++ ioeGetErrorString e
-					    )
-			     Right h'
-				 -> do
-				    c <- io $ hGetContents h'
-				    return ( ( addAttrInt transferStatus 200
-					       .>
-					       addAttr transferMessage "OK"
-					       .>
-					       replaceChildren (xtext c)
-					     ) n
-					   )
-
-		 else readErr ("file " ++ show source ++ " not readable")
-         else readErr ("file " ++ show source ++ " not found")
-    where
-    source	= fileUriPath . unEscapeString . uriPath $ uri
-    readErr msg	= addFatal msg n
-
-    -- remove leading / if file starts with windows drive letter, e.g. /c:/windows -> c:/windows
-    fileUriPath ('/' : file@(d : ':' : _more))
-	| d `elem` ['A'..'Z'] || d `elem` ['a'..'z']
-	    = file
-    fileUriPath file
-	= file
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerHttpCurl.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerHttpCurl.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerHttpCurl.html +++ /dev/null @@ -1,202 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
---
--- protocol handler functions for native http access
-
-module Text.XML.HXT.Parser.ProtocolHandlerHttpCurl
-    ( getHttpContentsWithCurl
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.DOM.XmlState
-
-import Text.XML.HXT.Parser.ProtocolHandlerUtil
-    ( parseContentType
-    )
-
-import Text.ParserCombinators.Parsec
-    ( Parser
-    , parse
-    , anyChar
-    , char
-    , digit
-    , getInput
-    , many1
-    , manyTill
-    , spaces
-    , string
-    , (<|>)
-    )
-
-import qualified Text.ParserCombinators.Parsec
-    ( try
-    )
-
-import Network.URI
-    ( URI
-    )
-
-import System.PipeOpen
-    ( popen
-    )
-
-import Data.Char
-    ( toLower
-    )
-
--- ------------------------------------------------------------
---
--- the http protocol handler implemented by calling external program curl
-
-getHttpContentsWithCurl	:: URI -> XmlStateFilter a
-getHttpContentsWithCurl uri n
-    = do
-      trace 2 ( "getHttpContentWithCurl: reading from URL " ++ show uri )
-
-      proxy       <- getSysParam a_proxy
-      curlOptions <- getSysParam a_options_curl
-
-      let allArgs = args ++ proxyArgs proxy ++ words curlOptions
-
-      trace 4 ( "getHttpContentWithCurl: running " ++ show (unwords (cmd : allArgs)) )
-
-      (res, errs, rc) <- io $ popen cmd allArgs
-
-      trace 4 ( "getHttpContentWithCurl: PID:    " ++ show rc   )
-      trace 4 ( "getHttpContentWithCurl: stdin:  " ++ show res  )
-      trace 4 ( "getHttpContentWithCurl: stderr: " ++ show errs )
-
-      if rc /= 0
-	 then addFatal ( "http error when requesting URI (rc=" ++ show rc ++ ") "
-			 ++ show uri
-			 ++ ": "
-			 ++ errs
-		       ) n
-	 else let
-	      (st, al, contents) = parseResponse res
-	      in
-	      liftMf ( addAttrl (const al)
-		       .>
-		       replaceChildren (xtext contents)
-		     )
-	      .>> ( if st >= 200 && st < 300
-		    then thisM
-		    else
-		    addFatal ( "http error when accessing URI "
-			       ++ show uri
-			       ++ ": "
-			       ++ show st
-			       ++ " "
-			       ++ (valueOf transferMessage $ newRoot al)
-			     )
-		  )
-	      $ n
-    where
-    cmd  = "curl"
-    args = [ "--silent"
-	   , "--show-error"
-	   , "--dump-header", "-"
-	   , show uri
-	   ]
-    proxyArgs ""
-	= []
-    proxyArgs prx
-	= [ "--proxy", prx ]
-
-parseResponse	:: String -> (Int, XmlTrees, String)
-parseResponse inp
-    = case (parse parseHttpResponse "HTTP Header" inp) of
-      Right res -> res
-      Left  _   -> (999, xattr transferMessage "illegal HTTP response", inp)
-
--- ------------------------------------------------------------
---
--- parsers for HTTP response
-
-parseHttpResponse		:: Parser (Int, XmlTrees, String)
-parseHttpResponse
-    = do
-      allResponses <- many1
-		      ( do
-			(rc, rh) <- parseResp
-			rhs      <- parseHeaders
-			return (rc, rh, rhs)
-		      )
-      let (rc, rh, rhs) = last allResponses
-      content  <- getInput
-      return (rc, rh ++ rhs, content)
-    where
-
-    crlf		:: Parser ()
-    crlf
-	= do
-	  ( Text.ParserCombinators.Parsec.try (string "\r\n") <|> string "\n" )
-	  return ()
-
-    parseResp		:: Parser (Int, XmlTrees)
-    parseResp
-	= do
-	  vers <- ( do
-		    http <- string "HTTP/"
-		    mav <- many1 digit
-		    char '.'
-		    miv <- many1 digit
-		    return (http ++ mav ++ "." ++ miv)
-		  )
-	  spaces
-	  ds <- many1 digit
-	  spaces
-	  reason <- manyTill anyChar crlf
-	  return ( read ds,
-		   xattr transferMessage reason ++ xattr transferVersion vers
-		 )
-
-    parseHeaders	:: Parser XmlTrees
-    parseHeaders
-	= ( do
-	    crlf
-	    return []
-	  )
-	  <|>
-	  ( do
-	    header1 <- parse1Header
-	    rest    <- parseHeaders
-	    return $ header1 ++ rest
-	  )
-	  <|>
-	  ( do
-	    return $ xattr (httpPrefix ++ "IllegalHeaders") ""
-	  )
-
-    parse1Header	:: Parser XmlTrees
-    parse1Header
-	= do
-	  header <- manyTill anyChar (char ':')
-	  spaces
-	  value  <- manyTill anyChar crlf
-	  let ct = parseCT header value
-	  return $ ct ++ xattr (httpPrefix ++ header) value
-	where
-	parseCT	:: String -> String -> XmlTrees
-	parseCT h v
-	    | map toLower h == "content-type"
-		= ( case (parse parseContentType h v) of
-		    Right res -> concatMap (uncurry xattr) res
-		    Left  _   -> []
-		  )
-	    | otherwise
-		= []
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerHttpNative.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerHttpNative.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerHttpNative.html +++ /dev/null @@ -1,161 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
---
--- protocol handler functions for native http access
---
-
-module Text.XML.HXT.Parser.ProtocolHandlerHttpNative
-    ( getHttpContentsWithHttp
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.DOM.XmlState
-
-import Text.XML.HXT.Parser.ProtocolHandlerUtil
-    ( parseContentType
-    )
-
-import Text.XML.HXT.DOM.Util
-    ( stringTrim
-    )
-
-import Text.ParserCombinators.Parsec
-    ( parse
-    )
-
-import System.IO
-import System.IO.Error
-
-import Network.URI
-    ( URI
-    )
-
-import Network.Socket
-    ( withSocketsDo
-    )
-
-import Network.HTTP		-- http modules
-import Network.Browser
-
--- ------------------------------------------------------------
---
--- the native http protocol handler
-
-type ResponseString	= Response String
-
--- ------------------------------------------------------------
---
--- the http protocol handler, haskell implementation
-
-getHttpContentsWithHttp	:: URI -> XmlStateFilter a
-getHttpContentsWithHttp uri n
-    = do
-      traceLevel <- getTraceLevel
-      trace 2 ("getHttpContent: reading from URL " ++ show uri)
-      proxy <- getSysParam a_proxy
-      res <- io $  try (getHttp traceLevel uri proxy)
-      case res of
-	       Left e
-		   -> readErr ( "http error when requesting URI "
-				++ show uri
-				++ ": "
-				++ ioeGetErrorString e
-				++ " (perhaps server does not understand HTTP/1.1) "
-			      )
-	       Right response
-		   -> let
-		      al = convertResponseHeaders response
-		      cs = xtext (rspBody response)
-		      st = convertResponseStatus (rspCode response)
-		      in
-		      if st >= 200 && st < 300
-			 then
-			 return $ (addAttrl (const al) .> replaceChildren cs) n
-			 else 
-			 readErr ( "http error when accessing URI "
-				   ++ show (show uri)
-				   ++ ": "
-				   ++ show st
-				   ++ " "
-				   ++ rspReason response
-				 )
-    where
-    readErr msg	= addFatal msg n
-
-    getHttp		:: Int -> URI -> String -> IO ResponseString
-    getHttp trc' uri' proxy'
-	= withSocketsDo $
-	  browse ( do
-		   setOutHandler (trcFct)
-		   setErrHandler (trcFct)
-
-		   setProxy' proxy'
-		   (_ruri, rsp) <- request rq
-		   return rsp
-		 )
-	where
-	trcFct s
-	    | trc' >= 5
-		= hPutStrLn stderr ("-- (" ++ show trc' ++ ") http: " ++ s)
-	    | otherwise
-		= return ()
-
-	rq = defaultGETRequest uri'
-	
-	setProxy' ""	= return ()
-	setProxy' p	= setProxy (Proxy p Nothing)
-
-    convertResponseStatus	:: (Int, Int, Int) -> Int
-    convertResponseStatus (a, b, c)
-	= 100 * a + 10 * b + c
-
-    convertResponseHeaders	:: ResponseString -> XmlTrees
-    convertResponseHeaders r'
-	= cvResponseCode (rspCode r')
-	  ++
-	  cvResponseReason (rspReason r')
-          ++
-	  cvResponseHeaders (rspHeaders r')
-	where
-	cvResponseCode	:: (Int, Int, Int) -> XmlTrees
-	cvResponseCode st'
-	    = xattr transferStatus (show (convertResponseStatus st'))
-	      ++
-	      xattr transferVersion httpVersion
-
-	cvResponseReason	:: String -> XmlTrees
-	cvResponseReason r''
-	    = xattr transferMessage (stringTrim r'')
-
-	cvResponseHeaders	:: [Header] -> XmlTrees
-	cvResponseHeaders
-	    = concatMap cvResponseHeader
-
-	cvResponseHeader	:: Header -> XmlTrees
-	cvResponseHeader (Header name value)
-	    | name == HdrContentType
-		= ( case (parse parseContentType (show HdrContentType) value) of
-		    Right res -> concatMap (uncurry xattr) res
-		    Left  _   -> []
-		  )
-                  ++
-		  addHttpAttr
-	    | otherwise
-		= addHttpAttr
-	    where
-	    addHttpAttr = xattr (httpPrefix ++ (show name)) value
-
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerHttpNativeOrCurl.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerHttpNativeOrCurl.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-ProtocolHandlerHttpNativeOrCurl.html +++ /dev/null @@ -1,53 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
---
--- protocol handler functions for native http access
-
-module Text.XML.HXT.Parser.ProtocolHandlerHttpNativeOrCurl
-    ( getHttpContentsNativeOrWithCurl
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlKeywords
-    ( a_use_curl
-    )
-
-import Text.XML.HXT.DOM.XmlState
-
-import Network.URI
-    ( URI
-    )
-
-import Text.XML.HXT.Parser.ProtocolHandlerHttpNative
-    ( getHttpContentsWithHttp
-    )
-
-import Text.XML.HXT.Parser.ProtocolHandlerHttpCurl
-    ( getHttpContentsWithCurl
-    )
-
-
--- ------------------------------------------------------------
---
--- the http protocol handler switch for internal / external access
-
-getHttpContentsNativeOrWithCurl		:: URI -> XmlStateFilter a
-getHttpContentsNativeOrWithCurl uri n
-    = do
-      curl <- getSysParamInt a_use_curl 0
-      ( if curl /= 0
-	then getHttpContentsWithCurl
-	else getHttpContentsWithHttp ) uri n
-
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-XmlInput.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-XmlInput.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-XmlInput.html +++ /dev/null @@ -1,392 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- ------------------------------------------------------------
---
--- input functions
--- implemented as filer
-
-module Text.XML.HXT.Parser.XmlInput
-    ( getXmlContents
-    , getXmlEntityContents
-    , getUrlContents
-    , getContentLength
-    , guessDocEncoding
-    , runInLocalURIContext
-    , runInNewURIContext
-    , getBaseURI
-    , setBaseURI
-    , getAbsolutURI
-    , isStandaloneDocument
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.DOM.XmlState
-
-import Text.XML.HXT.Parser.DefaultURI
-    ( setDefaultURI
-    )
-
-import Text.XML.HXT.Parser.XmlParser
-    ( parseXmlDocEncodingSpec
-    , parseXmlEntityEncodingSpec
-    , removeEncodingSpec
-    )
-
-import Text.XML.HXT.DOM.Unicode
-    ( getDecodingFct
-    , guessEncoding
-    , normalizeNL
-    )
-
-import Text.XML.HXT.Parser.XmlOutput
-    ( traceTree
-    , traceSource
-    , traceMsg
-    )
-
-import Text.XML.HXT.Parser.ProtocolHandler
-    ( getProtocolHandler
-    )
-
--- ------------------------------------------------------------
---
--- URI manipulation
-
-import Network.URI
-    ( parseURIReference
-    , relativeTo
-    , uriScheme
-    )
-
--- ------------------------------------------------------------
---
--- utilities
-
-import Data.Maybe
-
--- ------------------------------------------------------------
---
--- filter for reading the content
--- input: a root node with arguments in tag attribute list
--- and without any children.
-
--- attribute a_source   ("source")   for input file or uri
---
--- attribute a_encoding ("encoding") for encoding scheme
---
--- attribute a_proxy    ("proxy")    for proxy tob be used in http access
-
-getXmlContents'		:: XmlFilter -> XmlStateFilter a
-getXmlContents' parseEncodingSpec
-    = getContent'
-      `whenM` isRoot
-      where
-      getContent' t'
-	  = ( liftMf (setStatus c_ok "getXmlContents")
-	      .>>
-	      getUrlContents
-	      .>>
-	      liftF parseEncodingSpec
-	      .>>
-	      guessDocEncoding
-	      .>>
-	      traceMsg 1 ("getXmlContents: content read and decoded from " ++ show input')
-	      .>>
-	      traceTree
-	      .>>
-	      traceSource
-	    ) t'
-	    where
-	    input' = valueOf a_source t'
-
--- |
--- filter for reading the content of a XML document
---
--- input is a root node with the source as an attibute
--- the text is read, the encoding scheme is parsed and selected
--- and the input is translated into the internal UTF-8 string representation
-
-getXmlContents		:: XmlStateFilter a
-getXmlContents
-    = getXmlContents' parseXmlDocEncodingSpec
-      .>>
-      setBaseURIFilter
-      .>>
-      setStandAloneFilter
-
--- |
--- filter for reading the content of an external XML entity
---
---
--- see also : 'getXmlContents'
-
-getXmlEntityContents	:: XmlStateFilter a
-getXmlEntityContents
-    = getXmlContents' parseXmlEntityEncodingSpec
-      .>>
-      liftF (processChildren removeEncodingSpec)	-- remove encoding spec, it's not part of the entity value
-      .>> 
-      setBaseURIFilter
-
--- ------------------------------------------------------------
-
-setBaseURIFilter	:: XmlStateFilter a
-setBaseURIFilter
-    = performAction (\ t -> setBaseURI (valueOf transferURI t))
-      `whenM` isRoot
-
--- |
--- filter command for saving and restoring
--- the base URI
---
---    * 1.parameter f :  the filter that possible changes the base URI
---
---
---    - returns : a filter with the same effect as f, that restores the base URI after application of f
-
-runInLocalURIContext		:: XmlStateFilter a -> XmlStateFilter a
-runInLocalURIContext f t
-    = do
-      oldContext <- getBaseURI
-      trace 2 ("runInLocalURIContext: save base URI " ++ show oldContext)
-      res <- f t
-      setBaseURI oldContext
-      trace 2 ("runInLocalURIContext: restore base URI " ++ show oldContext)
-      return res
-
--- |
--- filter command for running an action in a new URI context
-
-runInNewURIContext	:: String -> XmlStateFilter a -> XmlStateFilter a
-runInNewURIContext uri f
-    | null uri
-	= f
-    | otherwise
-	= runInLocalURIContext
-	  ( \ t -> ( do
-		     trace 2 ("runInNewURIContext: new base URI " ++ show uri)
-		     setBaseURI uri
-		     f t
-		   )
-	  )
-
--- ------------------------------------------------------------
--- |
--- guessEncoding uses encoding attribute and content
--- to determine the encoding scheme.
---
--- it's assumed that an encoding spec has been tried to parse before guessing the encoding.
---
--- UTF-8 is the default encoding
---
--- other supported encodings are ISO-8859-1 (also known as ISO-Latin-1),
--- US-ASCII, UTF-16 or ISO-10646-UCS-2, UTF-16BE, UTF-16LE
-
-guessDocEncoding	:: XmlStateFilter a
-guessDocEncoding
-    = addDocEncoding
-      `whenM` isRoot
-    where
-    addDocEncoding n'
-	= do
-	  trace 2 ( "guessDocEncoding: encoding is " ++ show guess)
-	  ( encFilter (getDecodingFct guess)
-	    .>>
-	    issueError
-	    .>>
-	    liftMf (addAttr transferEncoding guess) ) n'
-	  where
-	  guess	:: String
-	  guess	= head . filter (not . null)
-		  $ [ (guessEncoding . showXText . getChildren) n'
-		    , valueOf transferEncoding n'
-		    , valueOf a_encoding n'
-		    , utf8
-		    ]
-	  encFilter (Just fct)
-	      = decodeDoc fct
-
-	  encFilter Nothing
-	      = addFatal ("encoding scheme not supported: " ++ show guess)
-
-	  decodeDoc df n''
-	      | null errs	= liftMf (replaceChildren (xtext (normalizeNL res))) $ n''
-	      | otherwise	= ( liftMf (replaceChildren (xtext ""))
-				    .>>
-				    ( issueDecodingErrs
-				      +++>>
-				      addFatal "decoding errors detected"
-				    )
-				  ) n''
-	      where
-	      str = xshow . getChildren $ n''
-	      (res, errs) = df str
-	      issueDecodingErrs = catM . map (issueErr . (guess ++) . (" encoding error" ++)) $ errs
-
--- ------------------------------------------------------------
-
-getDefaultURI	:: XState state String
-getDefaultURI
-    = do
-      uri <- getSysParam transferDefaultURI
-      if null uri
-	 then do
-	      setDefaultURI
-	      getDefaultURI
-	 else return uri
-
--- |
--- set the base URI, all other URIs are handled relative to this base URI
---
--- the default base URI is @file:\/\/\/\<current-working-dir\>\/@
---
--- see also : 'getBaseURI'
-
-setBaseURI	:: String -> XState state ()
-setBaseURI str
-    = do
-      trace 2 ("setBaseURI: new base URI: " ++ show str)
-      setSysParam transferURI str
-
--- |
--- read the current base URI
---
--- see also : 'setBaseURI'
-
-getBaseURI	:: XState state String
-getBaseURI
-    = do
-      uri <- getSysParam transferURI
-      if null uri
-	 then do
-	      res <- getDefaultURI
-	      setBaseURI res
-	      getBaseURI
-	 else return uri
-
--- |
--- transform an URI into an absolut URI using the current base URI
---
---
---    * 1.parameter uri :  the URI as string
---
---
---    - returns : the absolut URI as string or \"\" in case of an error
-
-getAbsolutURI	:: String -> XState state String
-getAbsolutURI uri
-    = do
-      baseUri <- getBaseURI
-      return $ expandURI uri baseUri
-
-expandURI	:: String -> String -> String
-expandURI uri base
-    = fromMaybe "" $ expand
-    where
-    expand = do
-	     base' <- parseURIReference base
-	     uri'  <- parseURIReference uri
-	     abs'  <- relativeTo uri' base'
-	     return $ show abs'
-
--- ------------------------------------------------------------
-
-setStandAloneFilter	:: XmlStateFilter a
-setStandAloneFilter
-    = performAction setStandAlone
-      where
-      setStandAlone t
-	  = do
-	    if null standalone
-	       then return ()
-	       else do
-		    trace 2 ("setStandAloneFilter: standalone=" ++ show standaloneVal)
-		    setSysParam a_standalone standaloneVal
-	    where
-	    standalone	= getValue a_standalone t
-	    standaloneVal	= showXText standalone
-
--- |
--- predicate for testing the standalone document attribute
-
-isStandaloneDocument	:: XState state Bool
-isStandaloneDocument
-    = do
-      val <- getSysParam a_standalone
-      return (val == "yes")
-
--- ------------------------------------------------------------
-
--- |
--- the hard io operations
---
--- for reading a file or accessing a document via http
--- input must be a root node with a @source@ attribute specifying the URI
-
-getUrlContents	:: XmlStateFilter a
-getUrlContents
-    =  getCont
-      `whenM` isRoot
-    where
-    getCont n'
-	= do
-	  trace 1 ("getUrlContent: reading " ++ show src)
-	  uri <- getAbsolutURI src
-	  if null uri
-	     then urlErr ( "illegal URI for input: " ++ show src )
-	     else let
-		  uri'     = fromJust $ parseURIReference uri
-		  proto    = init . uriScheme $ uri'
-		  handler  = getProtocolHandler proto
-		  in
-		  ( liftMf (addAttr transferProtocol proto
-			   .>
-			   addAttr transferURI uri
-			  )
-		    .>>
-		    handler uri'
-		  ) $ n'
-	where
-	src        = valueOf a_source n'
-	urlErr msg = addFatal msg n'
-
--- ------------------------------------------------------------
-
--- |
--- compute the length of the data for a document read previously
--- by a call of 'getUrlContents. The result is stored as an attribute
--- value in the document root node. the attribute name is 'a_contentLength'
-
-getContentLength	:: XmlFilter
-getContentLength
-    = addAttrl contentLengthAttr
-      `when` isRoot
-      where
-      http_contentLength	= httpPrefix ++ "Content-Length"
-
-      contentLengthAttr		:: XmlFilter
-      contentLengthAttr t
-	  = choice [ hasAttr a_contentLength
-		     :-> none
-		   , hasAttr http_contentLength
-		     :-> mkXAttr a_contentLength (getValue http_contentLength)
-		   , this
-                     :-> mkXAttr a_contentLength getLength
-		   ] t
-
-      getLength			:: XmlFilter
-      getLength t
-	  = xtext (show . length . xshow . getChildren $ t)
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-XmlOutput.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-XmlOutput.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-XmlOutput.html +++ /dev/null @@ -1,176 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- output functions
--- implemented as filer
-
-module Text.XML.HXT.Parser.XmlOutput
-    ( putXmlDoc
-    , putXmlDocToFile
-    , putXmlTree	-- for trace output
-    , putXmlSource	--  "    "     "
-
-    , hPutXmlDoc
-    , hPutXmlTree
-    , hPutXmlSource
-
-    , traceF
-    , traceMsg
-    , traceTree
-    , traceSource
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.DOM.XmlState
-
-import Text.XML.HXT.DOM.EditFilters	( indentDoc
-					, numberLinesInXmlDoc
-					, treeRepOfXmlDoc
-					, addHeadlineToXmlDoc
-					)
-
-import System.IO
-import System.IO.Error
-
--- ------------------------------------------------------------
-
--- |
--- document output for standard output
---
--- see also : 'hPutXmlDoc'
-
-putXmlDoc	:: XmlStateFilter a
-putXmlDoc	= hPutXmlDoc stdout
-
--- |
--- document output for arbitrary files.
---
--- Result is the input document
-
-hPutXmlDoc	:: Handle -> XmlStateFilter a
-hPutXmlDoc handle t
-    = do
-      res <- io $ try (hPutStr handle content)
-      case res of
-        Left ioerr
-	    -> ( issueFatal (show ioerr)
-		 +++>>
-		 thisM
-	       ) t
-	Right _
-	    -> thisM t
-
-    where
-    content = xshow . getChildren $ t
-
--- |
--- document output on a given file name
---
--- Result is the input document
---
--- see also : 'hPutXmlDoc', 'putXmlDoc'
-
-putXmlDocToFile	:: String -> XmlStateFilter a
-putXmlDocToFile fn t
-    = do
-      res <- io $ try (openFile fn WriteMode)
-      case res of
-        Left ioerr
-	    -> ( issueFatal (show ioerr)
-		 +++>>
-		 thisM
-	       ) t
-	Right h
-	    -> do
-	       t' <- hPutXmlDoc h t
-	       io $ try (hClose h)
-	       trace 2 ("document written to file: " ++ fn)
-	       return t'
-
--- ------------------------------------------------------------
-
--- |
--- output of tree representation for trace
-
-hPutXmlTree	:: Handle -> XmlStateFilter a
-hPutXmlTree handle
-    = performAction
-      (\ n -> liftMf (treeRepOfXmlDoc
-		     .>
-		     addHeadlineToXmlDoc
-		    )
-              .>>
-              hPutXmlDoc handle
-              $ n
-      )
-
-putXmlTree	:: XmlStateFilter a
-putXmlTree	= hPutXmlTree stdout
-
--- |
--- output of text representation for trace
-
-hPutXmlSource	:: Handle -> XmlStateFilter a
-hPutXmlSource handle
-    = performAction
-      (\ n -> liftMf ( ( rootTag
-			[ sattr a_source "internal tree" ]
-			[ this ]
-			`whenNot` isRoot
-		      )
-		      .>
-		      indentDoc
-		      .>
-		      numberLinesInXmlDoc
-		      .>
-		      addHeadlineToXmlDoc
-		    )
-              .>>
-              hPutXmlDoc handle
-              $ n
-      )
-
-putXmlSource	:: XmlStateFilter a
-putXmlSource	= hPutXmlSource stdout
-
--- ------------------------------------------------------------
-
--- trace filter for inserting trace operations
--- into a filter sequence
---
---    * 1.parameter level : like in 'traceCmd'
---
---    - 2.parameter cmd : the output filter, e.g. putXmlTree or putXmlSource
---
---    - 3.parameter : the tree
---
---    - returns: the tree
-
-traceF		:: Int -> XmlStateFilter a -> XmlStateFilter a
-traceF level cmd
-    = performAction (\ t -> traceCmd level (cmd t))
-
-traceMsg	:: Int -> String -> XmlStateFilter a
-traceMsg level msg
-    = performAction (\ _ -> trace level msg)
-
-traceTree	:: XmlStateFilter a
-traceTree
-    = traceF 4 (hPutXmlTree stderr)
-
-traceSource	:: XmlStateFilter a
-traceSource
-    = traceF 3 (hPutXmlSource stderr)
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser-XmlParser.html b/doc/hxt-filter/src/Text-XML-HXT-Parser-XmlParser.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser-XmlParser.html +++ /dev/null @@ -1,91 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- Xml Parser: the main parse filter 
-
-module Text.XML.HXT.Parser.XmlParser
-    ( module Text.XML.HXT.Parser.XmlParsec
-    , module Text.XML.HXT.Parser.XmlTokenParser
-    , parseXmlDoc
-    , substXmlEntities
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-import Text.XML.HXT.DOM.XmlState
-
-import Text.XML.HXT.Parser.XmlTokenParser
-
-import Text.XML.HXT.Parser.XmlEntities
-import Text.XML.HXT.Parser.XmlParsec
-import Text.XML.HXT.Parser.XmlOutput
-    ( traceTree
-    , traceSource
-    , traceMsg
-    )
-
--- ------------------------------------------------------------
-
--- |
--- The monadic parser for a whole document.
--- input must be a root node with a single text child.
--- Error messages are issued and global error state is set.
-
-parseXmlDoc	:: XmlStateFilter a
-parseXmlDoc
-    = parseDoc
-      `whenM` ( isRoot .> getChildren .> isXText )
-      where
-      parseDoc t
-	  = ( traceMsg 2 ("parseXmlDoc: parse XML document " ++ show loc)
-	      .>>
-	      parser
-	      .>>
-	      liftMf checkRes
-	      .>>
-	      traceTree
-	      .>>
-	      traceSource
-	    ) $ t
-	  where
-	  loc = valueOf a_source t			-- document name
-	  checkRes
-	      = setStatus c_err ("parsing XML source " ++ show loc)
-	        `whenNot`
-	        getChildren
-	  parser
-	      = processChildrenM (liftF (parseXmlText document' loc))
-
--- ------------------------------------------------------------
-
--- |
--- Filter for substitution of all occurences of the predefined XML entites quot, amp, lt, gt, apos
--- by equivalent character references
-
-substXmlEntities	:: XmlFilter
-substXmlEntities
-    = choice
-      [ isXEntityRef	:-> substEntity
-      , isXTag		:-> processAttr (processChildren substXmlEntities)
-      , this		:-> this
-      ]
-      where
-      substEntity t'@(NTree (XEntityRef en) _)
-	  = case (lookup en xmlEntities) of
-	    Just i
-		-> [mkXCharRefTree i]
-	    Nothing
-		-> this t'
-
-      substEntity _					-- just for preventing ghc warning
-	  = error "substXmlEntities: illegal argument"
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Parser.html b/doc/hxt-filter/src/Text-XML-HXT-Parser.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Parser.html +++ /dev/null @@ -1,45 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- Simple parse functions.
---
--- the "main" building blocks for an application.
--- this module exports all important functions for parsing, validating and transforming XML.
--- it also exports all basic datatypes and functions of the toolbox.
---
-
-module Text.XML.HXT.Parser
-    ( module Text.XML.HXT.DOM
-
-    , module Text.XML.HXT.Parser.XmlParser
-    , module Text.XML.HXT.Parser.HtmlParser
-    , module Text.XML.HXT.Parser.XmlInput
-    , module Text.XML.HXT.Parser.XmlOutput
-    , module Text.XML.HXT.Parser.DTDProcessing
-    , module Text.XML.HXT.Parser.MainFunctions
-
-    , module Text.XML.HXT.Validator.Validation
-    )
-where
-
-import Text.XML.HXT.DOM
-
-import Text.XML.HXT.Parser.XmlParser
-import Text.XML.HXT.Parser.HtmlParser
-import Text.XML.HXT.Parser.XmlInput
-import Text.XML.HXT.Parser.XmlOutput
-import Text.XML.HXT.Parser.DTDProcessing
-import Text.XML.HXT.Parser.MainFunctions
-
-import Text.XML.HXT.Validator.Validation
-
--- ------------------------------------------------------------
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Validator-AttributeValueValidation.html b/doc/hxt-filter/src/Text-XML-HXT-Validator-AttributeValueValidation.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Validator-AttributeValueValidation.html +++ /dev/null @@ -1,367 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- This module provides functions for validating attributes.
-
--- The main functions are:
---
---  - Check if the attribute value meets the lexical constraints of its type
---
---  - Normalization of an attribute value
---
-
--- Special namings in source code:
---
---  - nd - XDTD node
---
---  - n  - XTag node
---
-
-module Text.XML.HXT.Validator.AttributeValueValidation
-    ( checkAttributeValue
-    , normalizeAttributeValue
-    )
-where
-
-import Text.XML.HXT.Parser.XmlParser
-    ( parseNMToken
-    , parseName
-    )
-
-import Text.XML.HXT.DOM.XmlTree
-import Text.XML.HXT.DOM.Util
-
--- |
--- Checks if the attribute value meets the lexical constraints of its type.
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - returns : a function which takes an element (XTag or XDTD ATTLIST),
---                    checks if the attribute value meets the lexical constraints
---                    of its type and returns a list of errors
-
-checkAttributeValue :: XmlTrees -> XmlTree -> XmlFilter
-checkAttributeValue dtdPart attrDecl@(NTree (XDTD ATTLIST al) _) n@(NTree (XTag _ _al') _)
-    = checkValue attrType dtdPart normalizedVal attrDecl n
-      where
-      attrType      = lookup1 a_type al
-      attrValue     = valueOf (getAttrName al) n
-      normalizedVal = normalizeAttributeValue (Just attrDecl) attrValue
-
-checkAttributeValue dtdPart attrDecl@(NTree (XDTD ATTLIST al) _) n@(NTree (XDTD ATTLIST al') _)
-    = checkValue attrType dtdPart normalizedVal attrDecl n
-      where
-      attrType      = lookup1 a_type al
-      attrValue     = lookup1 a_default al'
-      normalizedVal = normalizeAttributeValue (Just attrDecl) attrValue
-
-checkAttributeValue _ nd n
-    = error ("checkAttributeValue: illegeal parameter:\n" ++ show nd ++ show n)
-
-
--- |
--- Dispatches the attibute check by the attribute type.
---
---    * 1.parameter typ :  the attribute type
---
---    - 2.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 3.parameter attrValue :  the normalized attribute value to be checked
---
---    - 4.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - returns : a functions which takes an element (XTag or XDTD ATTLIST),
---                        checks if the attribute value meets the lexical constraints
---                        of its type and returns a list of errors
-
-checkValue :: String -> XmlTrees -> String -> XmlTree -> XmlFilter
-checkValue typ dtdPart attrValue attrDecl
-	| typ == k_cdata	= none
-	| typ == k_enumeration	= checkValueEnumeration attrDecl attrValue
-	| typ == k_entity	= checkValueEntity dtdPart attrDecl attrValue
-	| typ == k_entities	= checkValueEntities dtdPart attrDecl attrValue
-	| typ == k_id		= checkValueId attrDecl attrValue
-	| typ == k_idref	= checkValueIdref attrDecl attrValue
-	| typ == k_idrefs	= checkValueIdrefs attrDecl attrValue
-	| typ == k_nmtoken	= checkValueNmtoken attrDecl attrValue
-	| typ == k_nmtokens	= checkValueNmtokens attrDecl attrValue
-	| typ == k_notation	= checkValueEnumeration attrDecl attrValue
-	| otherwise		= error ("Attribute type " ++ show typ ++ " unknown.")
-
--- |
--- Checks the value of Enumeration attribute types. (3.3.1 \/ p.27 in Spec)
---
---    * 1.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - 2.parameter attrValue :  the normalized attribute value to be checked
-
-checkValueEnumeration :: XmlTree -> String -> XmlFilter
-checkValueEnumeration (NTree (XDTD ATTLIST al) cs) attrValue
-    = if attrValue `elem` enumVals
-      then none
-      else err ("Attribute " ++ show (getAttrName al) ++ " for element " ++ show (getElemName al) ++
-                " must have a value from list "++ show enumVals ++ ".")
-      where
-      enumVals :: [String]
-      enumVals = map (getEnumVal) cs
-
-      getEnumVal :: XmlTree -> String
-      getEnumVal (NTree (XDTD NAME al') _) = lookup1 a_name al'
-      getEnumVal _                         = ""
-
-checkValueEnumeration n _
-    = error ("checkValueEnumeration: illegeal parameter:\n" ++ show n)
-
-
--- |
--- Checks the value of ENTITY attribute types. (3.3.1 \/ p.26 in Spec)
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node, to get the
---                    unparsed entity declarations
---
---    - 2.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - 3.parameter attrValue :  the normalized attribute value to be checked
-
-checkValueEntity :: XmlTrees -> XmlTree -> String -> XmlFilter
-checkValueEntity dtdPart (NTree (XDTD ATTLIST al) _) attrValue
-    = if attrValue `elem` upEntities
-      then none
-      else err ("Entity " ++ show attrValue ++ " of attribute " ++ show (getAttrName al) ++
-                " for element " ++ show (getElemName al) ++ " is not unparsed. " ++
-                "The following unparsed entities exist: " ++ show upEntities ++ ".")
-      where
-      upEntities :: [String]
-      upEntities = map (getEnumVal) (isUnparsedEntity $$ dtdPart)
-
-      getEnumVal :: XmlTree -> String
-      getEnumVal (NTree (XDTD ENTITY al') _) = lookup1 a_name al'
-      getEnumVal _                           = ""
-
-
-checkValueEntity _ n _
-    = error ("checkValueEntity: illegeal parameter:\n" ++ show n)
-
-
--- |
--- Checks the value of ENTITIES attribute types. (3.3.1 \/ p.26 in Spec)
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node, to get the
---                    unparsed entity declarations
---
---    - 2.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - 3.parameter attrValue :  the normalized attribute value to be checked
-
-checkValueEntities ::XmlTrees -> XmlTree -> String -> XmlFilter
-checkValueEntities dtdPart attrDecl@(NTree (XDTD ATTLIST al) _) attrValue
-    = if null valueList
-      then err ("Attribute " ++ show (getAttrName al) ++ " of element " ++
-                 show (getElemName al) ++ " must be one or more names.")
-      else cat (map (checkValueEntity dtdPart attrDecl) valueList)
-      where
-      valueList = words attrValue
-
-checkValueEntities _ n _
-    = error ("checkValueEntities: illegeal parameter:\n" ++ show n)
-
-
--- |
--- Checks the value of NMTOKEN attribute types. (3.3.1 \/ p.26 in Spec)
---
---    * 1.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - 2.parameter attrValue :  the normalized attribute value to be checked
-
-checkValueNmtoken :: XmlTree -> String -> XmlFilter
-checkValueNmtoken (NTree (XDTD ATTLIST al) _) attrValue
-    = checkNmtoken parseRes
-      where
-      parseRes :: XmlTrees
-      parseRes = parseNMToken "" (mkXTextTree attrValue)
-
-      checkNmtoken :: XmlTrees -> XmlFilter
-      checkNmtoken ((NTree (XError _ s) _):_)
-          = err ("Attribute value " ++ show attrValue ++ " of attribute " ++ show (getAttrName al) ++
-	         " for element " ++ show (getElemName al) ++ " must be a name token, "++ (lines s) !! 1 ++".")
-
-      checkNmtoken _ = none
-
-
-checkValueNmtoken n _
-    = error ("checkValueNmtoken: illegeal parameter:\n" ++ show n)
-
-
--- |
--- Checks the value of NMTOKENS attribute types. (3.3.1 \/ p.26 in Spec)
---
---    * 1.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - 2.parameter attrValue :  the normalized attribute value to be checked
-
-checkValueNmtokens :: XmlTree -> String -> XmlFilter
-checkValueNmtokens attrDecl@(NTree (XDTD ATTLIST al) _) attrValue
-    = if null valueList
-      then err ("Attribute "++ show (getAttrName al) ++" of element " ++
-                 show (getElemName al) ++ " must be one or more name tokens.")
-      else cat (map (checkValueNmtoken attrDecl) valueList)
-      where
-      valueList = words attrValue
-
-checkValueNmtokens n _
-    = error ("checkValueNmtokens: illegeal parameter:\n" ++ show n)
-
-
--- |
--- Checks the value of ID attribute types. (3.3.1 \/ p.25 in Spec)
---
---    * 1.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - 2.parameter attrValue :  the normalized attribute value to be checked
-
-checkValueId :: XmlTree -> String -> XmlFilter
-checkValueId attrDecl attrValue
-    = checkForName "Attribute value" attrDecl attrValue
-
-
--- |
--- Checks the value of IDREF attribute types. (3.3.1 \/ p.26 in Spec)
---
---    * 1.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - 2.parameter attrValue :  the normalized attribute value to be checked
-
-checkValueIdref :: XmlTree -> String -> XmlFilter
-checkValueIdref attrDecl attrValue
-    = checkForName "Attribute value" attrDecl attrValue
-
-
--- |
--- Checks the value of IDREFS attribute types. (3.3.1 \/ p.26 in Spec)
---
---    * 1.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - 2.parameter attrValue :  the normalized attribute value to be checked
-
-checkValueIdrefs :: XmlTree -> String -> XmlFilter
-checkValueIdrefs attrDecl attrValue
-    = cat (map (checkValueIdref attrDecl) (words attrValue))
-
-
-
--- -----------------------------------------------------------------------------
--- General helper functions for checking attribute values
---
-
--- |
--- Checks if the value of an attribute is a name.
---
---    * 1.parameter msg :  error message, should be "Entity" or "Attribute value"
---
---    - 2.parameter attrDecl :  the declaration of the attribute from the DTD
---
---    - 3.parameter attrValue :  the normalized attribute value to be checked
-
-checkForName ::  String -> XmlTree -> String -> XmlFilter
-checkForName msg (NTree (XDTD ATTLIST al) _) attrValue
-    = checkName parseRes
-      where
-      parseRes :: XmlTrees
-      parseRes = parseName "" (mkXTextTree attrValue)
-
-      checkName :: XmlTrees -> XmlFilter
-      checkName ((NTree (XError _ s) _):_)
-          = err (msg ++ " "++ show attrValue ++" of attribute " ++ show (getAttrName al) ++
-	    " for element "++ show (getElemName al) ++" must be a name, " ++ (lines s) !! 1 ++ ".")
-
-      checkName _ = none
-
-
-checkForName _ n _
-    = error ("checkForName: illegeal parameter:\n" ++ show n)
-
-
--- |
--- Gets the element name from an attribute list of an XDTD ATTLIST node.
---
---    * 1.parameter tag :  the attibute list of an XDTD ATTLIST
---
---    - returns : the element name
-
-getElemName :: Attributes -> String
-getElemName = lookup1 a_name
-
-
--- |
--- Gets the attribute name from an attribute list of an XDTD ATTLIST node.
---
---    * 1.parameter tag :  the attibute list of an XDTD ATTLIST
---
---    - returns : the attribute name
-
-getAttrName :: Attributes -> String
-getAttrName = lookup1 a_value
-
-
-
--- -----------------------------------------------------------------------------
-
-
--- |
--- Normalizes an attribute value with respect to its type. (3.3.3 \/ p.29 in Spec)
---
---    * 1.parameter attrDecl :  the declaration of the attribute from the DTD. Expected
---                   is a list. If the list is empty, no declaration exists.
---
---    - 2.parameter value :  the attribute value to be normalized
---
---    - returns : the normalized value
---
-normalizeAttributeValue :: Maybe XmlTree -> String -> String
-normalizeAttributeValue (Just (NTree (XDTD ATTLIST al) _)) value
-    = normalizeAttribute attrType
-      where
-      attrType = lookup1 a_type al
-
-      normalizeAttribute :: String -> String
-      normalizeAttribute typ
-          | typ == k_cdata	= cdataNormalization value
-          | otherwise		= otherNormalization value
-
-
--- Attribute not declared in DTD, normalization as CDATA
-normalizeAttributeValue _ value
-    = cdataNormalization value
-
-
--- ------------------------------------------------------------
--- Helper functions for normalization
-
-
--- |
--- Normalization of CDATA attribute values.
--- is already done when parsing
--- during entity substituion for attribute values
-cdataNormalization :: String -> String
-cdataNormalization = id
-
-
--- | Normalization of attribute values other than CDATA.
-otherNormalization :: String -> String
-otherNormalization = reduceWSSequences . stringTrim . cdataNormalization
-
--- | Reduce whitespace sequences to a single whitespace.
-reduceWSSequences :: String -> String
-reduceWSSequences str = unwords (words str)
-
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Validator-DTDValidation.html b/doc/hxt-filter/src/Text-XML-HXT-Validator-DTDValidation.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Validator-DTDValidation.html +++ /dev/null @@ -1,637 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- This module provides functions for validating the DTD of XML documents
--- represented as XmlTree.
-
--- Unlike other popular XML validation tools the validation process returns
--- a list of errors instead of aborting after the first error was found.
-
-
--- Unlike validation of the document, the DTD branch is traversed four times:
---
---  - Validation of Notations
---
---  - Validation of Unparsed Entities
---
---  - Validation of Element declarations
---
---  - Validation of Attribute declarations
-
--- Special namings in source code:
---
---  - nd - XDTD node
---
--- Author : .\\artin Schmidt
-
-module Text.XML.HXT.Validator.DTDValidation
-    ( removeDoublicateDefs
-    , validateDTD
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.Validator.AttributeValueValidation
-
-
-
--- |
--- Validate a DTD.
---
---    - returns : a functions which takes the DTD subset of the XmlTree, checks
---                  if the DTD is valid and returns a list of errors
-
-validateDTD :: XmlFilter
-validateDTD dtdPart
-    = {-# SCC "validateNotations" #-} validateNotations dtdPart'
-      ++
-      {-# SCC "validateEntities" #-} validateEntities dtdPart' notationNames
-      ++
-      {-# SCC "validateElements" #-} validateElements dtdPart' elemNames
-      ++
-      {-# SCC "validateAttributes" #-} validateAttributes dtdPart' elemNames notationNames
-
-      where
-      dtdPart' = getChildren dtdPart
-
-      notationNames :: [String]
-      notationNames
-          = getXTextValues (isNotation .> getDTDValue a_name $$ dtdPart')
-
-      elemNames :: [String]
-      elemNames
-          = getXTextValues (isElement  .> getDTDValue a_name $$ dtdPart')
-
-
-
-
--- ------------------------------------------------------------
-
--- |
--- Returns a list of XText values.
---
---    * 1.parameter xtextList :  a list of XText nodes
---
---    - returns : the values of the XText nodes
-
-getXTextValues :: XmlTrees -> [String]
-getXTextValues
-  = concatMap showT
-  where
-    showT (NTree n _)
-	| isXTextNode n = [textOfXNode n]
-    showT _             = []
-
-
--- ------------------------------------------------------------
-
-
--- |
--- Validation of Notations, checks if all notation names are unique.
--- Validity constraint: Unique Notation Name (4.7 \/ p.44 in Spec)
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - returns : a list of errors
-
-validateNotations :: XmlTrees -> XmlTrees
-validateNotations dtdPart
-    = checkForUniqueNotation notations []
-      where
-      notations = isNotation $$ dtdPart
-
-      checkForUniqueNotation :: XmlTrees -> [String] -> XmlTrees
-      checkForUniqueNotation (x@(NTree (XDTD NOTATION al) _):xs) used
-          = if name `elem` used
-	    then err ("Notation "++ show name ++ " was already specified.") x
-		 ++
-		 checkForUniqueNotation xs used
-
-	    else checkForUniqueNotation xs (name : used)
-	    where
-	    name = lookup1 a_name al
-
-      checkForUniqueNotation [] _ = []
-
-      checkForUniqueNotation nd _
-          = error ("checkForUniqueNotation: illegeal parameter:\n" ++ show nd)
-
-
--- |
--- Validation of Entities.
---
--- 1. Issues a warning if entities are declared multiple times.
---
---    Optional warning: (4.2 \/ p.35 in Spec) 
---
---
--- 2. Validates that a notation is declared for an unparsed entity.
---
---    Validity constraint: Notation Declared (4.2.2 \/ p.36 in Spec)
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter notationNames :  list of all notation names declared in the DTD
---
---    - returns : a list of errors
-
-validateEntities :: XmlTrees -> [String] -> XmlTrees
-validateEntities dtdPart notationNames
-    = checkForUniqueEntity entities []
-      ++
-      checkNotationDecls notationNames upEntities
-
-      where
-      entities   = isEntity $$ dtdPart
-      upEntities = isUnparsedEntity $$ dtdPart
-
-      -- Check if entities are declared multiple times
-      checkForUniqueEntity :: XmlTrees -> [String] -> XmlTrees
-      checkForUniqueEntity (x@(NTree (XDTD ENTITY al) _):xs) used
-          = if name `elem` used
-	    then warn ("Entity "++ show name ++ " was already specified. " ++
-	               "First declaration will be used.") x
-		 ++
-		 checkForUniqueEntity xs used
-
-	    else checkForUniqueEntity xs (name : used)
-	    where
-	    name = lookup1 a_name al
-
-      checkForUniqueEntity [] _ = []
-
-      checkForUniqueEntity nd _
-          = error ("checkForUniqueEntity: illegeal parameter:\n" ++ show nd)
-
-
-      -- Find unparsed entities for which no notation is specified
-      checkNotationDecls :: [String] -> XmlTrees -> XmlTrees
-      checkNotationDecls notationNames' upEntities'
-	  = concatMap (checkNotationDecl) upEntities'
-          where
-          checkNotationDecl :: XmlTree -> XmlTrees
-          checkNotationDecl n@(NTree (XDTD ENTITY al) _)
-              = if (notationName al) `elem` notationNames'
-	        then []
-                else err ("The notation " ++ show (notationName al) ++ " must be declared " ++
-	                  "when referenced in the unparsed entity declaration for " ++
-		          show (upEntityName al) ++ ".") n
-                where
-		notationName = lookup1 k_ndata
-                upEntityName = lookup1 a_name
-
-          checkNotationDecl nd
-              = error ("checkNotationDecl: illegeal parameter:\n" ++ show nd)
-
-
-
--- |
--- Validation of Element declarations.
---
--- 1. Validates that an element is not declared multiple times.
---
---    Validity constraint: Unique Element Type Declaration (3.2 \/ p.21 in Spec) 
---
---
--- 2. Validates that an element name only appears once in a mixed-content declaration.
---
---    Validity constraint: No Duplicate Types (3.2 \/ p.21 in Spec) 
---
---
--- 3. Issues a warning if an element mentioned in a content model is not declared in the
---    DTD.
---
---    Optional warning: (3.2 \/ p.21 in Spec)
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter elemNames :  list of all element names declared in the DTD
---
---    - returns : a list of errors
-
-
-validateElements :: XmlTrees -> [String] -> XmlTrees
-validateElements dtdPart elemNames
-    = checkForUniqueElement elements []
-      ++
-      checkMixedContents mixedContentElems
-      ++
-      checkContentModels elemNames elements
-
-      where
-      elements          = isElement $$ dtdPart
-      mixedContentElems = isMixedContentElement $$ dtdPart
-
-
-      -- Validates that an element is not declared multiple times
-      checkForUniqueElement :: XmlTrees -> [String] -> XmlTrees
-      checkForUniqueElement (x@(NTree (XDTD ELEMENT al) _):xs) used
-          = if name `elem` used
-	    then err ("Element type " ++ show name ++
-		      " must not be declared more than once.") x
-		 ++
-		 checkForUniqueElement xs used
-
-	    else checkForUniqueElement xs (name : used)
-	    where
-	    name = lookup1 a_name al
-
-      checkForUniqueElement [] _ = []
-
-      checkForUniqueElement nd _
-          = error ("checkForUniqueElement: illegeal parameter:\n" ++ show nd)
-
-
-      -- Validates that an element name only appears once in a mixed-content declaration
-      checkMixedContents elems
-          = concatMap (checkMixedContent) elems
-	  where
-          checkMixedContent (NTree (XDTD ELEMENT al) cs)
-	      = checkMC (getChildren (head cs)) []
-	      where
-	      elemName = lookup1 a_name al
-
-	      checkMC :: XmlTrees -> [String] -> XmlTrees
-	      checkMC (x@(NTree (XDTD NAME al') _):xs) used
-                  = if name `elem` used
-	            then err ("The element type " ++ show name ++
-			      " was already specified in the mixed-content model of the element declaration " ++
-		              show elemName ++ ".") x
-		         ++
-		         checkMC xs used
-
-	            else checkMC xs (name : used)
-	            where
-	            name = lookup1 a_name al'
-
-              checkMC [] _ = []
-
-              checkMC nd _
-	          = error ("checkMC: illegeal parameter:\n" ++ show nd)
-
-	  checkMixedContent nd
-	      = error ("checkMixedContent: illegeal parameter:\n" ++ show nd)
-
-
-      -- Issues a warning if an element mentioned in a content model is not
-      -- declared in the DTD.
-      checkContentModels names elems
-          = concatMap checkContentModel elems
-	  where
-          checkContentModel :: XmlFilter
-          checkContentModel (NTree (XDTD ELEMENT al) cs)
-              = validateContent (lookup1 a_type al)
-	      where
-	      elemName = lookup1 a_name al
-
-	      validateContent :: String -> XmlTrees
-	      validateContent cm
-	          | cm == v_children = checkContent (head cs)
-	          | cm == v_mixed    = checkContent (head cs)
-	          | otherwise        = []  -- no child elements to check
-
-	      checkContent :: XmlFilter
-	      checkContent n@(NTree (XDTD NAME al') _)
-	          = if childElemName `elem` names
-	            then []
-	            else warn ("The element type "++ show childElemName ++
-		               ", used in content model of element "++ show elemName ++
-			       ", is not declared.") n
-	            where
-		    childElemName = lookup1 a_name al'
-
-	      checkContent (NTree (XDTD CONTENT _) cs')
-	          = concatMap (checkContent) cs'
-
-	      checkContent nd
-	          = error ("checkContent: illegeal parameter:\n" ++ show nd)
-
-          checkContentModel nd
-              = error ("checkContentModel: illegeal parameter:\n" ++ show nd)
-
-
--- |
--- Validation of Attribute declarations.
---
--- (1) Issues a warning if an attribute is declared for an element type not itself
---    decared.
---
---    Optinal warning: (3.3 \/ p. 24 in Spec)
---
---
--- 2. Issues a warning if more than one definition is provided for the same
---    attribute of a given element type. Fist declaration is binding, later
---    definitions are ignored.
---
---    Optional warning: (3.3 \/ p.24 in Spec)
---
---
--- 3. Issues a warning if the same Nmtoken occures more than once in enumerated
---    attribute types of a single element type.
---
---    Optional warning: (3.3.1 \/ p.27 in Spec) 
---
---
--- 4. Validates that an element type has not more than one ID attribute defined.
---
---    Validity constraint: One ID per Element Type (3.3.1 \/ p.26 in Spec) 
---
---
--- 5. Validates that an element type has not more than one NOTATION attribute defined.
---
---    Validity constraint: One Notation per Element Type (3.3.1 \/ p.27 in Spec) 
---
---
--- 6. Validates that an ID attributes has the type #IMPLIED or #REQUIRED.
---
---    Validity constraint: ID Attribute Default (3.3.1 \/ p.26 in Spec) 
---
---
--- 7. Validates that all referenced notations are declared.
---
---    Validity constraint: Notation Attributes (3.3.1 \/ p.27 in Spec) 
---
---
--- 8. Validates that notations are not declared for EMPTY elements.
---
---    Validity constraint: No Notation on Empty Element (3.3.1 \/p.27 in Spec) 
---
---
--- 9. Validates that the default value matches the lexical constraints of it's type.
---
---    Validity constraint: Attribute default legal (3.3.2 \/ p.28 in Spec)
---
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter elemNames :  list of all element names declared in the DTD
---
---    - 3.parameter notationNames :  list of all notation names declared in the DTD
---
---    - returns : a list of errors
-
-validateAttributes :: XmlTrees -> [String] -> [String] -> XmlTrees
-validateAttributes dtdPart elemNames notationNames
-    = -- 1. Find attributes for which no elements are declared
-      ((checkDeclaredElements elemNames) $$ attributes)
-      ++
-      -- 2. Find attributes which are declared more than once
-      (checkForUniqueAttributeDeclaration attributes [])
-      ++
-      -- 3. Find enumerated attribute types which nmtokens are declared more than once
-      (checkEnumeratedTypes
-      `o`
-      (isEnumAttrType `orElse` isNotationAttrType) $$ attributes)
-      ++
-      -- 4. Validate that there exists only one ID attribute for an element
-      (checkForUniqueId idAttributes [])
-      ++
-      -- 5. Validate that there exists only one NOTATION attribute for an element
-      (checkForUniqueNotation notationAttributes [])
-      ++
-      -- 6. Validate that ID attributes have the type #IMPLIED or #REQUIRED
-      (checkIdKindConstraint $$ idAttributes)
-      ++
-      -- 7. Validate that all referenced notations are declared
-      ((checkNotationDeclaration notationNames) $$ notationAttributes)
-      ++
-      -- 8. Validate that notations are not declared for EMPTY elements
-      ((checkNoNotationForEmptyElement
-      	  (
-    	      getXTextValues (getDTDValue a_name $$ (isEmptyElement $$ dtdPart))
-       	  )
-        ) $$ notationAttributes)
-      ++
-      -- 9. Validate that the default value matches the lexical constraints of it's type
-      ((checkDefaultValueTypes dtdPart) $$ (isDefaultAttrKind $$ attributes))
-
-      where
-      --------------------------------------------------------------------------
-      -- helper functions
-      attributes         = isAttlist $$ dtdPart
-      idAttributes       = isIdAttrType $$ attributes
-      notationAttributes = isNotationAttrType $$ attributes
-
-
-      elemName = lookup1 a_name
-      attName  = lookup1 a_value
-
-      --------------------------------------------------------------------------
-      -- 1. Find attributes for which no elements are declared
-      checkDeclaredElements :: [String] -> XmlFilter
-      checkDeclaredElements elemNames' n@(NTree (XDTD ATTLIST al) _)
-          = if (elemName al) `elem` elemNames'
-	    then []
-	    else warn ("The element type \""++ elemName al ++ "\" used in declaration "++
-	               "of attribute \""++ attName al ++"\" is not declared.") n
-
-      checkDeclaredElements _ nd
-          = error ("checkDeclaredElements: illegeal parameter:\n" ++ show nd)
-
-      --------------------------------------------------------------------------
-      -- 2. Find attributes which are declared more than once
-      checkForUniqueAttributeDeclaration :: XmlTrees -> [String] -> XmlTrees
-      checkForUniqueAttributeDeclaration (x@(NTree (XDTD ATTLIST al) _):xs) used
-          = if name `elem` used
-	    then warn ("Attribute \""++ aname ++"\" for element type \""++
-		        ename ++"\" is already declared. First "++
-		        "declaration will be used.") x
-		 ++
-		 checkForUniqueAttributeDeclaration xs used
-
-	    else checkForUniqueAttributeDeclaration xs (name : used)
-	    where
-	    ename = elemName al
-	    aname = attName al
-	    name  = ename ++ "|" ++ aname
-
-      checkForUniqueAttributeDeclaration [] _ = []
-
-      checkForUniqueAttributeDeclaration nd _
-          = error ("checkForUniqueAttributeDeclaration: illegeal parameter:\n" ++ show nd)
-
-
-      --------------------------------------------------------------------------
-      -- 3. Find enumerated attribute types which nmtokens are declared more than once
-      checkEnumeratedTypes :: XmlFilter
-      checkEnumeratedTypes (NTree (XDTD ATTLIST al) cs)
-          = checkForUniqueType cs []
-	  where
-	  checkForUniqueType :: XmlTrees -> [String] -> XmlTrees
-          checkForUniqueType (x@(NTree (XDTD NAME al') _):xs) used
-              = if nmtoken `elem` used
-	        then warn ("Nmtoken \""++ nmtoken ++"\" should not "++
-		        "occur more than once in attribute \""++ attName al ++
-			"\" for element \""++ elemName al ++ "\".") x
-		     ++
-		     checkForUniqueType xs used
-
-	        else checkForUniqueType xs (nmtoken : used)
-	        where
-	        nmtoken = lookup1 a_name al'
-
-          checkForUniqueType [] _ = []
-
-          checkForUniqueType nd _
-              = error ("checkForUniqueType: illegeal parameter:\n" ++ show nd)
-
-      checkEnumeratedTypes nd
-          = error ("checkEnumeratedTypes: illegeal parameter:\n" ++ show nd)
-
-
-      --------------------------------------------------------------------------
-      -- 4. Validate that there exists only one ID attribute for an element
-      checkForUniqueId :: XmlTrees -> [String] -> XmlTrees
-      checkForUniqueId (x@(NTree (XDTD ATTLIST al) _):xs) used
-          = if ename `elem` used
-	    then err ("Element \""++ ename ++ "\" already has attribute of type "++
-		       "ID, another attribute \""++ attName al ++ "\" of type ID is "++
-		       "not permitted.") x
-		 ++
-		 checkForUniqueId xs used
-
-	    else checkForUniqueId xs (ename : used)
-	    where
-	    ename = elemName al
-
-      checkForUniqueId [] _ = []
-
-      checkForUniqueId nd _
-          = error ("checkForUniqueId: illegeal parameter:\n" ++ show nd)
-
-      --------------------------------------------------------------------------
-      -- 5. Validate that there exists only one NOTATION attribute for an element
-      checkForUniqueNotation :: XmlTrees -> [String] -> XmlTrees
-      checkForUniqueNotation (x@(NTree (XDTD ATTLIST al) _):xs) used
-          = if ename `elem` used
-	    then err ("Element \""++ elemName al ++ "\" already has attribute of type "++
-		       "NOTATION, another attribute \""++ attName al ++ "\" of type NOTATION "++
-		       "is not permitted.") x
-		 ++
-		 checkForUniqueNotation xs used
-
-	    else checkForUniqueNotation xs (ename : used)
-	    where
-	    ename = elemName al
-
-      checkForUniqueNotation [] _ = []
-
-      checkForUniqueNotation nd _
-          = error ("checkForUniqueNotation: illegeal parameter:\n" ++ show nd)
-
-      --------------------------------------------------------------------------
-      -- 6. Validate that ID attributes have the type #IMPLIED or #REQUIRED
-      checkIdKindConstraint :: XmlFilter
-      checkIdKindConstraint nd@(NTree (XDTD ATTLIST al) _)
-          = if (attKind == k_implied) || (attKind == k_required)
-	    then []
-	    else err ("ID attribute \""++ attName al ++"\" must have a declared default "++
-	              "of \"#IMPLIED\" or \"REQUIRED\"") nd
-	    where
-	    attKind = lookup1 a_kind al
-
-      checkIdKindConstraint nd
-          = error ("checkIdKindConstraint: illegeal parameter:\n" ++ show nd)
-
-
-      --------------------------------------------------------------------------
-      -- 7. Validate that all referenced notations are declared
-      checkNotationDeclaration :: [String] -> XmlFilter
-      checkNotationDeclaration notations (NTree (XDTD ATTLIST al) cs)
-          = checkNotations $$ cs
-	  where
-	  checkNotations :: XmlFilter
-	  checkNotations nd@(NTree (XDTD NAME al') _)
-	      = if notation `elem` notations
-	        then []
-	        else err ("The notation \""++ notation ++"\" must be declared when "++
-		          "referenced in the notation type list for attribute \""++ attName al ++
-			  "\" of element \""++ elemName al ++"\".") nd
-                where
-	        notation = lookup1 a_name al'
-
-          checkNotations nd
-              = error ("checkNotations: illegeal parameter:\n" ++ show nd)
-
-      checkNotationDeclaration _ nd
-          = error ("checkNotationDeclaration: illegeal parameter:\n" ++ show nd)
-
-      --------------------------------------------------------------------------
-      -- 8. Validate that notations are not declared for EMPTY elements
-      checkNoNotationForEmptyElement :: [String] -> XmlFilter
-      checkNoNotationForEmptyElement emptyElems nd@(NTree (XDTD ATTLIST al) _)
-          = if (elemName al) `elem` emptyElems
-	    then err ("Attribute \""++ attName al ++"\" of type NOTATION must not be "++
-	              "declared on the element \""++ elemName al ++"\" declared EMPTY.")
-		      nd
-	    else []
-
-      checkNoNotationForEmptyElement _ nd
-          = error ("checkNoNotationForEmptyElement: illegeal parameter:\n" ++ show nd)
-
-      --------------------------------------------------------------------------
-      -- 9. Validate that default values meet the lexical constraints of the attribute types
-      checkDefaultValueTypes :: XmlTrees -> XmlFilter
-      checkDefaultValueTypes dtdPart' n@(NTree (XDTD ATTLIST _) _)
-          = checkAttributeValue dtdPart' n n
-
-      checkDefaultValueTypes _ nd
-          = error ("checkDefaultValueTypes: illegeal parameter:\n" ++ show nd)
-
-
-
--- ------------------------------------------------------------
-
--- |
--- Removes doublicate declarations from the DTD, which first declaration is
--- binding. This is the case for ATTLIST and ENTITY declarations.
---
---    - returns : A function that replaces the children of DOCTYPE nodes by a list
---               where all multiple declarations are removed.
-
-removeDoublicateDefs :: XmlFilter
-removeDoublicateDefs n@(NTree (XDTD DOCTYPE _) cs)
-    = replaceChildren (removeDoubleDefs [] cs) n
-      where
-      removeDoubleDefs :: [String] -> XmlTrees -> XmlTrees
-      removeDoubleDefs used (x@(NTree (XDTD ATTLIST al) _):xs)
-          = if elemAttr `elem` used
-            then removeDoubleDefs used xs
-            else x
-	         :
-	         removeDoubleDefs (elemAttr : used) xs
-            where
-	    elemAttr = elemName ++ "|" ++ attrName
-            attrName = lookup1 a_value al
-            elemName = lookup1 a_name al
-
-
-      removeDoubleDefs used (x@(NTree (XDTD ENTITY al) _):xs)
-          = if name `elem` used
-            then removeDoubleDefs used xs
-            else x
-	         :
-	         removeDoubleDefs (name : used) xs
-            where
-            name = lookup1 a_name al
-
-
-      removeDoubleDefs used (x:xs)
-          = x : removeDoubleDefs used xs
-
-      removeDoubleDefs _ []
-          = []
-
-
-removeDoublicateDefs n
-    = [n]
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Validator-DocTransformation.html b/doc/hxt-filter/src/Text-XML-HXT-Validator-DocTransformation.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Validator-DocTransformation.html +++ /dev/null @@ -1,244 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- This module provides functions for transforming XML documents represented as
--- XmlTree with respect to its DTD.
-
--- Transforming an XML document with respect to its DTD means:
---
---  - add all attributes with default values
---
---  - normalize all attribute values
---
---  - sort all attributes in lexical order
---
-
-
--- Note: Transformation should be started after validation.
-
-
--- Before the document is validated, a lookup-table is build on the basis of
--- the DTD which maps element names to their transformation functions.
--- After this initialization phase the whole document is traversed in preorder
--- and every element is transformed by the XmlFilter from the lookup-table.
-
--- Special namings in source code:
---
---  - nd - XDTD node
---
---  - n  - XTag node
---
--- Author : .\\artin Schmidt
-
-module Text.XML.HXT.Validator.DocTransformation
-    ( transform
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.Validator.AttributeValueValidation
-
-import Data.Maybe
-import Data.List
-
-
-
--- |
--- Lookup-table which maps element names to their transformation functions. The
--- transformation functions are XmlFilters.
-
-type TransEnvTable	= [TransEnv]
-type TransEnv 		= (ElemName, TransFct)
-type ElemName		= String
-type TransFct		= XmlFilter
-
-
--- ------------------------------------------------------------
-
-
--- |
--- filter for transforming the document.
---
---    * 1.parameter dtdPart :  the DTD subset (Node @DOCTYPE@) of the XmlTree
---
---    - 2.parameter doc :  the document subset of the XmlTree
---
---    - returns : a list of errors
-
-transform :: XmlTree -> XmlTree -> XmlTrees
-transform dtdPart dom
-    = traverseTree transTable dom
-    where
-    transTable = {-# SCC "buildAllTransFcts" #-} buildAllTransformationFunctions dtdPart
-
-
-
--- |
--- Traverse the XmlTree in preorder.
---
---    * 1.parameter transEnv :  lookup-table which maps element names to their transformation functions
---
---    - returns : the whole transformed document
-
-traverseTree :: TransEnvTable -> XmlFilter
-traverseTree transEnv n@(NTree (XTag name _) cs)
-    = replaceChildren (concatMap (traverseTree transEnv) cs) (head (transFct n))
-      where
-      transFct = case (lookup (qualifiedName name) transEnv) of
-          Nothing -> this   -- element not in DTD, can't be transformed
-	  Just f  -> f
-
-traverseTree _ n = [n]
-
-
--- |
--- Build all transformation functions.
---
---    * 1.parameter dtdPart :  the DTD subset, root node should be of type @DOCTYPE@
---
---    - returns : lookup-table which maps element names to their transformation functions
-
-buildAllTransformationFunctions :: XmlTree -> TransEnvTable
-buildAllTransformationFunctions dtdPart
-    = buildTransRoot
-      :
-      -- construct the list of filters
-      map (buildTransformationFunctions dtdNodes) (isElement $$ dtdNodes)
-      where
-      dtdNodes = getChildren dtdPart
-
-
--- |
--- Build a transformation function for the document root. By root @\/@
--- is meant, which is the topmost dummy created by the parser. This function is only a
--- dummy, too.
---
---    * returns : entry for the lookup-table
-
-buildTransRoot :: TransEnv
-buildTransRoot = (t_root, this)
-
-
-
--- |
--- Build transformation functions for an element.
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    * 1.parameter nd :  element declaration for which the transformation functions are
---                    created
---
---    - returns : entry for the lookup-table
-
-buildTransformationFunctions :: XmlTrees -> XmlTree -> TransEnv
-
-buildTransformationFunctions dtdPart n@(NTree (XDTD ELEMENT al) _)
-    = (name, transFct)
-    where
-    name = lookup1 a_name al
-    transFct = lexicographicAttributeOrder
-               `o`
-	       normalizeAttributeValues n dtdPart
-	       `o`
-	       setDefaultAttributeValues n dtdPart
-
-buildTransformationFunctions _ n
-    = error ("buildTransformationFunctions: illegeal parameter:\n" ++ show n)
-
-
-
--- ------------------------------------------------------------
-
-
--- |
--- Sort the attributes of an element in lexicographic order.
---
---    * returns : a function which takes an element (XTag), sorts its
---                  attributes in lexicographic order and returns the changed element
-
-lexicographicAttributeOrder :: XmlFilter
-lexicographicAttributeOrder
-    = processAttrl sortAttrl
-      where
-      sortAttrl al
-	  = map (al !!) ixs
-	    where
-	    ns  = map nameOf al
-	    ixs = map snd . sort . zip ns $ [(0::Int)..]
-
--- |
--- Normalize attribute values.
---
---    * returns : a function which takes an element (XTag), normalizes its
---                  attribute values and returns the changed element
-
-normalizeAttributeValues :: XmlTree -> XmlTrees -> XmlFilter
-normalizeAttributeValues elemDescr@(NTree (XDTD ELEMENT _) _) dtdPart
-    = processAttr normalizeAttr
-      where
-      elemName     = valueOfDTD a_name elemDescr
-      declaredAtts = isAttlistOfElement elemName $$ dtdPart
-
-      normalizeAttr :: XmlFilter
-      normalizeAttr att
-	  = normalizeAttrValue (if null attDescr
-				then Nothing
-				else Just (head attDescr)) att
-	    where
-	    attDescr = filter (\ x -> (valueOfDTD a_value x) == nameOf att) declaredAtts
-
-      normalizeAttrValue :: Maybe XmlTree -> XmlFilter
-      normalizeAttrValue descr
-	  = modifyChildren ((modifyText (normalizeAttributeValue descr) $$) . xmlTreesToText)
-
-normalizeAttributeValues n _
-    = error ("normalizeAttributeValues: illegeal parameter:\n" ++ show n)
-
-
-
--- |
--- Set default attribute values if they are not set.
---
---    * returns : a function which takes an element (XTag), adds missing attribute
---                  defaults and returns the changed element
-
-setDefaultAttributeValues :: XmlTree -> XmlTrees -> XmlFilter
-setDefaultAttributeValues elemDescr@(NTree (XDTD ELEMENT _) _) dtdPart
-    = seqF (map setDefault defaultAtts)
-      where
-						-- select the element name from the dtd
-      elemName = valueOfDTD a_name elemDescr
-
-      defaultAtts = ( isFixedAttrKind		-- select attributes with default values
-		      `orElse`
-		      isDefaultAttrKind
-		    )
-                    $$
-		    (isAttlistOfElement elemName $$ dtdPart)
-
-      setDefault	:: XmlTree -> XmlFilter
-      setDefault attrDescr			-- add the default attributes
-	  = ( addAttr attName defaultValue	-- to tag nodes with missing attributes
-	      `whenNot`
-	      hasAttr attName
-	    )
-	    `when`
-	    isXTag
-	    where
-	    attName      = valueOfDTD a_value   attrDescr
-	    defaultValue = valueOfDTD a_default attrDescr
-
-
-setDefaultAttributeValues n _
-    = error ("setDefaultAttributeValues: illegeal parameter:\n" ++ show n)
-
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Validator-DocValidation.html b/doc/hxt-filter/src/Text-XML-HXT-Validator-DocValidation.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Validator-DocValidation.html +++ /dev/null @@ -1,547 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- This module provides functions for validating XML Documents represented as
--- XmlTree.
-
--- Unlike other popular XML validation tools the validation process returns
--- a list of errors instead of aborting after the first error was found.
-
-
--- Before the document is validated, a lookup-table is build on the basis of
--- the DTD which maps element names to their validation functions.
--- After this initialization phase the whole document is traversed in preorder
--- and every element is validated by the XmlFilter from the lookup-table.
-
--- Special namings in source code:
---
---  - nd - XDTD node
---
---  - n  - XTag node
---
--- Author : .\\artin Schmidt
-
-module Text.XML.HXT.Validator.DocValidation
-    ( validateDoc
-    )
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.Validator.AttributeValueValidation
-import Text.XML.HXT.Validator.XmlRE
-
-import Data.Maybe
-
--- |
--- Lookup-table which maps element names to their validation functions. The
--- validation functions are XmlFilters.
-
-type ValiEnvTable	= [ValiEnv]
-type ValiEnv 		= (ElemName, ValFct)
-type ElemName		= String
-type ValFct		= XmlFilter
-
-
-
--- ------------------------------------------------------------
-
-
--- |
--- Validate a document.
---
---    * 1.parameter dtdPart :  the DTD subset (Node @DOCTYPE@) of the XmlTree
---
---    - 2.parameter doc :  the document subset of the XmlTree
---
---    - returns : a list of errors
-
-validateDoc :: XmlTree -> XmlTree -> XmlTrees
-validateDoc dtdPart doc
-    = traverseTree valTable doc
-    where
-    valTable = {-# SCC "buildAllValFcts" #-} buildAllValidationFunctions dtdPart
-
-
--- |
--- Traverse the XmlTree in preorder.
---
---    * 1.parameter valiEnv :  lookup-table which maps element names to their validation functions
---
---    - returns : list of errors
-
-traverseTree :: ValiEnvTable -> XmlFilter
-traverseTree valiEnv n@(NTree (XTag name _) cs)
-    = (valFct n) ++ concatMap (traverseTree valiEnv) cs
-      where
-      valFct :: XmlFilter
-      valFct
-          = case (lookup (qualifiedName name) valiEnv) of
-	    Nothing -> err ("Element " ++ show (qualifiedName name) ++ " not declared in DTD.")
-	    Just f  -> f
-
-traverseTree _ _ = []
-
-
-
--- ------------------------------------------------------------
-
-
--- |
--- Build all validation functions.
---
---    * 1.parameter dtdPart :  DTD subset, root node should be of type @DOCTYPE@
---
---    - returns : lookup-table which maps element names to their validation functions
-
-buildAllValidationFunctions :: XmlTree -> ValiEnvTable
-buildAllValidationFunctions dtdPart
-    = buildValidateRoot dtdPart
-      :
-      -- construct a list of validation filters for all element declarations
-      map (buildValidateFunctions dtdNodes) (isElement $$ dtdNodes)
-      where
-      dtdNodes = getChildren dtdPart
-
-
--- |
--- Build a validation function for the document root. By root node @\/@
--- is meant, which is the topmost dummy created by the parser.
---
---    * 1.parameter dtdPart :  DTD subset, root node should be of type @DOCTYPE@
---
---    - returns : entry for the lookup-table
-
-buildValidateRoot :: XmlTree -> ValiEnv
-buildValidateRoot (NTree (XDTD DOCTYPE al) _)
-    = (t_root, valFct)
-      where
-      name = lookup1 a_name al
-
-      valFct :: XmlFilter
-      valFct nd@(NTree (XTag _ _) cs)
-          = if msg == ""
-            then []
-            else err ("Root Element must be " ++ show name ++ ". " ++ msg) nd
-	    where
-	    re = re_sym (name)
-	    msg = checkRE (matches re cs)
-
-      valFct n = error ("buildValidateRoot: illegeal parameter:\n" ++ show n)
-
-buildValidateRoot nd
-    = error ("buildValidateRoot: illegeal parameter:\n" ++ show nd)
-
-
--- |
--- Build validation functions for an element.
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter nd :  element declaration for which the validation functions are
---                   created
---
---    - returns : entry for the lookup-table
-
-buildValidateFunctions :: XmlTrees -> XmlTree -> ValiEnv
-
-buildValidateFunctions dtdPart nd@(NTree (XDTD ELEMENT al) _)
-    = (elemName, valFct)
-      where
-      elemName = lookup1 a_name al
-
-      valFct :: XmlFilter
-      valFct = buildContentValidation nd
-               +++
-	       buildAttributeValidation dtdPart nd
-
-buildValidateFunctions _ nd
-    = error ("buildValidateFunctions: illegeal parameter:\n" ++ show nd)
-
-
--- ------------------------------------------------------------
-
-
--- |
--- Build validation functions for the content model of an element.
--- Validity constraint: Element Valid (3 \/ p.18 in Spec)
---
---    * 1.parameter nd :  element declaration for which the content validation functions
---                  are built
---
---    - returns : a function which takes an element (XTag), checks if its
---                  children match its content model and returns a list of errors
-
-buildContentValidation :: XmlTree -> XmlFilter
-buildContentValidation nd@(NTree (XDTD ELEMENT al) _)
-    = contentValidation attrType nd
-      where
-      attrType = lookup1 a_type al
-
-
-      -- Delegates construction of the validation function on the basis of the
-      -- content model type
-      contentValidation :: String -> XmlTree -> XmlFilter
-      contentValidation typ (NTree (XDTD ELEMENT _) cs)
-          | typ == k_pcdata   = contentValidationPcdata
-          | typ == k_empty    = contentValidationEmpty
-          | typ == k_any      = contentValidationAny
-          | typ == v_children = contentValidationChildren cs
-          | typ == v_mixed    = contentValidationMixed cs
-          | otherwise         = error ("contentValidation: unknown type: " ++ show typ)
-
-      contentValidation _ nd'
-          = error ("contentValidation: illegeal parameter:\n" ++ show nd')
-
-
-      -- Checks #PCDATA content models
-      contentValidationPcdata :: XmlFilter
-      contentValidationPcdata n@(NTree (XTag name _) cs)
-          = if msg == ""
-            then []
-            else err ("The content of element "++ show (qualifiedName name) ++
-	              " must match (#PCDATA). "++ msg) n
-	    where
-	    re = re_rep (re_sym k_pcdata)
-	    msg = checkRE (matches re cs)
-
-      contentValidationPcdata n
-          = error ("contentValidationPcdata: illegeal parameter:\n" ++ show n)
-
-
-      -- Checks EMPTY content models
-      contentValidationEmpty :: XmlFilter
-      contentValidationEmpty n@(NTree (XTag name _) cs)
-          = if msg == ""
-            then []
-            else err ("The content of element " ++ show (qualifiedName name) ++
-	              " must match EMPTY. " ++ msg) n
-	    where
-	    re = re_unit
-	    msg = checkRE (matches re cs)
-
-      contentValidationEmpty n
-          = error ("contentValidationEmpty: illegeal parameter:\n" ++ show n)
-
-
-      -- Checks ANY content models
-      contentValidationAny :: XmlFilter
-      contentValidationAny n@(NTree (XTag name _) cs)
-          = if msg == ""
-            then []
-            else err ("The content of element " ++ show (qualifiedName name) ++
-	              " must match ANY. " ++ msg) n
-	    where
-	    re = re_rep (re_dot)
-	    msg = checkRE (matches re cs)
-
-      contentValidationAny n
-          = error ("contentValidationAny: illegeal parameter:\n" ++ show n)
-
-
-      -- Checks "children" content models
-      contentValidationChildren :: XmlTrees -> XmlFilter
-      contentValidationChildren cm n@(NTree (XTag name _) cs)
-          = if msg == ""
-            then []
-            else err ("The content of element " ++ show (qualifiedName name) ++
-	              " must match " ++ printRE re ++ ". " ++ msg) n
-	    where
-	    re = createRE (head cm)
-	    msg = checkRE (matches re cs)
-
-      contentValidationChildren _ n
-          = error ("contentValidationChildren: illegeal parameter:\n" ++ show n)
-
-
-      -- Checks "mixed content" content models
-      contentValidationMixed :: XmlTrees -> XmlFilter
-      contentValidationMixed cm n@(NTree (XTag name _) cs)
-          = if msg == ""
-            then []
-            else err ("The content of element "++ show (qualifiedName name) ++
-	              " must match " ++ printRE re ++ ". " ++ msg) n
-	    where
-	    re = re_rep (re_alt (re_sym k_pcdata) (createRE (head cm)))
-	    msg = checkRE (matches re cs)
-
-      contentValidationMixed _ n
-          = error ("contentValidationMixed: illegeal parameter:\n" ++ show n)
-
-
-buildContentValidation nd
-    = error ("buildContentValidation: illegeal parameter:\n" ++ show nd)
-
-
-
--- |
--- Build a regular expression from the content model. The regular expression
--- is provided by the module XmlRE.
---
---    * 1.parameter nd :  node of the content model. Expected: @CONTENT@ or
---              @NAME@
---
---    - returns : regular expression of the content model
-
-createRE ::  XmlTree -> RE String
-createRE (NTree (XDTD CONTENT al) cs)
-    = processModifier modifier
-      where
-      modifier = lookup1 a_modifier al
-      kind     = lookup1 a_kind al
-
-      processModifier :: String -> RE String
-      processModifier m
-          | m == v_plus	  = re_plus (processKind kind)
-	  | m == v_star	  = re_rep  (processKind kind)
-	  | m == v_option = re_opt  (processKind kind)
-	  | m == v_null	  = processKind kind
-	  | otherwise     = error ("Unknown modifier: " ++ show m)
-
-      processKind :: String -> RE String
-      processKind k
-          | k == v_seq	  = makeSequence cs
-	  | k == v_choice = makeChoice cs
-	  | otherwise	  = error ("Unknown kind: " ++ show k)
-
-      makeSequence :: XmlTrees -> RE String
-      makeSequence []     = re_unit
-      makeSequence (x:xs) = re_seq (createRE x) (makeSequence xs)
-
-      makeChoice :: XmlTrees -> RE String
-      makeChoice []       = re_zero ""
-      makeChoice (x:xs)   = re_alt (createRE x) (makeChoice xs)
-
-createRE (NTree (XDTD NAME al) _)
-    = re_sym (lookup1 a_name al)
-
-createRE nd
-    = error ("createRE: illegeal parameter:\n" ++ show nd)
-
-
-
--- ------------------------------------------------------------
-
-
-
--- |
--- Build validation functions for the attributes of an element.
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter nd :  element declaration for which the attribute validation functions
---                  are created
---
---    - returns : a function which takes an element (XTag), checks if its
---                  attributes are valid and returns a list of errors
-
-buildAttributeValidation :: XmlTrees -> XmlTree -> XmlFilter
-buildAttributeValidation dtdPart nd =
-    noDoublicateAttributes
-    +++
-    checkNotDeclardAttributes attrDecls nd
-    +++
-    checkRequiredAttributes attrDecls nd
-    +++
-    checkFixedAttributes attrDecls nd
-    +++
-    checkValuesOfAttributes attrDecls dtdPart nd
-    where
-    attrDecls = isAttlist $$ dtdPart
-
-
--- |
--- Validate that all attributes of an element are unique.
--- Well-formdness constraint: Unique AttSpec (3.1 \/ p.19 in Spec)
---
---    - returns : a function which takes an element (XTag), checks if its
---                  attributes are unique and returns a list of errors
-
-noDoublicateAttributes :: XmlFilter
-noDoublicateAttributes n@(NTree (XTag _ _) _)
-    = doubles . reverse $ names
-      where
-      tagname = nameOf n
-      names   = map nameOf . getAttrl $ n
-
-      doubles :: [String] -> XmlTrees
-      doubles []
-	  = []
-      doubles (n1:ns)
-	  = ( if n1 `elem` ns
-	      then err ("Attribute " ++ show n1 ++ " was already specified for element " ++ show tagname ++ ".") n
-	      else []
-	    ) ++ doubles ns
-
-noDoublicateAttributes n
-    = error ("noDoublicateAttributes: illegeal parameter:\n" ++ show n)
-
-
--- |
--- Validate that all \#REQUIRED attributes are provided.
--- Validity constraint: Required Attributes (3.3.2 \/ p.28 in Spec)
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter nd :  element declaration which attributes have to be checked
---
---    - returns : a function which takes an element (XTag), checks if all
---                  required attributes are provided and returns a list of errors
-
-checkRequiredAttributes :: XmlTrees -> XmlTree -> XmlFilter
-checkRequiredAttributes attrDecls (NTree (XDTD ELEMENT al) _)
-    = checkRequired requiredAtts
-      where
-      elemName     = lookup1 a_name al
-      requiredAtts = isRequiredAttrKind $$ (isAttlistOfElement elemName $$ attrDecls)
-
-
-      checkRequired :: XmlTrees -> XmlFilter
-      checkRequired ((NTree (XDTD ATTLIST al') _):xs) n@(NTree (XTag name _) _)
-          = if satisfies (hasAttr attName) n
-	    then checkRequired xs n
-	    else err ("Attribute " ++ show attName ++ " must be declared for element type " ++
-	             show (qualifiedName name) ++ ".") n
-	         ++
-		 checkRequired xs n
-	    where
-	    attName = lookup1 a_value al'
-
-      checkRequired [] _ = []
-
-      checkRequired nd n
-          = error ("checkRequired: illegeal parameter:\n" ++ show nd ++ show n)
-
-
-checkRequiredAttributes _ nd
-    = error ("checkRequiredAttributes: illegeal parameter:\n" ++ show nd)
-
-
-
--- |
--- Validate that \#FIXED attributes match the default value.
--- Validity constraint: Fixed Attribute Default (3.3.2 \/ p.28 in Spec)
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter nd :  element declaration which attributes have to be checked
---
---    - returns : a function which takes an element (XTag), checks if all
---                  fixed attributes match the default value and returns a list of errors
-
-checkFixedAttributes :: XmlTrees -> XmlTree -> XmlFilter
-checkFixedAttributes attrDecls (NTree (XDTD ELEMENT al) _)
-    = checkFixed fixedAtts
-      where
-      elemName  = lookup1 a_name al
-      fixedAtts = isFixedAttrKind $$ (isAttlistOfElement elemName $$ attrDecls)
-
-
-      checkFixed :: XmlTrees -> XmlFilter
-      checkFixed (x@(NTree (XDTD ATTLIST al') _):xs) n@(NTree (XTag name _) _)
-          = if satisfies (hasAttr attName) n
-	    then if attValue == fixedValue
-	         then checkFixed xs n
-	         else err ("Attribute " ++ show attName ++ " of element " ++ show (qualifiedName name) ++
-		           " with value " ++ show attValue ++ " must have a value of " ++
-			   show fixedValue ++ ".") n
-	              ++
-		      checkFixed xs n
-	    else checkFixed xs n
-	    where
-	    attName    = lookup1 a_value al'
-	    fixedValue = normalizeAttributeValue (Just x) (lookup1 a_default al')
-	    attValue   = normalizeAttributeValue (Just x) (valueOf attName n)
-
-      checkFixed [] _ = []
-
-      checkFixed nd n
-          = error ("checkFixed: illegeal parameter:\n" ++ show nd ++ show n)
-
-
-checkFixedAttributes _ nd
-    = error ("checkFixedAttributes: illegeal parameter:\n" ++ show nd)
-
-
--- |
--- Validate that an element has no attributes which are not declared.
--- Validity constraint: Attribute Value Type (3.1 \/ p.19 in Spec)
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter nd :  element declaration which attributes have to be checked
---
---    - returns : a function which takes an element (XTag), checks if all
---                  attributes are declared and returns a list of errors
-
-checkNotDeclardAttributes :: XmlTrees -> XmlTree -> XmlFilter
-checkNotDeclardAttributes attrDecls elemDescr
-    = checkNotDeclared
-      where
-      elemName = valueOfDTD a_name elemDescr
-      decls    = isAttlistOfElement elemName $$ attrDecls
-
-      checkNotDeclared :: XmlFilter
-      checkNotDeclared n
-	  = ( isXTag
-	      `guards`
-	      cat (map (searchForDeclaredAtt elemName decls) (getAttrl n))
-	    ) n
-
-      searchForDeclaredAtt :: String -> XmlTrees -> XmlTree -> XmlFilter
-      searchForDeclaredAtt name ((NTree (XDTD ATTLIST al') _):xs) att
-          = if (lookup1 a_value al') == nameOf att
-            then none
-	    else searchForDeclaredAtt name xs att
-
-      searchForDeclaredAtt name [] (NTree (XAttr attrName) _)
-          = err ("Attribute " ++ show (qualifiedName attrName) ++ " of element " ++ show name ++ " is not declared in DTD.")
-
-      searchForDeclaredAtt _ nd a
-          = error ("searchForDeclaredAtt: illegeal paramter:\n" ++ show nd ++ show a)
-
--- |
--- Validate that the attribute value meets the lexical constraints of its type.
--- Validity constaint: Attribute Value Type (3.1 \/ p.19 in Spec)
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter nd :  element declaration which attributes have to be checked
---
---    - returns : a function which takes an element (XTag), checks if all
---                  attributes meet the lexical constraints and returns a list of errors
-
-checkValuesOfAttributes :: XmlTrees -> XmlTrees -> XmlTree -> XmlFilter
-checkValuesOfAttributes attrDecls dtdPart elemDescr
-    = checkValues
-      where
-      elemName = valueOfDTD a_name elemDescr
-      decls    = isAttlistOfElement elemName $$ attrDecls
-
-      checkValues :: XmlFilter
-      checkValues n
-          = ( isXTag
-	      `guards`
-	      cat (map (checkValue decls) (getAttrl n))
-	    ) n
-
-      checkValue :: XmlTrees -> XmlTree -> XmlFilter
-      checkValue (attrDecl@(NTree (XDTD ATTLIST al') _):xs) att
-          = if (lookup1 a_value al') == nameOf att
-            then checkAttributeValue dtdPart attrDecl
-	    else checkValue xs att
-
-      checkValue [] _
-          = none  -- undeclared attribute, reported by separate function
-
-      checkValue n _
-          = error ("checkValue: illegeal parameter:\n" ++ show n)
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Validator-IdValidation.html b/doc/hxt-filter/src/Text-XML-HXT-Validator-IdValidation.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Validator-IdValidation.html +++ /dev/null @@ -1,278 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- This module provides functions for checking special ID/IDREF/IDREFS constraints.
-
--- Checking special ID/IDREF/IDREFS constraints means:
---
---  - checking that all ID values are unique.
---
---  - checking that all IDREF/IDREFS values match the value of some ID attribute
---
-
-
--- ID-Validation should be started before or after validating the document.
-
-
--- First all nodes with ID attributes are collected from the document, then
--- it is validated that values of ID attributes do not occure more than once.
--- During a second iteration over the document it is validated that there exists
--- an ID attribute value for IDREF/IDREFS attribute values.
-
--- Special namings in source code:
---
---  - nd - XDTD node
---
---  - n  - XTag node
---
--- Author : .\\artin Schmidt
-
-module Text.XML.HXT.Validator.IdValidation
-    ( validateIds
-    )
-where
-
-
-import Text.XML.HXT.DOM.XmlTree
-import Text.XML.HXT.Validator.AttributeValueValidation
-
-
-
--- |
--- Lookup-table which maps element names to their validation functions. The
--- validation functions are XmlFilters.
-
-type IdEnvTable		= [IdEnv]
-type IdEnv 		= (ElemName, IdFct)
-type ElemName		= String
-type IdFct		= XmlFilter
-
-
-
--- |
--- Perform the validation of the ID/IDREF/IDREFS constraints.
---
---    * 1.parameter dtdPart :  the DTD subset (Node @DOCTYPE@) of the XmlTree
---
---    - 2.parameter doc :  the document subset of the XmlTree
---
---    - returns : a list of errors
-
-validateIds :: XmlTree -> XmlTree -> XmlTrees
-validateIds dtdPart doc
-    = {-# SCC "checkForUniqueIds" #-} checkForUniqueIds idNodeList dtdNodes
-      ++
-      {-# SCC "checkIdReferences" #-} checkIdReferences idRefEnv doc
-      where
-      idEnv      = buildIdCollectorFcts dtdNodes
-      idRefEnv   = buildIdrefValidationFcts dtdNodes idNodeList
-      idNodeList = traverseTree idEnv doc
-      dtdNodes   = getChildren dtdPart
-
-
--- |
--- Traverse the XmlTree in preorder.
---
---    * 1.parameter idEnv :  lookup-table which maps element names to their validation functions
---
---    - returns : list of errors
-
-traverseTree :: IdEnvTable -> XmlFilter
-traverseTree idEnv n@(NTree (XTag name _) cs)
-    = (idFct n) ++ concatMap (traverseTree idEnv) cs
-      where
-      idFct :: XmlFilter
-      idFct
-          = case (lookup (qualifiedName name) idEnv) of
-	    Nothing -> none
-	    Just f  -> f
-
-traverseTree _ _ = []
-
-
-
--- |
--- Returns the value of an element's ID attribute. The attribute name has to be
--- retrieved first from the DTD.
---
---    * 1.parameter dtdPart :  list of ID attribute definitions from the DTD
---
---    - 2.parameter n :  element which ID attribute value should be returned
---
---    - returns : normalized value of the ID attribute
-
-getIdValue :: XmlTrees -> XmlTree -> String
-getIdValue (x@(NTree (XDTD ATTLIST al) _):xs) n@(NTree (XTag name _al') _)
-    = if (qualifiedName name) == elemName
-      then attrValue
-      else getIdValue xs n
-      where
-      elemName  = lookup1 a_name al
-      attrName  = lookup1 a_value al
-      attrValue = normalizeAttributeValue (Just x) (valueOf attrName n)
-
-getIdValue _ _ = ""
-
-
-
--- ------------------------------------------------------------
-
-
--- |
--- Build collector functions which return XTag nodes with ID attributes from
--- a document.
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - returns : lookup-table which maps element names to their collector function
-
-buildIdCollectorFcts :: XmlTrees -> IdEnvTable
-buildIdCollectorFcts dtdPart
-    = map (buildIdCollectorFct) (isIdAttrType $$ dtdPart)
-      where
-      buildIdCollectorFct :: XmlTree -> IdEnv
-      buildIdCollectorFct (NTree (XDTD ATTLIST al) _)
-          = (elemName, hasAttr attrName)
-            where
-            elemName = lookup1 a_name al
-            attrName = lookup1 a_value al
-
-      buildIdCollectorFct nd
-          = error ("buildIdCollectorFct: illegeal parameter:\n" ++ show nd)
-
-
--- |
--- Build validation functions for checking if IDREF\/IDREFS values match a value
--- of some ID attributes.
---
---    * 1.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - 2.parameter idNodeList :  list of all XTag nodes with ID attributes
---
---    - returns : lookup-table which maps element names to their validation function
-
-buildIdrefValidationFcts :: XmlTrees -> XmlTrees -> IdEnvTable
-buildIdrefValidationFcts dtdPart idNodeList
-    = map buildElemValidationFct elements
-      where
-      elements    = isElement $$ dtdPart
-      idValueList = getIdValues (isIdAttrType $$ dtdPart)
-
-      getIdValues :: XmlTrees -> [String]
-      getIdValues idAttrTypes
-          = map (getIdValue idAttrTypes) idNodeList
-
-
-      buildElemValidationFct :: XmlTree -> IdEnv
-      buildElemValidationFct (NTree (XDTD ELEMENT al) _)
-          = (elemName, buildIdrefValidationFct idRefAttrTypes)
-	  where
-	  elemName = lookup1 a_name al
-	  idRefAttrTypes = isIdRefAttrType $$ (isAttlistOfElement elemName) $$ dtdPart
-
-      buildElemValidationFct nd
-          = error ("buildIdrefValidationFct: illegeal parameter:\n" ++ show nd)
-
-
-      buildIdrefValidationFct :: XmlTrees -> XmlFilter
-      buildIdrefValidationFct (nd@(NTree (XDTD ATTLIST al) _):xs)
-          = checkIdref +++ buildIdrefValidationFct xs
-            where
-            attrName = lookup1 a_value al
-	    attrType = lookup1 a_type al
-
-            checkIdref :: XmlFilter
-            checkIdref n@(NTree (XTag name _) _)
-                = if satisfies (hasAttr attrName) n
-	          then if attrType == k_idref
-		       then checkValueDeclared n attrValue
-		       else let valueList = words attrValue
-		            in if null valueList
-		               then err ("Attribute " ++ show attrName ++
-					 " of Element " ++ show (qualifiedName name) ++
-					 " must have at least one name.") n
-		               else concatMap (checkValueDeclared n) (words attrValue)
-	          else []
-		  where
-		  attrValue = normalizeAttributeValue (Just nd) (valueOf attrName n)
-
-	    checkIdref _ = []
-
-
-	    checkValueDeclared :: XmlTree -> String -> XmlTrees
-	    checkValueDeclared n@(NTree (XTag _ _) _) attrValue
-	        = if attrValue `elem` idValueList
-		  then []
-		  else err ("An Element with identifier " ++ show attrValue ++
-		            " must appear in the document.") n
-
-            checkValueDeclared _ _ = []
-
-      buildIdrefValidationFct []
-          = none
-
-      buildIdrefValidationFct nd
-          = error ("buildIdCollectorFct: illegeal parameter:\n" ++ show nd)
-
-
--- ------------------------------------------------------------
-
-
--- |
--- Validate that all ID values are unique within a document.
--- Validity constraint: ID (3.3.1 \/p. 25 in Spec)
---
---    * 1.parameter idNodeList :  list of all XTag nodes with ID attributes
---
---    - 2.parameter dtdPart :  the children of the @DOCTYPE@ node
---
---    - returns : a list of errors
-
-checkForUniqueIds :: XmlTrees -> XmlTrees -> XmlTrees
-checkForUniqueIds idNodeList dtdPart
-    = checkForUniqueId idNodeList []
-      where
-      idAttrTypes = isIdAttrType $$ dtdPart
-
-      checkForUniqueId :: XmlTrees -> [String] -> XmlTrees
-      checkForUniqueId (x@(NTree (XTag name _) _):xs) used
-          = if attrValue `elem` used
-	    then err ("Attribute value " ++ show attrValue ++ " of type ID for element " ++
-	              show (qualifiedName name) ++ " must be unique within the document.") x
-		 ++
-		 checkForUniqueId xs used
-
-	    else checkForUniqueId xs (attrValue : used)
-	    where
-	    attrValue = getIdValue (isAttlistOfElement (qualifiedName name) $$ idAttrTypes) x
-
-      checkForUniqueId _ _ = []
-
-
-
--- |
--- Validate that all IDREF\/IDREFS values match the value of some ID attribute.
--- Validity constraint: IDREF (3.3.1 \/ p.26 in Spec)
---
---    * 1.parameter idRefEnv :  lookup-table which maps element names to their validation function
---
---    - 2.parameter doc :  the document to validate
---
---    - returns : a list of errors
-
-checkIdReferences :: IdEnvTable -> XmlTree -> XmlTrees
-checkIdReferences idRefEnv doc
-    = traverseTree idRefEnv doc
-
-
-
-
-
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Validator-RE.html b/doc/hxt-filter/src/Text-XML-HXT-Validator-RE.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Validator-RE.html +++ /dev/null @@ -1,340 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- A module for regular expression matching based on derivatives of regular expressions.
---
--- The code was taken from Joe English (<http://www.flightlab.com/~joe/sgml/validate.html>).
--- Tested and extended by Martin Schmidt.
---
--- Further references for the algorithm:
---
--- Janusz A. Brzozowski.
---
--- 	Derivatives of Regular Expressions. Journal of the ACM, Volume 11, Issue 4, 1964. 
---
--- Mark Hopkins.
---
---	Regular Expression Package. Posted to comp.compilers, 1994.
---      Available per FTP at <ftp://iecc.com/pub/file/regex.tar.gz>.
-
-
-
-module Text.XML.HXT.Validator.RE
-    ( RE(..)
-
-    , re_unit
-    , re_zero
-    , re_sym
-    , re_rep
-    , re_plus
-    , re_opt
-    , re_seq
-    , re_alt
-    , re_dot
-
-    , checkRE
-    , matches
-    , nullable
-    , printRE
-  )
-where
-
--- |
--- Data type for regular expressions.
-
-data RE a =
-	RE_ZERO	String		--' L(0)   = {} (empty set)
-	| RE_UNIT		--' L(1)   = { [] } (empty sequence)
-	| RE_SYM a		--' L(x)   = { [x] }
-	| RE_DOT                --' accept any single symbol
-	| RE_REP (RE a)		--' L(e*)  = { [] } `union` L(e+)
-	| RE_PLUS (RE a)	--' L(e+)  = { x ++ y | x <- L(e), y <- L(e*) }
-	| RE_OPT (RE a)		--' L(e?)  = L(e) `union` { [] }
-	| RE_SEQ (RE a) (RE a)	--' L(e,f) = { x ++ y | x <- L(e), y <- L(f) }
-	| RE_ALT (RE a) (RE a)	--' L(e|f) = L(e) `union` L(f)
-	deriving (Show, Eq)
-
-
-
--- ------------------------------------------------------------
--- Constructor functions to simplify regular expressions when constructing them.
-
--- |
--- Constructs a regular expression for an empty set.
---
---    * 1.parameter errMsg :  error message
---
---    - returns : regular expression for an empty set
-
-re_zero			:: String -> RE a
-re_zero m		= RE_ZERO m
-
-
--- |
--- Constructs a regular expression for an empty sequence.
---
---    - returns : regular expression for an empty sequence
-
-re_unit			:: RE a
-re_unit			= RE_UNIT
-
-
--- |
--- Constructs a regular expression for accepting a symbol
---
---    * 1.parameter sym :  the symbol to be accepted
---
---    - returns : regular expression for accepting a symbol
-
-re_sym			:: a -> RE a
-re_sym x		= RE_SYM x
-
-
--- |
--- Constructs a regular expression for accepting any singel symbol
---
---    - returns : regular expression for accepting any singel symbol
-
-re_dot			:: RE a
-re_dot			= RE_DOT
-
-
--- |
--- Constructs an optional repetition (*) of a regular expression
---
---    * 1.parameter re_a :  regular expression to be repeted
---
---    - returns : new regular expression
-
-re_rep			:: RE a -> RE a
-re_rep RE_UNIT		= RE_UNIT
-re_rep (RE_ZERO _)	= RE_UNIT
-re_rep e@(RE_REP _)	= RE_REP (rem_rep e)		-- remove nested reps
-re_rep e@(RE_ALT _ _)	= RE_REP (rem_rep e)		-- remove nested reps in alternatives
-re_rep e		= RE_REP e
-
--- |
--- remove redundant nested *'s in RE
--- theoretically this is unneccessary,
--- but without this simplification the runtime can increase exponentally
--- when computing deltas, e.g. for a** or (a|b*)* which is the same as (a|b)*
-
-rem_rep			:: RE a -> RE a
-rem_rep (RE_ALT e1 e2)	= RE_ALT (rem_rep e1) (rem_rep e2)
-rem_rep (RE_REP e1)	= rem_rep e1
-rem_rep e1		= e1
-
-
--- |
--- Constructs a repetition (+) of a regular expression
---
---    * 1.parameter re_a :  regular expression to be repeted
---
---    - returns : new regular expression
-
-re_plus			:: RE a -> RE a
-re_plus RE_UNIT		= RE_UNIT
-re_plus (RE_ZERO m) 	= RE_ZERO m
-re_plus e		= RE_PLUS e
-
-
--- |
--- Constructs an option (?) of a regular expression
---
---    * 1.parameter re_a :  regular expression to be optional
---
---    - returns : new regular expression
-
-re_opt			:: RE a -> RE a
-re_opt RE_UNIT		= RE_UNIT
-re_opt (RE_ZERO _)	= RE_UNIT
-re_opt e		= RE_OPT e
-
-
--- |
--- Constructs a sequence (,) of two regular expressions
---
---    * 1.parameter re_a :  first regular expression in sequence
---
---    - 2.parameter re_b :  second regular expression in sequence
---
---    - returns : new regular expression
-
-re_seq			:: RE a -> RE a -> RE a
-re_seq (RE_ZERO m) _	= RE_ZERO m
-re_seq RE_UNIT f	= f
-re_seq _ (RE_ZERO m)	= RE_ZERO m
-re_seq e RE_UNIT	= e
-re_seq e f		= RE_SEQ e f
-
-
--- |
--- Constructs an alternative (|) of two regular expressions
---
---    * 1.parameter re_a :  first regular expression of alternative
---
---    - 2.parameter re_b :  second regular expression of alternative
---
---    - returns : new regular expression
-
-re_alt			:: RE a -> RE a -> RE a
-re_alt (RE_ZERO _) f	= f
-re_alt e (RE_ZERO _)	= e
-re_alt e f		= RE_ALT e f
-
-
-
--- ------------------------------------------------------------
-
-
--- |
--- Checks if a regular expression matches the empty sequence.
---
--- nullable e == [] `in` L(e)
---
--- This check indicates if a regular expression fits to a sentence or not.
---
---    * 1.parameter re :  regular expression to be checked
---
---    - returns : true if regular expression matches the empty sequence,
---                otherwise false
-
-nullable		::  (Show a) => RE a -> Bool
-nullable (RE_ZERO _)	= False
-nullable RE_UNIT	= True
-nullable (RE_SYM _)	= False
-nullable (RE_REP _)	= True
-nullable (RE_PLUS e)	= nullable e
-nullable (RE_OPT _)	= True
-nullable (RE_SEQ e f)	= nullable e && nullable f
-nullable (RE_ALT e f)	= nullable e || nullable f
-nullable RE_DOT		= False
-
-
--- |
--- Derives a regular expression with respect to one symbol.
---
--- L(delta e x) = x \ L(e)
---
---    * 1.parameter re :  regular expression to be derived
---
---    - 2.parameter sym :  the symbol on which the regular expression is applied
---
---    - returns : the derived regular expression
-
-delta :: (Eq a, Show a) => RE a -> a -> RE a
-delta re x = case re of
-	RE_ZERO	_		-> re					-- re_zero m
-	RE_UNIT			-> re_zero ("Symbol " ++ show x ++ " unexpected.")
-	RE_SYM sym
-		| x == sym	-> re_unit
-		| otherwise	-> re_zero ("Symbol " ++ show sym ++ " expected, but symbol " ++ show x ++ " found.")
-	RE_REP  e		-> re_seq (delta e x) re		-- (re_rep e)
-	RE_PLUS e		-> re_seq (delta e x) (re_rep e)
-	RE_OPT  e		-> delta e x
-	RE_SEQ  e f
-		| nullable e	-> re_alt (re_seq (delta e x) f) (delta f x)
-		| otherwise	-> re_seq (delta e x) f
-	RE_ALT  e f		-> re_alt (delta e x) (delta f x)
-	RE_DOT			-> re_unit
-
-
--- |
--- Derives a regular expression with respect to a sentence.
---
---    * 1.parameter re :  regular expression
---
---    - 2.parameter s :  sentence to which the regular expression is applied
---
---    - returns : the derived regular expression
-
-matches :: (Eq a, Show a) => RE a -> [a] -> RE a
-matches e = foldl delta e
-
-
--- |
--- Checks if an input matched a regular expression. The function should be
--- called after matches.
---
--- Was the sentence used in @matches@ in the language of the regular expression?
--- -> matches e s == s `in` L(e)?
---
---    * 1.parameter re :  the derived regular expression
---
---    - returns : empty String if input matched the regular expression, otherwise
---               an error message is returned
-
-checkRE :: (Show a) => RE a -> String
-checkRE (RE_UNIT)	= ""
-checkRE (RE_ZERO m)	= m
-checkRE re
-	| nullable re	= ""
-	| otherwise	= "Input must match " ++ printRE re
-
-
-
--- ------------------------------------------------------------
-
-
-
--- |
--- Constructs a string representation of a regular expression.
---
---    * 1.parameter re :  a regular expression
---
---    - returns : the string representation of the regular expression
-
-printRE :: (Show a) => RE a -> String
-printRE re'
-    = "( " ++ printRE1 re' ++ " )"
-      where
-      printRE1 :: (Show a) => RE a -> String
-      printRE1 re = case re of
-	  RE_ZERO m				-> "ERROR: " ++ m
-	  RE_UNIT				-> ""
-	  RE_SYM sym				-> show sym
-	  RE_DOT				-> "."
-	  RE_REP e
-	      | isSingle e			-> printRE1 e ++ "*"
-	      | otherwise			-> "(" ++ printRE1 e ++ ")*"
-	  RE_PLUS e
-	      | isSingle e			-> printRE1 e ++ "+"
-	      | otherwise			-> "(" ++ printRE1 e ++ ")+"
-	  RE_OPT e
-	      | isSingle e			-> printRE1 e ++ "?"
-	      | otherwise			-> "(" ++ printRE1 e ++ ")?"
-	  RE_SEQ e f
-	      | isAlt e  && not (isAlt f)	-> "(" ++ printRE1 e ++ ") , " ++ printRE1 f
-	      | not (isAlt e) && isAlt f	-> printRE1 e ++ " , (" ++ printRE1 f ++ ")"
-	      | isAlt e  && isAlt f		-> "(" ++ printRE1 e ++ ") , (" ++ printRE1 f ++ ")"
-	      | otherwise			-> printRE1 e ++ " , " ++ printRE1 f
-	  RE_ALT e f
-	      | isSeq e  && not (isSeq f)	-> "(" ++ printRE1 e ++ ") | " ++ printRE1 f
-	      | not (isSeq e) && isSeq f	-> printRE1 e ++ " | (" ++ printRE1 f ++ ")"
-	      | isSeq e  && isSeq f		-> "(" ++ printRE1 e ++ ") | (" ++ printRE1 f ++ ")"
-	      | otherwise			-> printRE1 e ++ " | " ++ printRE1 f
-
-
-      isSingle :: RE a -> Bool
-      isSingle (RE_ZERO _)    = True
-      isSingle RE_UNIT        = True
-      isSingle (RE_SYM _)     = True
-      isSingle _              = False
-
-
-      isSeq :: RE a -> Bool
-      isSeq (RE_SEQ _ _)      = True
-      isSeq _                 = False
-
-
-      isAlt :: RE a -> Bool
-      isAlt (RE_ALT _ _)      = True
-      isAlt _                 = False
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Validator-Validation.html b/doc/hxt-filter/src/Text-XML-HXT-Validator-Validation.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Validator-Validation.html +++ /dev/null @@ -1,74 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- This module provides a state filter as a main function for validating XML documents.
---
--- The real validation is done with pure filters from module 'Text.XML.HXT.Validator.ValidationFilter'
---
--- Author : .\\artin Schmidt
-
-module Text.XML.HXT.Validator.Validation
-    ( getValidatedDoc
-    , module Text.XML.HXT.Validator.ValidationFilter
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlTree
-import Text.XML.HXT.DOM.XmlState
-
-import Text.XML.HXT.Validator.ValidationFilter
-
-import Text.XML.HXT.Parser.XmlOutput
-    ( traceTree
-    , traceSource
-    , traceMsg
-    )
-
--- ------------------------------------------------------------
-
--- |
--- monadic filter for validating and transforming a wellformed document.
---
--- the "main" function for validation.
---
--- the input tree must consist of a root node with a complete document and DTD.
--- Result is the single element list containing same tree but tranformed with respect to the DTD,
--- or, in case of errors, the root with an empty list of children
-
-getValidatedDoc		:: XmlStateFilter state
-getValidatedDoc
-    = traceMsg 1 "validating document"
-      .>>
-      ( ( runValidation
-	  .>>
-	  traceTree
-	  .>>
-	  traceSource
-	)
-	`whenM` (isRoot .> getChildren)
-      )
-      where
-      runValidation t
-	  = do
-	    issueError $$< res
-	    ( if null errs
-	      then ( traceMsg 1 "transforming validated document"
-		     .>>
-		     liftMf transform
-		   )
-	      else liftMf (setStatus c_err "validating document")
-	      ) t
-	    where
-	    res  = validate t
-	    errs = isXError .> neg isWarning $$ res
-
--- ------------------------------------------------------------
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Validator-ValidationFilter.html b/doc/hxt-filter/src/Text-XML-HXT-Validator-ValidationFilter.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Validator-ValidationFilter.html +++ /dev/null @@ -1,135 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- This module provides functions for validating XML documents represented as
--- XmlTree.
-
--- Unlike other popular XML validation tools the validation functions return
--- a list of errors instead of aborting after the first error was found.
--- 
--- Note: The validation process has been split into validation and transformation!
---       If @validate@ did not report any errors, @transform@
---       should be called, to change the document the way a validating parser
---       is expected to do.
-
---
--- Author : .\\artin Schmidt
-
-module Text.XML.HXT.Validator.ValidationFilter
-    ( getDTDSubset
-    , validate
-    , validateDTD
-    , validateDoc
-    , removeDoublicateDefs
-    , transform
-    )
-
-where
-
-import Text.XML.HXT.DOM.XmlTree
-
-import qualified Text.XML.HXT.Validator.DTDValidation as DTDValidation
-import qualified Text.XML.HXT.Validator.DocValidation as DocValidation
-import qualified Text.XML.HXT.Validator.IdValidation as IdValidation
-import qualified Text.XML.HXT.Validator.DocTransformation as DocTransformation
-
--- |
--- Main validation filter. Check if the DTD and the document are valid.
---
---
---    - returns : a function which expects a complete document as XmlTree input
---                     and returns a list of all errors found.
-
-validate 	:: XmlFilter
-validate	= validateDTD +++ validateDoc
-
--- |
--- Check if the DTD is valid.
---
---
---    - returns : a function which expects an XmlTree from the parser as input
---                     and returns a list of all errors found in the DTD.
-
-validateDTD	:: XmlFilter
-validateDTD
-    = choice [ getDTDSubset
-	       :-> DTDValidation.validateDTD
-	     , this
-               :-> err "Can't validate DTD: There is no DOCTYPE declaration in the document."
-	     ]
--- |
--- Check if the document corresponds to the given DTD.
---
---
---    - returns : a function which expects a complete document as XmlTree input
---                     and returns a list of all errors found in the content part.
-
-validateDoc	:: XmlFilter
-validateDoc t
-    = ( if null dtds
-	then err "Can't validate document: There is no DOCTYPE declaration in the document."
-	else ( DocValidation.validateDoc dtdPart
-               +++
-	       IdValidation.validateIds dtdPart
-	     )
-      ) $ t
-      where
-      dtds = getDTDSubset .> processBottomUp removeDoublicateDefs $ t
-      dtdPart  = head dtds
-
--- |
--- filter for transforming a document with respect to the given DTD.
---
--- Validating parsers
--- are expected to  normalize attribute values and add default values.
--- This function should be called after a successful validation.
---
---
---    - returns : a function which expects a complete XML document tree
---                and returns the transformed XmlTree
-
-transform	:: XmlFilter
-transform
-    = choice [ isRoot
-               :-> transformDoc
-	     , this
-	       :-> fatal "Can't transform document: No document root given"
-	     ]
-      where
-      transformDoc t
-	  | null dtds
-	      = this t
-	  | otherwise
-	      = DocTransformation.transform (head dtds) t
-	  where
-	  dtds = getDTDSubset .> processBottomUp removeDoublicateDefs $ t
-
--- |
--- Removes doublicate declarations from the DTD which first declaration is
--- binding. This is the case for ATTLIST and ENTITY declarations.
---
---
---    - returns : A function that replaces the children of DOCTYPE nodes by a list
---               where all multiple declarations are removed.
-
-removeDoublicateDefs :: XmlFilter
-removeDoublicateDefs
-    = DTDValidation.removeDoublicateDefs
-
---
--- selects the DTD part of a document
--- but only, if there is more than the internal part for the 4 predefined XML entities
-
-getDTDSubset	:: XmlFilter
-getDTDSubset
-    = getChildren .> isDoctype .> hasRootName
-      where
-      hasRootName = isOf (hasEntry a_name . attrlOfDTD)
-
- diff --git a/doc/hxt-filter/src/Text-XML-HXT-Validator-XmlRE.html b/doc/hxt-filter/src/Text-XML-HXT-Validator-XmlRE.html deleted file mode 100644 --- a/doc/hxt-filter/src/Text-XML-HXT-Validator-XmlRE.html +++ /dev/null @@ -1,113 +0,0 @@ - - - - -Haskell Code by HsColour - - - -
-- |
--- A module for regular expression matching, adapted for XML DTDs.
---
--- This module is based on the module RE.
---
--- Author .\\artin Schmidt
-
-module Text.XML.HXT.Validator.XmlRE
-    ( RE
-
-    , checkRE
-    , matches
-    , printRE
-
-    , re_unit
-    , re_zero
-    , re_sym
-    , re_rep
-    , re_plus
-    , re_opt
-    , re_seq
-    , re_alt
-    , re_dot
-    )
-where
-
--- import Debug.Trace(trace)
-
-import Text.XML.HXT.Validator.RE hiding (matches)
-
-import Text.XML.HXT.DOM.XmlTree
-
-import Text.XML.HXT.DOM.EditFilters
-    ( removeComment
-    , removeWhiteSpace
-    )
-
--- |
--- Derives a regular expression with respect to a list of elements.
---
---    * 1.parameter re :  regular expression
---
---    - 2.parameter list :  list of elements to which the regular expression is applied
---
---    - returns : the derived regular expression
-
-matches :: RE String -> XmlTrees -> RE String
-matches re list
-    = foldl delta re (removeUnimportantStuff $$ list)
-      where
-      removeUnimportantStuff :: XmlFilter
-      removeUnimportantStuff = processBottomUp (removeWhiteSpace `o` removeComment)
-      -- trace of growth of REs
-      -- delta' re el = delta (trace (("RE : " ++) . (++ "\n" ) . show $ re) re) el
-
-
--- |
--- Derives a regular expression with respect to one element.
---
--- L(delta e x) = x \ L(e)
---
---    * 1.parameter re :  regular expression to be derived
---
---    - 2.parameter el :  the element on which the regular expression is applied
---
---    - returns : the derived regular expression
-
-delta :: RE String -> XmlTree -> RE String
-delta re el
-    | not (allowed el) = re
-    | otherwise        = case re of
-        RE_ZERO m		 -> re_zero m
-        RE_UNIT			 -> re_zero (elemName el ++" unexpected.")
-        RE_SYM sym
-    	    | sym == k_pcdata	 -> let node = getNode el in
-	                            if ((isXTextNode node) || (isXCdataNode node))
-				    then re_unit
-				    else re_zero ("Character data expected, but "++ elemName el ++" found.")
-       	    | expectedNode el sym -> re_unit
-	    | otherwise           -> re_zero ("Element "++ show sym ++" expected, but "++ elemName el ++" found.")
-        RE_REP e                  -> re_seq (delta e el) (re_rep e)
-        RE_PLUS e                 -> re_seq (delta e el) (re_rep e)
-        RE_OPT e                  -> delta e el
-        RE_SEQ e f
-       	    | nullable e          -> re_alt (re_seq (delta e el) f) (delta f el)
-       	    | otherwise           -> re_seq (delta e el) f
-        RE_ALT e f                -> re_alt (delta e el) (delta f el)
-        RE_DOT                    -> re_unit
-
-    where
-    expectedNode :: XmlTree -> String -> Bool
-    expectedNode (NTree (XTag n _) _) sym = (qualifiedName n) == sym
-    expectedNode _ _			  = False
-
-    elemName :: XmlTree -> String
-    elemName (NTree (XTag n _) _)	= "element "++ show (qualifiedName n)
-    elemName _				= "character data"
-
-    allowed :: XmlTree -> Bool
-    allowed (NTree (XTag _ _) _)	= True
-    allowed (NTree (XText _) _)		= True
-    allowed (NTree (XCdata _) _)	= True
-    allowed _				= False
-
- diff --git a/doc/hxt-filter/src/hscolour.css b/doc/hxt-filter/src/hscolour.css deleted file mode 100644 --- a/doc/hxt-filter/src/hscolour.css +++ /dev/null @@ -1,5 +0,0 @@ -.keyglyph, .layout {color: red;} -.keyword {color: blue;} -.comment, .comment a {color: green;} -.str, .chr {color: teal;} -.keyword,.conid, .varid, .conop, .varop, .num, .cpp, .sel, .definition {} diff --git a/examples/Makefile b/examples/Makefile deleted file mode 100644 --- a/examples/Makefile +++ /dev/null @@ -1,40 +0,0 @@ -# Example Applications -# - -include ../Version.mk - -HXT_HOME = .. - -EXAMPLES = mini hparser hfilter hunit hsvg dtd2haskell -MORE_SAMPLES = blutgraetsche photoalbum -DIST = ../$(DIST_NAME) -DIST_DIR = $(DIST)/examples - -all : - if [ -f $(HXT_HOME)/lib/$(SOFTWARE)/package.conf ] ; \ - then $(MAKE) alllocal ; \ - else $(MAKE) alldist ; \ - fi - -alllocal : - $(foreach i,$(EXAMPLES),$(MAKE) -C $i PKGFLAGS="-ignore-package $(SOFTWARE)-$(LASTVERSION) -package-conf `pwd`/$(HXT_HOME)/lib/$(SOFTWARE)/package.conf -package $(SOFTWARE)" all ;) - -alldist : - $(foreach i,$(EXAMPLES),$(MAKE) -C $i all ;) - -test : - $(foreach i,$(EXAMPLES),$(MAKE) -C $i $@ ;) - -dist : - [ -d $(DIST_DIR) ] || mkdir -p $(DIST_DIR) - $(foreach i,$(EXAMPLES),$(MAKE) -C $i dist DIST=../$(DIST_DIR);) - [ -d $(DIST_DIR)/xhtml ] || mkdir -p $(DIST_DIR)/xhtml - cp xhtml/xhtml*.dtd xhtml/xhtml*.ent xhtml/xhtml*.xml $(DIST_DIR)/xhtml - cp Makefile $(DIST_DIR) - -clean : - $(foreach i,$(EXAMPLES),$(MAKE) -C $i $@ ;) - - -.PHONY : all clean test dist - diff --git a/examples/dtd2haskell/DTDtoHXT.hs b/examples/dtd2haskell/DTDtoHXT.hs deleted file mode 100644 --- a/examples/dtd2haskell/DTDtoHXT.hs +++ /dev/null @@ -1,434 +0,0 @@ --- | --- DTDtoHXml - A program for generating access functions for the Haskell XML Toolbox --- from a DTD --- --- Author : Uwe Schmidt --- --- Version : $Id: DTDtoHXT.hs,v 1.2 2005/04/14 12:52:51 hxml Exp $ --- --- this program may be used as example main program for the --- Haskell XML Toolbox - -module Main -where - -import Text.XML.HXT.Parser -- import all stuff for parsing, validating, and transforming XML - -import System.IO -- import the IO and commandline option stuff -import System.Environment -import System.Console.GetOpt -import System.Exit - -import Data.Maybe -import Data.Char -import Data.List - --- ------------------------------------------------------------ - --- | --- the main program - -main :: IO () -main - = do - argv <- getArgs -- get the commandline arguments - al <- cmdlineOpts argv -- and evaluate them, return a key-value list - res <- run' -- build a XML root from the list and start parsing - $ getDocumentAndGenerateHaskellCode al emptyRoot - exitProg (null res) -- set return code and terminate - --- ------------------------------------------------------------ - -exitProg :: Bool -> IO a -exitProg True = exitWith (ExitFailure (-1)) -exitProg False = exitWith ExitSuccess - --- ------------------------------------------------------------ - -uppercaseInitials, namespaceAware, prefixUnderline :: String - -uppercaseInitials = "uppercase-initials" -namespaceAware = "namespace-aware" -prefixUnderline = "prefix-underline" - --- ------------------------------------------------------------ - -generateHXmlToolboxAccessFuntions :: XmlFilter -generateHXmlToolboxAccessFuntions t - = processChildren (isXDTD `guards` genHaskell) t - where - genHaskell dt - = cat - [ code [ sepl - , "--" - , "-- don't edit this module" - , "-- generated with " ++ progName - , "-- simple access function for Haskell XML Toolbox" - , "-- generated from DTD of document: " ++ show source - , "" - , "module " ++ hsmodul - , "where" - , "" - , "import Text.XML.HXT.DOM.XmlTree (XmlFilter)" - , "import qualified Text.XML.HXT.DOM.XmlTree as X hiding (XmlFilter)" - ] - - , comm "namespace declarations" - , code (map nsType nsPrefixes) - , comm "" - , code (zipWith nsDef nsPrefixes nsUris) - - , comm "element names (tag names)" - , code (map (constNameType maxElemLen "tag") elements) - , comm "" - , code (map (constNameDef maxElemLen "tag") elements) - - , comm "isTag test filter" - , code (map isTagType elements) - , comm "" - , code (map isTagDef elements) - - , comm "make tag nodes constructor filter" - , code (map mkTagType elements) - , comm "" - , code (map mkTagDef elements) - - , comm "attribute names" - , code (map (constNameType maxAttrLen "attr") attributes) - , comm "" - , code (map (constNameDef maxAttrLen "attr") attributes) - - , comm "get attribute value access filter" - , code (map getValueType attributes) - , comm "" - , code (map getValueDef attributes) - - , comm "has attribute test filter" - , code (map hasAttrType attributes) - , comm "" - , code (map hasAttrDef attributes) - - , comm "make attribute nodes constructor filter for computed attribute values" - , code (map mkAttrType attributes) - , comm "" - , code (map mkAttrDef attributes) - , comm "make attribute nodes constructor filter for string attribute values" - , code (map mkSAttrType attributes) - , comm "" - , code (map mkSAttrDef attributes) - - , comm ("end of module " ++ hsmodul) - - ] - $ dt - where - code = txt . concatMap (++ "\n") - - comm cm = code [ "", sepl, "--", "-- " ++ cm, ""] -- generate a headline comment - - sepl = "-- ----------------------------------------" - - nn = trInitial . concatMap nc -- normalize names - - nc c - | c `elem` ['a'..'z'] ++ ['A'..'Z'] ++ ['0'..'9'] ++ "_" = [c] - | c == ':' || c == '-' = "_" - | otherwise = ("_" ++) . show . fromEnum $ c - - trInitial str - | null str = str - | underLn = '_' : str - | upperCs = toUpper (head str) : tail str - | otherwise = str - - modname = reverse - . (\ n -> if '.' `elem` n -- remove extension - then drop 1 . dropWhile (/= '.') $ n - else n - ) - . takeWhile (/= '/') -- remove dir path - . reverse - - maxLen = maximum . (0 :) . map length - - padd n x = take n (x ++ repeat ' ') - - tagPrefix = "tag" - attrPrefix = "attr" - nsPrefix = "ns" - - tagName n = tagPrefix ++ nn n - attName a = attrPrefix ++ nn a - nspName n = nsPrefix ++ nn n - - constNameType ln prefix n - = prefix ++ padd ln (nn n) ++ " :: String" - - constNameDef ln prefix n - = prefix ++ padd ln (nn n) ++ " = " ++ show n - - isTagType n - = "is" ++ padd maxElemLen (nn n) ++ " :: XmlFilter" - - isTagDef n - = "is" ++ padd maxElemLen (nn n) ++ " = " ++ - ( either - (const ("X.isTag " ++ tagPrefix ++ nn n)) - (\ (ns, pr, lp) - -> "X.isNsTag " ++ ( if null pr - then tagName n - else show lp - ) ++ " " ++ nspName ns - ) - . quName - $ n - ) - - mkTagType n - = "t" ++ padd maxElemLen (nn n) ++ " :: XmlFilter" - - mkTagDef n - = "t" ++ padd maxElemLen (nn n) ++ " = " ++ - ( either - (const ("X.etag " ++ tagName n)) - (\ (ns, _pr, _lp) - -> "X.mkXNsTag " ++ tagName n ++ " " ++ nspName ns ++ " X.none X.none" - ) - . quName - $ n - ) - - hasAttrType n - = "has" ++ padd maxAttrLen (nn n) ++ " :: XmlFilter" - - hasAttrDef n - = "has" ++ padd maxAttrLen (nn n) ++ " = " ++ - ( either - (const ("X.hasAttr " ++ attName n)) - (\ (ns, _pr, lp) - -> "X.hasNsAttr " ++ show lp ++ " " ++ nspName ns - ) - . quNameAttr - $ n - ) - - mkAttrType n - = "af" ++ padd maxAttrLen (nn n) ++ " :: XmlFilter -> XmlFilter" - - mkAttrDef n - = "af" ++ padd maxAttrLen (nn n) ++ " = " ++ - ( either - (const ("X.mkXAttr " ++ attName n)) - (\ (ns, _pr, _lp) - -> "X.mkXNsAttr " ++ attName n ++ " " ++ nspName ns - ) - . quNameAttr - $ n - ) - - mkSAttrType n - = "a" ++ padd maxAttrLen (nn n) ++ " :: String -> XmlFilter" - - mkSAttrDef n - = "a" ++ padd maxAttrLen (nn n) ++ " = \\ v -> " ++ - ( either - (const ( "X.mkXAttr " ++ attName n ++ " (X.txt v)" )) - (\ (ns, _pr, _lp) - -> "X.mkXNsAttr " ++ attName n ++ " " ++ nspName ns ++ " (X.txt v)" - ) - . quNameAttr - $ n - ) - - getValueType n - = "get" ++ padd maxAttrLen (nn n) ++ " :: XmlFilter" - - getValueDef n - = "get" ++ padd maxAttrLen (nn n) ++ " = " ++ - ( either - (const ("X.getValue " ++ attName n)) - (\ (ns, _pr, lp) - -> "X.getNsValue " ++ show lp ++ " " ++ nspName ns - ) - . quNameAttr - $ n - ) - - nsType n - = nsPrefix ++ padd maxNsLen (nn n) ++ " :: String" - - nsDef n v - = nsPrefix ++ padd maxNsLen (nn n) ++ " = " ++ show v - - source = xshow . getValue a_source $ t - modul = modname . xshow . getValue a_output_file $ t - root = xshow . (isDoctype .> getDTDValue a_name) $ dt - hsmodul - | null modul = "DTD" ++ nn root - | otherwise = modul - - upperCs = satisfies (hasAttr uppercaseInitials) $ t - underLn = satisfies (hasAttr prefixUnderline) $ t - nsAware = satisfies (hasAttr namespaceAware) $ t - - elements -- select all element names from dtd - = nub - . sort - . map ( xshow . this) - . (deep isElement .> getDTDValue a_name) - $ dt - - maxElemLen = maxLen . map nn $ elements - - attributes - = nub - . sort - . map ( xshow . this) - . (deep isAttlist .> getDTDValue a_value) - $ dt - - maxAttrLen = maxLen . map nn $ attributes - - nsName [] = root - nsName n = n - - namespaces - = map (\ (n,v) -> (drop 6 n, v)) - . map (\ t' -> (xshow . getDTDValue a_value $ t', xshow . getDTDValue a_default $ t')) - . isNSAttr - $ dt - - nsPrefixes = map (nsName . fst) namespaces - nsUris = map snd namespaces - - maxNsLen = maxLen . map nn $ nsPrefixes - - quName :: String -> Either String (String, String, String) - quName n - | not nsAware = Left n - | null lp && isNothing defns = Left n - | null lp = Right (nsName "", "", pr) - | isNothing expns = Left n - | otherwise = Right (nsName pr, pr, tail lp) - where - (pr, lp) = span (/= ':') n - defns = lookup "" namespaces - expns = lookup pr namespaces - - quNameAttr :: String -> Either String (String, String, String) - quNameAttr an - | ':' `elem` an = quName an - | otherwise = Left an - - isNSAttr :: XmlFilter - isNSAttr - = deep isAttlist - .> - ( ( getDTDValue a_value - .> - isOfText (\ s' -> s' == "xmlns" || "xmlns:" `isPrefixOf` s') - ) - `guards` - ( isFixedAttrKind `guards` this) - ) - --- ------------------------------------------------------------ - --- | --- the /real/ main program --- --- get wellformed document, validates document, propagates and check namespaces --- and controls output - -getDocumentAndGenerateHaskellCode :: Attributes -> XmlStateFilter state -getDocumentAndGenerateHaskellCode al - = parseDocument ( al - ++ - [ (a_parse_html, v_0) - , (a_canonicalize, v_0) - , (a_remove_whitespace, v_0) - ] - ) - .>> - traceMsg 1 "start processing" - .>> - liftMf generateHXmlToolboxAccessFuntions - .>> - traceMsg 1 "processing finished" - .>> - traceSource - .>> - traceTree - .>> - writeDocument [ (a_output_xml, v_0) - ] - .>> - checkStatus - --- ------------------------------------------------------------ --- --- the boring option definition and evaluation part --- --- see doc for System.Console.GetOpt - -progName :: String -progName = "DTDtoHXml" - -options :: [OptDescr (String, String)] -options - = selectOptions [ a_help - ] generalOptions - ++ - selectOptions [ a_trace - , a_proxy - , a_use_curl - , a_options_curl - , a_encoding - , a_validate - , a_check_namespaces - ] inputOptions - ++ - selectOptions [ a_output_file - ] outputOptions - ++ - [ Option "u" [prefixUnderline] (NoArg (prefixUnderline, v_1)) "separate tag and attribute names with a '_'" - , Option "U" [uppercaseInitials] (NoArg (uppercaseInitials, v_1)) "transform the first char of tag and attribute names to uppercase" - , Option "N" [namespaceAware] (NoArg (namespaceAware, v_1)) "filter are namespace aware, if namespace attributes occur in the DTD" - ] - ++ - showOptions - -usage :: [String] -> IO a -usage errl - | null errl - = do - hPutStrLn stdout use - exitProg False - | otherwise - = do - hPutStrLn stderr (concat errl ++ "\n" ++ use) - exitProg True - where - header = "DTDtoHXml - Generation of access function for the Haskell XML Toolbox from a DTD\n" ++ - "Usage: " ++ progName ++ " [OPTION...] [URI or FILE]" - use = usageInfo header options - -cmdlineOpts :: [String] -> IO (Attributes) -cmdlineOpts argv - = case (getOpt Permute options argv) of - (ol,n,[] ) - -> do - sa <- src n - help (lookup a_help ol) - return (ol ++ sa) - (_,_,errs) - -> usage errs - where - src [] = return [(a_source, "")] - src [uri] = return [(a_source, uri)] - src _ = usage ["only one input url or file allowed\n"] - - help Nothing = return () - help (Just _) = usage [] - --- ------------------------------------------------------------ diff --git a/examples/dtd2haskell/Makefile b/examples/dtd2haskell/Makefile deleted file mode 100644 --- a/examples/dtd2haskell/Makefile +++ /dev/null @@ -1,56 +0,0 @@ -# $Id: Makefile,v 1.5 2005/04/14 12:52:51 hxml Exp $ - -HXT_HOME = ../.. -PKGFLAGS = -GHCFLAGS = -Wall -O2 -GHC = ghc $(GHCFLAGS) $(PKGFLAGS) - -prog = ./DTDtoHXT - -all : $(prog) - -$(prog) : $(prog).hs - $(GHC) --make -o $@ $< - -force : - $(GHC) --make -o $(prog) $(prog).hs - -test : - @echo "===> run a few generation examples" - $(MAKE) XHTML.o XHTML2.o XHTML3.o - @echo "===> the generated modules" - ls -l XHTML*.hs XHTML*.o - -EX1 = ../xhtml/xhtml.xml -EX2 = ../photoalbum/photos.xml - -XHTML.o : $(prog) $(EX1) - @echo "===> generate a module for XHTML access function from the XHTML DTD with naming convention is, get, ..." - $(prog) --output-file XHTML.hs --uppercase-initials $(EX1) - $(GHC) -c XHTML.hs - -XHTML2.o : $(prog) $(EX1) - @echo "===> generate a module for XHTML access function from the XHTML DTD with naming convention is_, get_, ..." - $(prog) --output-file XHTML2.hs --prefix-underline $(EX1) - $(GHC) -c XHTML2.hs - -XHTML3.o : $(prog) $(EX1) - @echo "===> same as test2, but with namespace aware access functions, if xmlns is used in DTD" - $(prog) --output-file XHTML3.hs --prefix-underline --namespace-aware $(EX1) - $(GHC) -c XHTML3.hs - -Photo.hs : $(prog) $(EX2) - $(prog) --output-file $@ --uppercase-initials $(EX2) - - -DIST = $(HXT_HOME)/dist/examples -DIST_DIR = $(DIST)/dtd2haskell -DIST_FILES = $(prog).hs Makefile - -dist : - [ -d $(DIST_DIR) ] || mkdir -p $(DIST_DIR) - cp $(DIST_FILES) $(DIST_DIR) - -clean : - rm -f $(prog) XHTML*.hs *.o *.hi - diff --git a/examples/hfilter/FilterExample.hs b/examples/hfilter/FilterExample.hs deleted file mode 100644 --- a/examples/hfilter/FilterExample.hs +++ /dev/null @@ -1,172 +0,0 @@ --- | --- HXPath - XPath Evaluator of the Haskell XML Toolbox --- --- Author : Torben Kuseler, Uwe Schmidt --- --- Version : $Id: FilterExample.hs,v 1.9 2004/09/02 19:11:50 hxml Exp $ - -module Main(main) -where - -import Text.XML.HXT.Parser -- import all stuff for parsing, validating, and transforming XML - -import System.IO -- import the IO and commandline option stuff -import System.Environment -import System.Console.GetOpt -import System.Exit - -import Network.URI - -import Data.Maybe - - --- ------------------------------------------------------------ - --- | --- the main program of the Filter example - -main :: IO () -main - = do - argv <- getArgs - al <- cmdlineOpts argv - res <- run' $ filterEx al emptyRoot - exitProg (null res) -- set return code and terminate - --- ------------------------------------------------------------ - -exitProg :: Bool -> IO a -exitProg True = exitWith (ExitFailure (-1)) -exitProg False = exitWith ExitSuccess - --- ------------------------------------------------------------ - --- | --- the /real/ main program --- --- runs in the trivial XmlState monad (with user state set to ()) --- so IO and access to global options is possible - -filterEx :: Attributes -> XmlStateFilter state -filterEx al - = parseDocument al - .>> - liftMf filterDocument - .>> - writeDocument [] - .>> - checkStatus - --- ------------------------------------------------------------ --- --- some simple selection and editing filter - -filterDocument :: XmlFilter -- the main processing filter -filterDocument t - = processChildren (filterexamples xf) t - where - xf = xshow . getValue "filter" $ t - -filterexamples :: String -> XmlFilter -filterexamples "all-text" = deep isXText -filterexamples "all-body-text-without-whitespace" = getAllBodyText -filterexamples "all-a-tags-with-href-attr" = getAllTagsWithAttr "a" "href" -filterexamples "all-href-values-of-a-tags" = getAllAttrValues "a" "href" -filterexamples "change-img-src-to-abs-uri" = changeToAbsolutURIs "http://localhost/images/" "img" "src" -filterexamples f = cmt ("error: " ++ f ++ " not defined") +++ this - -getAllBodyText :: XmlFilter -getAllBodyText - = isTag "html" .> getChildren .> isTag "body" .> getChildren .> deep (isOfText noWhiteSpace) - where - noWhiteSpace = not . all (`elem` " \t\n") - -getAllTagsWithAttr :: String -> String -> XmlFilter -getAllTagsWithAttr tn an - = multi (isTag tn .> hasAttr an) - -getAllAttrValues :: String -> String -> XmlFilter -getAllAttrValues tn an - = multi (isTag tn .> getValue an) - -changeToAbsolutURIs :: String -> String -> String -> XmlFilter -changeToAbsolutURIs base tn an - = processTopDown (changeURI `when` isTag tn) - where - changeURI = modifyAttr an (toAbsURI base) - -toAbsURI :: String -> String -> String -toAbsURI base uri - = fromMaybe "" $ expand - where - expand = do - base' <- parseURI base - uri' <- parseURI uri - abs' <- relativeTo uri' base' - return $ show abs' - --- ------------------------------------------------------------ --- --- the options definition part --- see doc for System.Console.GetOpt - -progName :: String -progName = "HXmlFilter" - -options :: [OptDescr (String, String)] -options - = generalOptions - ++ - inputOptions - ++ - outputOptions - ++ - [ Option "f" ["filter"] (ReqArg flt "FILTER") ( "filter to be applied, one of: " ++ nl ++ - "\"all-text\"," ++ nl ++ - "\"all-body-text-without-whitespace\"," ++ nl ++ - "\"all-a-tags-with-href-attr\"," ++ nl ++ - "\"all-href-values-of-a-tags\"," ++ nl ++ - "\"change-img-src-to-abs-uri\"" ) - ] - ++ - showOptions - where - nl = "\n\t\t\t\t\t " - att n v = (n, v) - flt = att "filter" - - -usage :: [String] -> IO a -usage errl - | null errl - = do - hPutStrLn stdout use - exitProg False - | otherwise - = do - hPutStrLn stderr (concat errl ++ "\n" ++ use) - exitProg True - where - header = "FilterExamples - Examples for applying XML filter from the Haskell XML Toolbox\n" ++ - "Usage: " ++ progName ++ " [OPTION...] [URI or FILE]" - use = usageInfo header options - -cmdlineOpts :: [String] -> IO (Attributes) -cmdlineOpts argv - = case (getOpt Permute options argv) of - (ol,n,[] ) - -> do - sa <- src n - help (lookup a_help ol) - return (ol ++ sa) - (_,_,errs) - -> usage errs - where - src [] = return [("source", "")] - src [uri] = return [("source", uri)] - src _ = usage ["only one input uri or file allowed\n"] - - help Nothing = return () - help (Just _) = usage [] - --- ------------------------------------------------------------ diff --git a/examples/hfilter/Makefile b/examples/hfilter/Makefile deleted file mode 100644 --- a/examples/hfilter/Makefile +++ /dev/null @@ -1,63 +0,0 @@ -# $Id: Makefile,v 1.7 2005/04/14 12:52:51 hxml Exp $ - -HXT_HOME = ../.. -PKGFLAGS = -GHCFLAGS = -Wall -O2 -GHC = ghc $(GHCFLAGS) $(PKGFLAGS) - -prog = ./FilterExample -opts = --parse-html --do-not-issue-warnings -runprog = $(prog) $(opts) - -all : $(prog) - -force : - $(GHC) --make -o $(prog) $(prog).hs - -$(prog) : $(prog).hs - $(GHC) --make -o $@ $< - -EX = ./lousy.html - -test : $(prog) - @echo "===> Filter examples" - @echo ; echo "===> the filter parses a document and selects or modifies parts of it" - @echo ; echo "===> usage" ; echo - ./FilterExample --help - @echo ; sleep 2 - @$(MAKE) test1 test2 test3 test4 test5 - -test1 : - @sleep 2 ; echo ; echo "===> extract all a tags with a href attribute" ; echo ; sleep 2 - $(runprog) --filter=all-a-tags-with-href-attr $(EX) - @echo - -test2 : - @sleep 2 ; echo ; echo "===> extract all href attribute values for a tags" ; echo ; sleep 2 - $(runprog) --filter=all-href-values-of-a-tags $(EX) - @echo - -test3 : - @sleep 2 ; echo ; echo "===> change all src attribute values of img tags to absolut uris" ; echo ; sleep 2 - $(runprog) --filter=change-img-src-to-abs-uri $(EX) - @echo - -test4 : - @sleep 2 ; echo ; echo "===> select all text" ; echo ; sleep 2 - $(runprog) --filter=all-text $(EX) - @echo - -test5 : - @sleep 2 ; echo ; echo "===> select all text within body, but remove whitespace" ; echo ; sleep 2 - $(runprog) --filter=all-body-text-without-whitespace $(EX) - @echo - -DIST = $(HXT_HOME)/dist/examples -DIST_DIR = $(DIST)/hfilter - -dist : - [ -d $(DIST_DIR) ] || mkdir -p $(DIST_DIR) - cp $(EX) Makefile $(prog).hs $(DIST_DIR) - -clean : - rm -f $(prog) *.o *.hi diff --git a/examples/hfilter/lousy.html b/examples/hfilter/lousy.html deleted file mode 100644 --- a/examples/hfilter/lousy.html +++ /dev/null @@ -1,26 +0,0 @@ - - - - A HTML Documents with some Errors - - - -

HTML -

html -

some text and a &xxx; -

more text -

- -
123 -
- - -
-
Uwe - Schmidt
- - -Last modified: Mon May 12 13:11:29 CEST 2003 - - diff --git a/examples/hparser/HXmlParser.hs b/examples/hparser/HXmlParser.hs deleted file mode 100644 --- a/examples/hparser/HXmlParser.hs +++ /dev/null @@ -1,136 +0,0 @@ --- | --- HXmlParser - Validating XML Parser of the Haskell XML Toolbox --- XML well-formed checker and validator. --- --- Author : .\\artin Schmidt and Uwe Schmidt --- --- Version : $Id: HXmlParser.hs,v 1.14 2005/04/14 12:52:51 hxml Exp $ --- --- this program may be used as example main program for the --- Haskell XML Toolbox - -module Main -where - -import Text.XML.HXT.Parser -- import all stuff for parsing, validating, and transforming XML - -import System.IO -- import the IO and commandline option stuff -import System.Environment -import System.Console.GetOpt -import System.Exit - -import Data.Maybe - --- ------------------------------------------------------------ - --- | --- the main program of the Haskell XML Validating Parser - -main :: IO () -main - = do - argv <- getArgs -- get the commandline arguments - al <- cmdlineOpts argv -- and evaluate them, return a key-value list - res <- run' $ parser al emptyRoot -- build a XML root from the list and start parsing - exitProg (null res) -- set return code and terminate - --- ------------------------------------------------------------ - -exitProg :: Bool -> IO a -exitProg True = exitWith (ExitFailure (-1)) -exitProg False = exitWith ExitSuccess - --- ------------------------------------------------------------ - --- | --- the /real/ main program --- --- get wellformed document, validates document, propagates and check namespaces --- and controls output - -parser :: Attributes -> XmlStateFilter state -parser al - = parseDocument al -- read document - .>> - traceMsg 1 "start processing" - .>> - liftMf processDocument -- process document: in this case rather simple, just apply a pure filter - .>> - traceMsg 1 "processing finished" - .>> - traceSource - .>> - traceTree - .>> - ( writeDocument [] -- write result, all options already set with parseDocument - `whenNotM` - hasAttr "no-output" - ) - .>> - checkStatus -- check status - -processDocument :: XmlFilter -processDocument - = ( processChildren (deep isXText) -- process document, just select text when option \"show-text\" is set - `when` - hasAttr "show-text" - ) - --- ------------------------------------------------------------ --- --- the options definition part --- see doc for System.Console.GetOpt - -progName :: String -progName = "HXmlParser" - -options :: [OptDescr (String, String)] -options - = generalOptions - ++ - inputOptions - ++ - outputOptions - ++ - [ Option "q" ["no-output"] (NoArg ("no-output", "1")) "no output of resulting document" - , Option "x" ["show-text"] (NoArg ("show-text", "1")) "output only the raw text, remove all markup" - ] - ++ - showOptions - -usage :: [String] -> IO a -usage errl - | null errl - = do - hPutStrLn stdout use - exitProg False - | otherwise - = do - hPutStrLn stderr (concat errl ++ "\n" ++ use) - exitProg True - where - header = "HXmlParser - Validating XML Parser of the Haskell XML Toolbox\n" ++ - "XML well-formed checker and validator.\n\n" ++ - "Usage: " ++ progName ++ " [OPTION...] [URI or FILE]" - use = usageInfo header options - -cmdlineOpts :: [String] -> IO (Attributes) -cmdlineOpts argv - = case (getOpt Permute options argv) of - (ol,n,[]) - -> do - sa <- src n - help (lookup a_help ol) sa - return (ol ++ sa) - (_,_,errs) - -> usage errs - where - src [] = return [] - src [uri] = return [("source", uri)] - src _ = usage ["only one input uri or file allowed\n"] - - help (Just _) _ = usage [] - help Nothing [] = usage ["no input uri or file given\n"] - help Nothing _ = return () - --- ------------------------------------------------------------ diff --git a/examples/hparser/Makefile b/examples/hparser/Makefile deleted file mode 100644 --- a/examples/hparser/Makefile +++ /dev/null @@ -1,111 +0,0 @@ -# $Id: Makefile,v 1.7 2005/04/14 12:52:51 hxml Exp $ - -HXT_HOME = ../.. -PKGFLAGS = -GHCFLAGS = -Wall -O2 -GHC = ghc $(GHCFLAGS) $(PKGFLAGS) - -prog = ./HXmlParser - -all : $(prog) - -HXmlParser : HXmlParser.hs - $(GHC) --make -o $@ $< - -force : - $(GHC) --make -o $(prog) $(prog).hs - -test : - @echo "===> run a few simple test cases with the validating parser" - @echo "===> first see all command line options" - ./HXmlParser --help - @echo - $(MAKE) test0 test1 test2 test3 test4 - -EX1 = ./example1.xml -EXi = ./invalid.xml -EX2 = ../xhtml/xhtml.xml -EX3 = ./namespace0.xml -EX3a = ./namespace1.xml -EX4 = ./lousy.html - -EX = $(EX1) $(EXi) $(EX3) $(EX3a) $(EX4) - -test0 : HXmlParser - @echo "===> a 1. simple valid document" - ./HXmlParser $(EX1) - @echo - @echo "===> the dom tree of the same document (without any redundant whitespace)" - ./HXmlParser --show-tree --remove-whitespace $(EX1) - @echo - @echo "===> the next test case contains validation erors, it must fail" - ./HXmlParser --verbose $(EXi) || true - @echo - @echo "===> same source, but only wellformed check" - ./HXmlParser --do-not-validate $(EXi) || true - @echo - @echo "===> only validation, no output of an XHTML source" - ./HXmlParser --verbose --no-output $(EX2) - @echo - -test1 : HXmlParser - @echo "===> the source of a very simple valid document" ; echo ; sleep 2 - cat $(EX1) - @sleep 2 ; echo ; echo "===> parser will emit UTF-8" ; echo ; sleep 2 - ./HXmlParser --output-encoding=UTF-8 $(EX1) - @echo - @sleep 2 ; echo ; echo "===> once again with ISO-8859-1 (latin1) output" ; echo ; sleep 2 - ./HXmlParser --output-encoding=ISO-8859-1 $(EX1) - @echo - @sleep 2 ; echo ; echo "===> once again with US-ASCII output" ; echo ; sleep 2 - ./HXmlParser --output-encoding=US-ASCII $(EX1) - @echo - @sleep 2 ; echo ; echo "===> once again with hdom tree output" ; echo ; sleep 2 - ./HXmlParser --show-tree --output-encoding=ISO-8859-1 $(EX1) - @echo - @sleep 2 ; echo ; echo "===> once again, but without any markup" ; echo ; sleep 2 - ./HXmlParser --show-text --output-encoding=ISO-8859-1 $(EX1) - @echo - -test2 : HXmlParser - @echo "===> the source of a xhtml document" ; echo ; sleep 2 - cat $(EX2) - @echo "that document has" `cat $(EX2) | wc -l` "lines" - @sleep 2 ; echo ; echo "===> parser will validate this document and try to indent the output" ; echo ; sleep 2 - ./HXmlParser --indent $(EX2) - @sleep 2 ; echo ; echo "===> once again, but remove all markup" ; echo ; sleep 2 - ./HXmlParser --show-text --remove-whitespace $(EX2) - @sleep 2 ; echo ; echo "===> once again with hdom tree output" ; echo ; sleep 2 - ./HXmlParser --show-tree --remove-whitespace $(EX2) - -test3 : HXmlParser - @echo "===> namespace processing examples" ; echo ; sleep 2 - @echo "===> namespace propagation test" ; echo ; sleep 2 - ./HXmlParser --verbose --check-namespaces --indent --output-encoding=ISO-8859-1 $(EX3) - @echo - @echo ; sleep 2 ; echo "===> namespace propagation test: tree output with attached namespaces" ; echo ; sleep 2 - ./HXmlParser --verbose --check-namespaces --remove-whitespace --show-tree --output-encoding=ISO-8859-1 $(EX3) - @echo - @echo ; sleep 2 ; echo "===> namespace validation test: this test produces namespace errors" ; echo ; sleep 2 - ./HXmlParser --verbose --do-not-validate --check-namespaces --indent --output-encoding=ISO-8859-1 $(EX3a) || true - @echo - - -test4 : HXmlParser - @echo "===> HTML parsing examples" ; echo ; sleep 2 - @echo "===> the source of a lousy html document" ; echo ; sleep 2 - cat $(EX4) - @sleep 2 ; echo ; echo "===> parser accepts this document and tries to build a document tree" ; echo ; sleep 2 - ./HXmlParser --indent --preserve-comment --parse-html $(EX4) - @echo - -DIST = $(HXT_HOME)/dist/examples -DIST_DIR = $(DIST)/hparser - -dist : - [ -d $(DIST_DIR) ] || mkdir -p $(DIST_DIR) - cp $(EX) Makefile $(prog).hs $(DIST_DIR) - -clean : - rm -f $(prog) *.o *.hi - diff --git a/examples/hparser/example1.xml b/examples/hparser/example1.xml deleted file mode 100644 --- a/examples/hparser/example1.xml +++ /dev/null @@ -1,22 +0,0 @@ - - - - - - - -]> - - - - - - hello world äöüß test - diff --git a/examples/hparser/invalid.xml b/examples/hparser/invalid.xml deleted file mode 100644 --- a/examples/hparser/invalid.xml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - -]> - - - - hello world - diff --git a/examples/hparser/lousy.html b/examples/hparser/lousy.html deleted file mode 100644 --- a/examples/hparser/lousy.html +++ /dev/null @@ -1,26 +0,0 @@ - - - - A HTML Documents with some Errors - - - -

HTML -

html -

some text and a &xxx; -

more text -

- -
123 -
- - -
-
Uwe - Schmidt
- - -Last modified: Mon May 12 13:11:29 CEST 2003 - - diff --git a/examples/hparser/namespace0.xml b/examples/hparser/namespace0.xml deleted file mode 100644 --- a/examples/hparser/namespace0.xml +++ /dev/null @@ -1,31 +0,0 @@ - - - - - - - - - - - - - -]> - - - - - hello world äöüß test - diff --git a/examples/hparser/namespace1.xml b/examples/hparser/namespace1.xml deleted file mode 100644 --- a/examples/hparser/namespace1.xml +++ /dev/null @@ -1,60 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - -]> - - - - - - - - - <:tag/><:/><:::/> - - - - - - - - - - - - - - - - - - - diff --git a/examples/hsvg/.ghci b/examples/hsvg/.ghci deleted file mode 100644 --- a/examples/hsvg/.ghci +++ /dev/null @@ -1,11 +0,0 @@ -:set -package-conf ../../lib/hxt/package.conf -:set -package hxt -:set -Wall - -:def ex0 (\ _ -> return ":set args --trace=1 --encoding=ISO-8859-1 --do-not-validate -o ISO-8859-1 example1.xml") - -:def x (\ _ -> return ":load TreeVisualisation\n:ex0\nmain") - -:x - -:module + IO Main diff --git a/examples/hsvg/Makefile b/examples/hsvg/Makefile deleted file mode 100644 --- a/examples/hsvg/Makefile +++ /dev/null @@ -1,83 +0,0 @@ -# $Id: Makefile,v 1.7 2006/06/01 15:03:21 hxml Exp $ - -HXT_HOME = ../.. -PKGFLAGS = -GHCFLAGS = -Wall -O2 -GHC = ghc $(GHCFLAGS) $(PKGFLAGS) - -prog = ./TreeVisualisation - -all : $(prog) - -force : - $(GHC) --make -o $(prog) $(prog).hs - -$(prog) : $(prog).hs - $(GHC) --make -o $@ $< - -# Tree Visualisation Examples - -proxy := $(shell if [ `hostname` = "si" ] ; then echo -n "--proxy=www-cache.fh-wedel.de:3128" ; else echo -n ; fi) - -HTV = $(prog) -t1 --use-curl --options-curl="-L" --encoding=ISO-8859-1 --parse-html --do-not-issue-warnings --remove-whitespace -XTV = $(prog) -t1 --use-curl --do-not-validate --do-not-issue-warnings --remove-whitespace - -JPGS = index.html.jpg \ - www.fh-wedel.de.index.html.jpg \ - www.w3.org.index.html.jpg \ - www.haskell.org.index.html.jpg - -vtree : $(prog) $(JPGS) - -index.html.svg : $(HXT_HOME)/doc/index.html - @echo "get Haskell XML Toolbox homepage" - $(HTV) --width=800 --height=400 \ - $< > $@ - -www.fh-wedel.de.index.html.svg : - @echo "get FH Wedel homepage" - $(HTV) --horizontalTree --horizontalLines --width=600 --height=800 --border 30 \ - http://www.fh-wedel.de/ > $@ - -www.w3.org.index.html.svg : - @echo "get www.w3.org" - $(XTV) --centricTree --withAttr --width=1000 --height=1000 $(proxy) \ - http://www.w3.org/ > $@ - -www.haskell.org.index.html.svg : - @echo "get www.haskell.org" - $(HTV) --horizontalLines --withAttr --width=600 --height=400 $(proxy) \ - http://www.haskell.org/haskellwiki/Haskell > $@ - -%.jpg : %.svg - svgtoraster -m image/jpeg -q 0.7 `pwd`/$< - -%.png : %.svg - svgtoraster -m image/png `pwd`/$< - - -test : - $(MAKE) index.html.svg - -DIST = $(HXT_HOME)/dist/examples -DIST_DIR = $(DIST)/hsvg -DIST_FILES = $(prog).hs Makefile .ghci - -dist : - [ -d $(DIST_DIR) ] || mkdir -p $(DIST_DIR) - cp $(DIST_FILES) $(DIST_DIR) - -clean : - rm -f $(prog) *.o *.hi *.jpg *.png - -cleanvt : - rm -f \ - index.html.jpg \ - www.fh-wedel.de.index.html.jpg \ - www.w3.org.index.html.jpg \ - www.haskell.org.index.html.jpg \ - index.html.svg \ - www.fh-wedel.de.index.html.svg \ - www.w3.org.index.html.svg \ - www.haskell.org.index.html.svg - diff --git a/examples/hsvg/TreeVisualisation.hs b/examples/hsvg/TreeVisualisation.hs deleted file mode 100644 --- a/examples/hsvg/TreeVisualisation.hs +++ /dev/null @@ -1,449 +0,0 @@ --- | --- TreeVisualisation - A Haskell XML Toolbox application for --- a graphic representation of n-ary trees, e.g. XmlTrees --- with SGML. Input is a XML or HTML document, output a SGML document --- consisting of a graphical representation of the tree --- --- Author: Uwe Schmidt uwe@fh-wedel.de --- --- Version : $Id: TreeVisualisation.hs,v 1.9 2004/09/02 19:11:50 hxml Exp $ - -module Main where - -import Text.XML.HXT.Parser - -import System.IO -import System.Environment -import System.Console.GetOpt - -import System.Exit - -import Data.Maybe - --- ---------------------------------------------------------- - --- | --- compute a layout tree for a given NTree --- --- the layout tree has a stucture isomophic to the input tree --- the layout is a pair of (x,y) coordinates. for every node --- a weight is computed, the space for a tree will be proprtional to --- the sum of the weight in the tree - -treeToWeightedTree :: (Num b) => (a -> b) -> NTree a -> NTree (b, b) -treeToWeightedTree wf (NTree n cs) - = (NTree (wot, woc) cs') - where - cs' = map (treeToWeightedTree wf) cs - woc = sum . map (\ (NTree (sum', _) _) -> sum') $ cs' - wot = woc + wf n - --- | --- auxiliary function called by 'horizontalLayout' for doint the hard work - -weightedTreeToHLayout :: (Fractional a) => a -> a -> NTree (a,a) -> NTree (a,a) -weightedTreeToHLayout from to (NTree (_wot, woc) cs) - = NTree (from, to) cs' - where - len = to - from - cs' = layoutChildren (fromInteger 0) cs - layoutChildren _ [] - = [] - layoutChildren start (t1@(NTree (wot1, _woc1) _cs1) : ts) - = weightedTreeToHLayout from' to' t1 : layoutChildren start' ts - where - from' = (start / woc) * len + from - to' = (start' / woc) * len + from - start' = start + wot1 - --- | --- A horizontal layout for a tree generated with 'treeToWeightedTree' --- is computed. The nodes are positioned in the unit square ((0,0),(1,1)) --- with the origin in the left upper corner. The root node is centered --- at the top of the square - -horizontalLayout :: (Fractional b) => (a -> b) -> NTree a -> NTree (b,b) -horizontalLayout weightFct - = weightedTreeToHLayout (fromInteger 0) (fromInteger 1) . treeToWeightedTree weightFct - --- | --- layout of a tree in a 1.0 x 1.0 square --- with the root node centered at the top and the --- deepest leaves at the bottom - -vTreeLayout :: (Fractional b) => (a -> b) -> NTree a -> NTree (b,b) -vTreeLayout weightFct t - = vLayout (0::Int) . horizontalLayout weightFct $ t - where - d = (depthNTree t - 1) `max` 1 - vLayout i (NTree (l,u) cs) - = NTree (x, y) cs' - where - x = (l + u) / fromInteger 2 - y = fromInteger (toInteger i) / fromInteger (toInteger d) - cs' = map (vLayout (i + 1)) cs - -mirrorLayout :: NTree (a,a) -> NTree (a,a) -mirrorLayout - = mapNTree (\ (x,y) -> (y, x)) - -scaleLayout :: (RealFrac a) => Int -> Int -> Int -> NTree (a,a) -> NTree (Int,Int) -scaleLayout border dx dy - = mapNTree scale - where - scale (x,y) = (truncate (x * dx') + border, truncate (y * dy') + border) - dx' = fromIntegral (dx - 2 * border) - dy' = fromIntegral (dy - 2 * border) - -centricLayout :: (Floating a) => NTree (a,a) -> NTree (a,a) -centricLayout - = mapNTree center - where - center (x, y) - = ((x' + 1) /2, (y' + 1) /2) - where - phi = (2 * x - 0.5) * pi - r = y - x' = cos phi * r - y' = sin phi * r --- | --- map nodes of a NTree to SVG tags - -mapNodesToXml :: (a -> (Int, Int) -> XmlTrees) -> NTree a -> NTree (Int, Int) -> XmlTrees -mapNodesToXml formatNode layoutTree orgTree - = concat . zipWith formatNode (nTreeToList layoutTree) $ (nTreeToList orgTree) - -mapNodesToSVG :: (a -> XmlFilter) -> NTree a -> NTree (Int, Int) -> XmlTrees -mapNodesToSVG circleLayout - = mapNodesToXml drawNode - where - drawNode n (x,y) - = atag "circle" [ sattr "cx" (show x) - , sattr "cy" (show y) - , circleLayout n - ] $ undefined - -mapEdgesToSVG :: ((Int, Int) -> (Int, Int) -> XmlTrees) -> NTree (Int, Int) -> XmlTrees -mapEdgesToSVG draw (NTree p1 cs) - = concatMap (\ t' -> mkLine t' ++ mapEdgesToSVG draw t') cs - where - mkLine (NTree p2 _) = draw p1 p2 - -drawLine :: XmlFilter -> (Int, Int) -> (Int, Int) -> XmlTrees -drawLine lineAttrl p1 p2 - = drawLines lineAttrl [p1,p2] - -drawHPath :: XmlFilter -> (Int, Int) -> (Int, Int) -> XmlTrees -drawHPath lineAttrl p1@(x1, y1) p2@(x2, y2) - = drawLines lineAttrl [p1, (x1,y12), (x2,y12), p2] - where - y12 = (y1 + y2) `div` 2 - -drawVPath :: XmlFilter -> (Int, Int) -> (Int, Int) -> XmlTrees -drawVPath lineAttrl p1@(x1, y1) p2@(x2, y2) - = drawLines lineAttrl [p1, (x12,y1), (x12,y2), p2] - where - x12 = (x1 + x2) `div` 2 - -drawLines :: XmlFilter -> [(Int, Int)] -> XmlTrees -drawLines attl ps - = concat . zipWith draw ps $ tail ps - where - draw (x1, y1) (x2, y2) - = atag "line" [ sattr "x1" (show x1) - , sattr "y1" (show y1) - , sattr "x2" (show x2) - , sattr "y2" (show y2) - , attl - ] $ undefined - --- | --- filter for copying the attributes into the content part --- the result does not correspont to a wellformed XML document --- but for drawing the tree inclusive attributes this works fine - -moveAttrlToContent :: XmlFilter -moveAttrlToContent - = processChildren - ( processBottomUp - ( substChildren (getAttrl +++ getChildren) `when` isXTag ) ) - --- | --- the main transformation filter - -xmlTreeToSVG :: XmlFilter -xmlTreeToSVG t - = rootTag [ getAttrl ] - [ getChildren - .> - isXTag -- get the root tag - .> - cat [ dtd DOCTYPE [ sattr a_name "svg" - , sattr k_public "-//W3C//DTD SVG 1.1//EN" - , sattr k_system "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" - ] [] - , tag "svg" - [ sattr "width" (show widthInt) - , sattr "height" (show heightInt) - , sattr "version" "1.1" - , sattr "xmlns" "http://www.w3.org/2000/svg" - , sattr "xmlns:xlink" "http://www.w3.org/1999/xlink" -- currently not used - ] - [ stag "title" [ txt source] - , tag "text" [ sattr "x" "10" -- draw source uri - , sattr "y" "22" - , sattr "font-size" "12" - , sattr "fill" "grey" - ] [ txt ("source: " ++ source) - ] - , legend (10, heightInt - 5 * pixelPerLine - 10) - [ (tagColor, "tag") - , (textColor, "text") - , (attrColor, "attribute") - , (cmtColor, "comment") - , (defColor, "others") - ] - , nodesToSVG - . scaleLayout borderWidthInt widthInt heightInt - . layoutFct - . vTreeLayout nSize - ] - ] - ] .> addXmlPiToDoc $ t - where - t1 = head . (getChildren .> isXTag) $ t -- the root tag - - pixelPerLine = 15 - - legend :: (Int, Int) -> [(String, String)] -> XmlFilter - legend (x1, y1) ls - = cat (zipWith legend1 ps ls) - where - ps = map (\ y' -> (x1, y1 + y' * pixelPerLine)) [0..] - legend1 (x', y') (color, text) - = cat [ atag "circle" [ sattr "cx" (show (x' + 5)) - , sattr "cy" (show (y' + 10)) - , sattr "r" "5" - , sattr "fill" color - , sattr "stroke-width" lineWidth - , sattr "stroke" lineColor - ] - , tag "text" [ sattr "x" (show (x' + pixelPerLine)) - , sattr "y" (show (y' + pixelPerLine)) - , sattr "font-size" "12" - , sattr "fill" "grey" - ] [ txt text - ] - ] - - defValueOf attr' def' t' - | null res = def' - | otherwise = res - where - res = valueOf attr' t' - - width = defValueOf "width" "800" t - height = defValueOf "height" "600" t - nodeScale = defValueOf "nodeSize" "1" t - borderWidth = defValueOf "borderWidth" "20" t - lineWidth = defValueOf "lineWidht" "1" t - lineColor = defValueOf "lineColor" "grey" t - textColor = defValueOf "textNodeColor" "blue" t - tagColor = defValueOf "tagNodeColor" "red" t - attrColor = defValueOf "attrNodeColor" "green" t - cmtColor = defValueOf "cmtNodeColor" "magenta" t - defColor = defValueOf "defaultNodeColor" "grey" t - layout = defValueOf "layout" "vertical" t - lineStyle = defValueOf "lineStyle" "line" t - source = valueOf a_source t - - widthInt, heightInt, borderWidthInt :: Int - - widthInt = read width `max` 100 - heightInt = read height `max` 100 - borderWidthInt= read borderWidth - - nodesToSVG t' = mapEdgesToSVG (edgeLayoutFct edgeLayout) t' - ++ - mapNodesToSVG nodeLayout t1 t' - - nodeLayout n - = cat [ sattr "fill" nColor - , sattr "stroke" ( if r < 5 -- if circle too small - then nColor -- border is drawn in the same color as cirle - else lineColor - ) - , sattr "stroke-width" lineWidth - , sattr "r" (show r) - ] - where - (nColor, nSz) = nLayout n - nSz1 = nSz * (read nodeScale) - r = (round (sqrt (fromInteger (toInteger nSz1))::Double))::Int - - nSize :: XNode -> Double - nSize = fromInteger . toInteger . snd . nLayout - - nLayout (XTag _tn _) = (tagColor, 9) -- constant size for tags - nLayout (XText tx) = (textColor, length tx) - nLayout (XAttr _an) = (attrColor, 4) -- attributes are smaller than tags - nLayout (XCmt c) = (cmtColor, length c) - nLayout _ = (defColor, 1) -- entities, PI's, dtd stuff, ... - - layoutFct :: NTree (Double,Double) -> NTree (Double,Double) - layoutFct - = fromJust . lookup layout - $ [ ("vertical", id) - , ("horizontal", mirrorLayout ) - , ("centric", centricLayout ) - ] - - edgeLayoutFct - = fromJust . lookup (layout, lineStyle) - $ [ (("vertical", "line"), drawLine ) - , (("vertical", "fork"), drawHPath ) - , (("horizontal", "line"), drawLine ) - , (("horizontal", "fork"), drawVPath ) - , (("centric", "line"), drawLine ) - , (("centric", "fork"), drawLine ) - ] - - edgeLayout - = cat [ sattr "stroke" lineColor - , sattr "stroke-width" "1" - ] - --- ---------------------------------------------------------- - --- | --- the main program of the Haskell XML Validating Parser - -main :: IO () -main - = do - argv <- getArgs - al <- cmdlineOpts argv - res <- run' (xmlToSVG al emptyRoot) - exitProg (null res) -- set return code and terminate - --- ------------------------------------------------------------ - -exitProg :: Bool -> IO a -exitProg True = exitWith (ExitFailure (-1)) -exitProg False = exitWith ExitSuccess - --- ------------------------------------------------------------ - --- | --- the /real/ main program --- --- runs in the trivial XmlState monad (with user state set to ()) --- so IO and access to global options is possible - -xmlToSVG :: Attributes -> XmlStateFilter state -xmlToSVG al - = parseDocument al -- read document - .>> - traceMsg 1 "start processing" - .>> - liftMf - ( canonicalizeAllNodes - .> - ( moveAttrlToContent `when` hasAttr "withAttr" ) - .> - xmlTreeToSVG - .> - indentDoc - ) - .>> - traceMsg 1 "processing finished" - .>> - traceSource - .>> - traceTree - .>> - ( writeDocument [ (a_indent, v_1) ] - `whenM` - getChildren - ) - .>> - checkStatus - --- ------------------------------------------------------------ --- --- the options definition part --- see doc for System.Console.GetOpt - -progName :: String -progName = "TreeVisualisation" - -options :: [OptDescr (String, String)] -options - = generalOptions - ++ - inputOptions - ++ - outputOptions - ++ - showOptions - ++ - [ Option "" ["width"] (ReqArg (nat "width") "NUM") "SVG image width in pixel, default: 800" - , Option "" ["height"] (ReqArg (nat "height") "NUM") "SVG image height in pixel, default: 600" - , Option "" ["withAttr"] (NoArg (att "withAttr" "1")) "show tag attributes, default: no" - , Option "" ["nodeSize"] (ReqArg (nat "nodeSize") "NUM") "scale size of nodes, default: 1" - , Option "" ["lineWidth"] (ReqArg (nat "lineWidth") "NUM") "width of edges in pixel, default: 1\n" - , Option "" ["border"] (ReqArg (nat "borderWidth") "NUM") "border around tree in pixel, default: 20\n" - - , Option "" ["verticalTree"] (NoArg (att "layout" "vertical")) "vertical tree layout, root centered at the top border" - , Option "" ["horizontalTree"] (NoArg (att "layout" "horizontal")) "horizontal tree layout, root centered at the left border" - , Option "" ["centricTree"] (NoArg (att "layout" "centric")) "layout with root in the center" - , Option "" ["directLines"] (NoArg (att "lineStyle" "line")) "edges are drawn as direct lines" - , Option "" ["horizontalLines"] (NoArg (att "lineStyle" "fork")) "edges are drawn as a path of horizontal and vertical lines\n" - - , Option "" ["textNodeColor"] (ReqArg (att "textNodeColor") "COLOR") "text node: color name or RGB value in format \"#RRGGBB\"" - , Option "" ["tagNodeColor"] (ReqArg (att "tagNodeColor") "COLOR") "tag node color" - , Option "" ["attrNodeColor"] (ReqArg (att "attrNodeColor") "COLOR") "attribute node color" - , Option "" ["cmtNodeColor"] (ReqArg (att "cmtNodeColor") "COLOR") "comment node color" - , Option "" ["defaultNodeColor"] (ReqArg (att "defNodeColor") "COLOR") "other node color" - ] - where - att n v = (n, v) - nat n v = (n, filter (`elem` "0123456789") v) - -usage :: [String] -> IO a -usage errl - | null errl - = do - hPutStrLn stdout use - exitProg False - | otherwise - = do - hPutStrLn stderr (concat errl ++ "\n" ++ use) - exitProg True - where - header = "TreeVisualisation - An example application of the Haskell XML Toolbox\n" ++ - "for the visualisation of the structure of a XML document with SVG\n" ++ - "Usage: " ++ progName ++ " [OPTION...] [URI or FILE]" - use = usageInfo header options - -cmdlineOpts :: [String] -> IO (Attributes) -cmdlineOpts argv - = case (getOpt Permute options argv) of - (ol,n,[] ) - -> do - sa <- src n - help (lookup a_help ol) - return (ol ++ sa) - (_,_,errs) - -> usage errs - where - src [] = usage ["no input url or file given\n"] - src [url] = return [("source", url)] - src _ = usage ["only one input uri or file allowed\n"] - - help Nothing = return () - help (Just _) = usage [] - --- ------------------------------------------------------------ - - diff --git a/examples/hunit/HUnitExample.hs b/examples/hunit/HUnitExample.hs deleted file mode 100644 --- a/examples/hunit/HUnitExample.hs +++ /dev/null @@ -1,616 +0,0 @@ --- | --- HUnit - Haskell XML Toolbox examples and tests --- --- Author: Uwe Schmidt uwe@fh-wedel.de --- --- Version : $Id: HUnitExample.hs,v 1.8 2005/04/14 12:52:51 hxml Exp $ - -module Main where - -import System -import Test.HUnit -import Text.XML.HXT.Parser -import Data.Char - -aMinimalDoc :: XmlTree -aMinimalDoc = mkRootTree [] (xtext "") - -aSimpleXHTMLDoc :: XmlTree -aSimpleXHTMLDoc - = mkRootTree - ( xattr a_source "simple.xml" ) - ( xtext - ( concatMap (++ "\n") - [ "" - , "" - , " A Simple XHTML Document" - , " " - , " " - , "" - ] - ) - ) - -mkMinimalDoc :: String -> XmlTree -mkMinimalDoc cont - = mkRootTree [] (xtext cont) - -mkInputDoc :: String -> XmlTree -mkInputDoc src - = mkRootTree ( xattr a_source src) [] - -mkDoc :: String -> XmlTree -mkDoc cont - = mkRootTree - ( xattr a_source "a test") - ( xtext ("\n" ++ cont) ) - --- | --- compare trees - -testEqualTrees :: XmlTrees -> XmlTrees -> Test -testEqualTrees e1 e2 - = TestCase $ - assertEqual "" e1 e2 - --- | --- testDocFilter creates a test for the application of a pure --- functional filter to a XML tree. The result is converted into --- the external string representation and compared with the expected --- result. --- --- see also: 'testStateFilter' and 'testEditFilter' - -testDocFilter :: String -> XmlFilter -> XmlTree -> Test -testDocFilter expected xfilter doc - = TestCase $ - assertEqual "" expected (xshow $ xfilter doc) - --- | --- testStateFilter creates a test for monadic filters, doing IO and using --- the internal state, consisting of program options and status information --- The filter is applied to a XML tree, the result is converted to a string --- and this result is compared with the expected result. --- --- see also: 'testEditFilter' for pure functional filters - -testStateFilter :: String -> XmlStateFilter () -> XmlTree -> Test -testStateFilter expected xfilter input - = TestCase $ - do - res <- run' $ xfilter input - assertEqual "" expected (xshow res) - --- | --- The test bed for edit filter for external documents. --- The input tree must specify the external document to be read. --- This document is checked for wellformedness, canonicalized --- (char refs substituted, ...) and processed with the edit filter. --- The result is transformed into the string representation and compared --- with the expected string. - -testEditFilter :: String -> XmlFilter -> XmlTree -> Test -testEditFilter expected xfilter input - = TestCase $ - do - res <- run' - $ ( getWellformedDoc -- read the document - .>> - liftMf canonicalizeAllNodes -- normalize the document and remove decl - .>> - liftMf ( processChildren xfilter ) -- apply the editing filter only to the 'real' document - .>> -- nodes, not to nodes surrounding the document tag - putXmlTree -- just trace output - .>> - liftMf getChildren -- just for comparing the document contents - ) - input - assertEqual "" expected (xshow res) - - --- | --- ausiliary function to make haskell string constants with quotes more readable - -singleToDoubleQuote :: String -> String -singleToDoubleQuote - = map (\ c -> if c == '\'' then '"' else c) - --- | --- the complete set of test cases - -allTests :: Test -allTests - = TestList - [ constructionTests - , treeConstructionTests - , parseTests - , inputTests - , removeTests - , simpleSelectionTests - , namespaceTests - ] - --- | --- tree versus filter construction tests --- documents may be constructed by tree operations --- or with the more flexible filter operations applied to an arbitray tree - -treeConstructionTests :: Test -treeConstructionTests - = TestLabel "tree and filter construction tests" $ - TestList $ - map (\ (t, f) -> testEqualTrees t (f undefined) ) - [ (xtext "xyz", txt "xyz" ) - , (xcmt "cmt", cmt "cmt" ) - , (xtag "img" [] [], tag "img" [] [] ) - , (xtag "img" [] [], etag "img" ) - - , (xtag "img" (xattr "b" "13") [], tag "img" [sattr "b" "13"] [] ) - - , (xtag "img" (xattr "b" "13") [], atag "img" [sattr "b" "13"] ) - - , (xtag "t" (xattr "a" "42" ++ xattr "b" "id") - (xtext "abc"), - tag "t" [sattr "a" "42", sattr "b" "id"] - [txt "abc"] ) - ] - --- | --- construction tests are all applied to the empty document, --- no information is used from that document, --- but construction is lifted to the filter level. --- this is more general than explicit construction. --- in more complex examples some information may be extracted from --- the source, some can be constant. --- --- see also: 'testDocFilter' - -constructionTests :: Test -constructionTests - = TestLabel "document construction tests" $ - TestList $ - map (\ (res, f) -> testDocFilter res f undefined) -- undefined or something else, e.g. emptyRoot - [ ("" , mkXTag "x" none none ) - , ("" , tag "x" [] [] ) -- syntactically more comfortable shortcut for mkXTag - , ("" , stag "x" [] ) -- shortcut for tags without attributes - , ("" , atag "x" [] ) -- shortcut for empty tags with attributes - , ("" , etag "x" ) -- shortcut for empty tags without attributes - - , ("" - , mkXTag "x" (mkXAttr "a" (mkXText "1")) none ) - , ("42" - , mkXTag "x" (mkXAttr "a" (mkXText "1")) (mkXText "42") ) - , ("42" - , tag "x" [ attr "a" $ txt "1" ] [ txt "42" ] ) - , ("42" - , tag "x" [ sattr "a" "1" ] [ txt "42" ] ) - - , ("" , atag "x" [ sattr "a" "1" ] ) - - , ("4243" - , tag "x" [ sattr "a" "1" - , sattr "b" "2" - ] [ txt "42" - , etag "y" - , txt "43" - ] ) - , ("" - , mkXCmt $ txt " a comment " ) - , ("" - , cmt "a comment" ) -- short cut for uncomputed comment - - , ("" - , cmt " an illegal XML comment containing 2 -- in comment text " ) - - , ("*" , mkXCharRef 42 ) - , ("<" , mkXEntityRef "lt" ) - , ("]]>" - , mkXCdata $ txt "") - , ("]]>" -- short cut for uncomputed cdata content - , cdata "") - , ("" , mkXPi "abc" $ txt "xyz" ) - , ("" , spi "abc" "xyz" ) -- short cut for an uncomputed pi content - ] - --- | --- simple selection tests - -simpleSelectionTests :: Test -simpleSelectionTests - = TestLabel "simple tree selection tests" $ - TestList $ - map (\ (res, f) -> testDocFilter (singleToDoubleQuote res) f simpleDoc) - [ (src , this ) - , ("1" , getValue "a" ) - , ("" , getValue "b" ) - , (body1 , getChildren ) - - -- text selection - , ("xyz" , getChildren .> isXText ) - , ("xyz" , getChildren .> isText "xyz" ) - , ("" , getChildren .> isText "abc" ) - , ("xyz" , getChildren .> isOfText (>="x") ) - , ("" , getChildren .> isOfText (<"x") ) - , ("" , getChildren .> isWhiteSpace ) - - -- tag selection - , ("abc" - , getChildren .> isXTag ) - - -- comment selection - , ("" , getChildren .> isXCmt ) - - -- text OR tag selection - , ("abcxyz" - , getChildren .> (isXTag +++ isXText) ) - - -- generalised OR - , ("abcxyz" - , getChildren .> cat [isXTag, isXText] ) - - , ("abc" , getChildren .> getChildren ) - - -- atribute value selection - , ("1" , getValue "a" ) - - , ("abc" - , getChildren .> isTag "t" ) - - -- attribute selection - , ("abc" - , getChildren .> hasAttr "a" ) - - , ("42" , getChildren .> getValue "a" ) - , ("42" , getChildren .> hasValue "a" (all isDigit) ) - , ("13" , getChildren .> hasValue "b" (all isDigit) ) - , ("" , getChildren .> isTag "t" .> hasValue "b" (all isDigit) ) - , ("42" , getChildren .> hasValue "a" (== "42") ) - , ("" , getChildren .> hasValue "a" (== "43") ) - , ("42" , getChildren .> hasValue "a" (\ str -> ((read str)::Int) > 40) ) - , ("42" , getChildren .> hasValue "a" (not . null) ) - , ("id13" , getChildren .> hasValue "b" (const True) ) - , ("13" , getChildren .> isTag "img" .> hasValue "b" (const True) ) - , ("" , getChildren .> hasValue "c" (const True) ) - - , (" a='42' b='id' b='13' x='0'" - , getChildren .> getAttrl ) - - , (" a='42' b='id'" - , getChildren .> isTag "t" .> getAttrl ) - - , ("42id" , getChildren .> isTag "t" .> getAttrl .> getChildren ) - - , (" b='id' b='13'" - , getChildren .> getAttrl .> isAttr "b" ) - - , (" b='13'" , getChildren .> isTag "img" .> getAttrl .> isAttr "b" ) - , ("13" , getChildren .> isTag "img" .> getAttrl .> isAttr "b" .> getChildren ) - , ("13" , getChildren .> isTag "img" .> getValue "b" ) - , ("timgyz" , getChildren .> getName ) - , ("t" , getChildren .> isTag "t" .> getName ) - , ("abbx" , getChildren .> getAttrl .> getName ) - , ("bb" , getChildren .> getAttrl .> isAttr "b" .> getName ) - , ("ab" , getChildren .> isTag "t" .> getAttrl .> getName ) - , ("b" , getChildren .> isTag "t" .> getAttrl .> isAttr "b" .> getName ) - - -- deep search for text or tags - , ("abcxyz" , deep isXText ) - , ("abc" , deep (isTag "t") .> deep isXText ) - ] - where - src = "" ++ body1 ++ "" - body1 = "" - ++ "abc" - ++ "" - ++ "xyz" - ++ "" - ++ "" - - sDocFilter - = tag "r" [ sattr "a" "1" ] - [ cmt "cmt" - , tag "t" [ sattr "a" "42", sattr "b" "id" ] - [ txt "abc" - ] - , atag "img" [ sattr "b" "13" ] - , txt "xyz" - , atag "y" [ sattr "x" "0" ] - , etag "z" - ] - simpleDoc = head $ sDocFilter undefined - --- | --- simple tests with namespaces - -namespaceTests :: Test -namespaceTests - = TestLabel "namespace tests" $ - TestList $ - map (\ (res, f) -> testDocFilter (singleToDoubleQuote res) f simpleDoc) - [ (src , this ) - -- select all "t" tags, even nested ones (multi) and extract the text from the body - , ("sssaaa" , multi (isTag "t" .> getChildren .> isXText) ) - - -- select all text within all tags of a specific namespace - , ("sssaaazzzeee" , multi (isXTag .> hasNamespace "dns" .> getChildren .> isXText) ) - , ("bbb" , multi (isXTag .> hasNamespace "n1" .> getChildren .> isXText) ) - , ("cccdddfffggg" , multi (isXTag .> hasNamespace "n2" .> getChildren .> isXText) ) - - -- select all text within all tags with a specific local name - , ("sssaaabbbcccdddzzz" - , multi (isXTag .> hasLocalPart "t" .> getChildren .> isXText) ) - , ("eee" , multi (isXTag .> hasLocalPart "e" .> getChildren .> isXText) ) - - -- select all text within all tags with a specific prefix - , ("bbbddd" , multi (isXTag .> hasPrefix "x" .> getChildren .> isXText) ) - , ("ccc" , multi (isXTag .> hasPrefix "y" .> getChildren .> isXText) ) - , ("zzz" , multi (isXTag .> hasPrefix "z" .> getChildren .> isXText) ) - , ("sssaaaeeefffggg" - , multi (isXTag .> hasPrefix "" .> getChildren .> isXText) ) - - -- select all attribute values of a specific namespace - -- !!! the default namespace is not propagated to attribute names - , ("z5" , multi (isXTag .> getAttrl .> hasNamespace "dns" .> getChildren) ) - , ("2z4" , multi (isXTag .> getAttrl .> hasNamespace "n1" .> getChildren) ) - , ("x3y3u4" , multi (isXTag .> getAttrl .> hasNamespace "n2" .> getChildren) ) - , ("dnsn2" , multi (isXTag .> getAttrl .> hasLocalPart "xmlns" .> getChildren) ) - - -- select namespaces from all namespace declarations - , ("dnsn1n2dnsn2n2" - , multi (isXTag .> getAttrl .> isNamespaceDecl .> getChildren) ) - - -- all default namespace declarations - , ("dnsn2" , multi (isXTag .> getAttrl .> hasLocalPart "xmlns" .> getChildren) ) - - -- all none default namespace declarations - , ("n1n2dnsn2" , multi (isXTag .> getAttrl .> hasPrefix "xmlns" .> getChildren) ) - , ("n1n2" , multi (isXTag .> getAttrl .> hasPrefix "xmlns" .> hasLocalPart "x" .> getChildren) ) - , ("n2" , multi (isXTag .> getAttrl .> hasPrefix "xmlns" .> hasLocalPart "y" .> getChildren) ) - , ("dns" , multi (isXTag .> getAttrl .> hasPrefix "xmlns" .> hasLocalPart "z" .> getChildren) ) - ] - where - -- the text representation of the tree - -- with ' instead of " for readablility of the string constants - src = "" - ++ "sss" - ++ "aaa" - ++ "bbb" - ++ "ccc" - ++ "ddd" - ++ "zzz" - ++ "eee" - ++ "fffggg" ++ - "" - - -- the filter for generating the test document - sDocFilter - = tag "t" [ sattr "xmlns" "dns" -- 4 namespace declarations - , sattr "xmlns:x" "n1" - , sattr "xmlns:y" "n2" - , sattr "xmlns:z" "dns" - ] - [ txt "sss" - , tag "t" [ sattr "a" "1" - , sattr "x:a" "2" ] - [ txt "aaa" - ] - , tag "x:t" [ sattr "a" "x1" - , sattr "y:a" "x3" - ] - [ txt "bbb" - ] - , tag "y:t" [ sattr "a" "y1" - , sattr "y:a" "y3" - ] - [ txt "ccc" - ] - , tag "x:t" [ sattr "xmlns:x" "n2" -- redefinition of prefix x: - , sattr "x:a" "u4" - ] - [ txt "ddd" - ] - , tag "z:t" [ sattr "x:a" "z4" - , sattr "z:a" "z5" - ] - [ txt "zzz" - ] - , tag "e" [ sattr "b" "42" ] - [ txt "eee" - ] - , tag "f" [ sattr "xmlns" "n2" -- redefinition of default namespace - ] - [ txt "fff" - , tag "g" [ ] - [ txt "ggg" ] - ] - ] - -- create document and propagate namespaces - simpleDoc = head $ (sDocFilter .> propagateNamespaces) undefined - --- | --- minimal tests for parsing data. --- --- the tests are document trees with a root --- node containing a single text node with the document source. --- That tree is passed to the parser, which substitutes the text node with the parsed xml tree. --- In general this may be a list of trees containing also the --- surrounding parts like the xml declaraion, the document type definition --- possibly comments and processing instructions. --- --- see also: 'testStateFilter' - -parseTests :: Test -parseTests - = TestLabel "minimal parser tests" $ - TestList - [ testStateFilter "" parseXmlDoc mini -- the tree inclusive root node - , testStateFilter "" (parseXmlDoc .>> liftMf getChildren) mini -- only the content - , testStateFilter "" (parseXmlDoc .>> liftMf getChildren) min2 -- same content - , testStateFilter "" (parseXmlDoc .>> liftMf getChildren) minErr -- syntax error: content empty - , testStateFilter errr (parseXmlDoc .>> liftMf (getValue a_status)) minErr -- syntax error reported in a_status - ] - where - errr = show c_err - mini = mkMinimalDoc "" - min2 = mkMinimalDoc "" - minErr = mkMinimalDoc "" - - --- | --- simple external file containing one tag - -mini1 :: XmlTree -mini1 = newDocument "mini1.xml" -- test documents - --- | --- simple external file containing one tag - -mini2 :: XmlTree -mini2 = newDocument "mini2.xml" - --- | --- simple not existing external file - -notThere :: XmlTree -notThere = newDocument "notThere.xml" -- does not exist - --- | --- These test check the access to external files --- and error reporting in case of input or parse errors --- Some test issue tree like trace output of the documents read --- to show the internal structure and nesting - -inputTests :: Test -inputTests - = TestLabel "input tests" $ - TestList - [ testStateFilter "mini1.xml" - ( putXmlTree .>> - liftMf (getValue a_source) - ) mini1 - , testStateFilter ok ( liftMf (getValue a_status) - ) mini1 - , testStateFilter "" ( liftMf getChildren - ) mini1 - , testStateFilter "" ( getXmlContents .>> - putXmlTree .>> - liftMf getChildren - ) mini1 - , testStateFilter ok ( getXmlContents .>> - liftMf (getValue a_status) - ) mini1 - , testStateFilter "4" ( getXmlContents .>> - liftMf getContentLength .>> - putXmlTree .>> - liftMf (getValue a_contentLength) - ) mini1 - , testStateFilter ok ( getXmlContents .>> - liftMf (getValue a_status) - ) mini2 - , testStateFilter "" ( getXmlContents .>> - putXmlTree .>> - liftMf getChildren - ) notThere - , testStateFilter fat ( getXmlContents .>> - liftMf (getValue a_status) - ) notThere - ] - where - ok = show c_ok - fat = show c_fatal - --- | --- A few tests for removing parts of a document tree. --- As input tree the document in file mini2.xml is used. - -removeTests :: Test -removeTests - = TestLabel "document transformation tests" $ - TestList - [ testEditFilter allText getAllText mini2 - , testEditFilter allData (removeAllWhiteSpace .> getAllText) mini2 - , testEditFilter allImp (removeIgnorableData .> getAllText) mini2 - , testEditFilter allDat (removeMeta .> getAllText) mini2 - ] - where - getAllText = deep isXText - containsUnknownOrIgnore = getChildren .> ( isText "unknown" - +++ - isText "ignore" - ) - removeIgnorableData = processTopDown ( none - `when` - ( isTag "data" .> containsUnknownOrIgnore ) - ) - removeMeta = processTopDown ( none - `when` - ( isTag "data" .> hasValue "class" ( == "meta" ) ) - ) - allText = " ignore unknown important important " - allData = "ignoreunknownimportantimportant" - allImp = " important important " - allDat = " ignore important " - - -ys :: XmlTree -ys = head $ - tag "s:Envelope" - [ sattr "xmlns:s" "http://schemas.xmlsoap.org/soap/envelope/", - sattr "xmlns:xenc" "http://www.w3.org/2001/04/xmlenc#", - sattr "xmlns:eg" "http://example.org/paymentv2", - sattr "xmlns:wsse" "http://schemas.xmlsoap.org/ws/2002/12/secext" - ] - [ stag "s:Header" - [ stag "wsse:Security" - [ tag "wsse:BinarySecurityToken" - [ sattr "ValueType" "wsse:Kerberosv5ST", - sattr "EncodingType" "wsse:Base64Binary" - ] - [ txt "QMwcAG ..." - ] - ] - ], - stag "s:Body" - [ stag "eg:OrderCurrency" - [ stag "eg:Name" - [ txt "John Smith" ], - tag "eg:Amount" - [ sattr "Currency" "'USD'" ] - [ txt "1000" ], - tag "eg:CreditCard" - [ sattr "Limit" "'5000'", - sattr "Currency" "'GBP'" - ] - [ stag "xenc:EncryptedData" - [ atag "xenc:EncryptionMethod" - [ sattr "Algorithm" "http://www.w3.org/2001/04/xmlenc#tripledes-cbc" ] - ], - stag "xenc:CipherData" - [ stag "xenc:CipherValue" - [ txt "r5KipsDV ..." ] - ] - ] - ] - ] - ] - .> propagateNamespaces - .> indentDoc - $ undefined - - -main :: IO () -main - = do - c <- runTestTT allTests - putStrLn $ show c - let errs = errors c - fails = failures c - System.exitWith (codeGet errs fails) - -codeGet :: Int -> Int -> ExitCode -codeGet errs fails - | fails > 0 = ExitFailure 2 - | errs > 0 = ExitFailure 1 - | otherwise = ExitSuccess - --- ---------------------------------------------------------- diff --git a/examples/hunit/Makefile b/examples/hunit/Makefile deleted file mode 100644 --- a/examples/hunit/Makefile +++ /dev/null @@ -1,32 +0,0 @@ -# $Id: Makefile,v 1.6 2005/04/14 12:52:51 hxml Exp $ - -HXT_HOME = ../.. -PKGFLAGS = -GHCFLAGS = -Wall -O2 -GHC = ghc $(GHCFLAGS) $(PKGFLAGS) - -prog = ./HUnitExample - -all : $(prog) - -force : - $(GHC) --make $(GHCPACKAGES) -o $(prog) $(prog).hs - -$(prog) : $(prog).hs - $(GHC) --make $(GHCPACKAGES) -o $@ $< - -test : $(prog) - @echo "===> run HUnit examples" ; echo ; sleep 2 - $(prog) - -DIST = $(HXT_HOME)/dist/examples -DIST_DIR = $(DIST)/hunit -DIST_FILES = mini1.xml mini2.xml Makefile $(prog).hs - -dist : - [ -d $(DIST_DIR) ] || mkdir -p $(DIST_DIR) - cp $(DIST_FILES) $(DIST_DIR) - -clean : - rm -f $(prog) $(prog).o $(prog).hi - diff --git a/examples/hunit/mini1.xml b/examples/hunit/mini1.xml deleted file mode 100644 --- a/examples/hunit/mini1.xml +++ /dev/null @@ -1,1 +0,0 @@ - diff --git a/examples/hunit/mini2.xml b/examples/hunit/mini2.xml deleted file mode 100644 --- a/examples/hunit/mini2.xml +++ /dev/null @@ -1,1 +0,0 @@ - ignore unknown important important diff --git a/examples/mini/Makefile b/examples/mini/Makefile deleted file mode 100644 --- a/examples/mini/Makefile +++ /dev/null @@ -1,34 +0,0 @@ -# $Id: Makefile,v 1.5 2005/04/14 12:52:52 hxml Exp $ - -HXT_HOME = ../.. -PKGFLAGS = -GHCFLAGS = -Wall -O2 -GHC = ghc $(GHCFLAGS) $(PKGFLAGS) - -prog = ./ParseExample - -all : $(prog) - -force : - $(GHC) --make -o $(prog) $(prog).hs - -$(prog) : $(prog).hs - $(GHC) --make -o $@ $< - -test : $(prog) - @echo "===> a very simple test" - @echo "===> a xml source" - @cat example1.xml - @sleep 2; echo "===> parse, validate and normalise the document" - $(prog) example1.xml - -DIST = $(HXT_HOME)/dist/examples -DIST_DIR = $(DIST)/mini - -dist : - [ -d $(DIST_DIR) ] || mkdir -p $(DIST_DIR) - cp example1.xml Makefile $(prog).hs $(DIST_DIR) - -clean : - rm -f $(prog) *.o *.hi - diff --git a/examples/mini/ParseExample.hs b/examples/mini/ParseExample.hs deleted file mode 100644 --- a/examples/mini/ParseExample.hs +++ /dev/null @@ -1,50 +0,0 @@ --- | --- This is a simple example for parsing and validating an XML file and printing the generated --- XmlTree to standard out. --- --- Author : .\\artin Schmidt --- Version : $Id: ParseExample.hs,v 1.4 2004/09/02 19:11:53 hxml Exp $ - -module Main(main) -where - -import Text.XML.HXT.Parser - -import System.IO -import System - --- --- call this program with a single parameter for the file or uri to be processed --- e.g. ParseExample example1.xml - -main :: IO () -main - = do - argv <- getArgs - -- take the first cmdline argument as source name - -- start the XState monad with the runParser command - res <- run' $ parser [(a_source, head argv)] emptyRoot - exitProg res - --- run a command in the XState monad. --- this monad includes the IO monad, a system state for global options --- and a user definable state (type parameter state). This user state is --- set to () (the empty state) by the run' command. --- There are more general run commands: run, run0 in case of a proccessing --- function, that requires e.g. an environment - -parser :: Attributes -> XmlStateFilter () -parser al - = parseDocument al - .>> - writeDocument [(a_indent, v_1)] -- indent document and output to stdout - .>> - checkStatus -- check status - --- ------------------------------------------------------------ - -exitProg :: [a] -> IO () -exitProg [] = exitWith (ExitFailure (-1)) -exitProg _ = exitWith ExitSuccess - --- ------------------------------------------------------------ diff --git a/examples/mini/example1.xml b/examples/mini/example1.xml deleted file mode 100644 --- a/examples/mini/example1.xml +++ /dev/null @@ -1,22 +0,0 @@ - - - - - - - -]> - - - - - - hello world äöüß test - diff --git a/examples/xhtml/xhtml-lat1.ent b/examples/xhtml/xhtml-lat1.ent deleted file mode 100644 --- a/examples/xhtml/xhtml-lat1.ent +++ /dev/null @@ -1,196 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/xhtml/xhtml-special.ent b/examples/xhtml/xhtml-special.ent deleted file mode 100644 --- a/examples/xhtml/xhtml-special.ent +++ /dev/null @@ -1,79 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/xhtml/xhtml-symbol.ent b/examples/xhtml/xhtml-symbol.ent deleted file mode 100644 --- a/examples/xhtml/xhtml-symbol.ent +++ /dev/null @@ -1,242 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/xhtml/xhtml.xml b/examples/xhtml/xhtml.xml deleted file mode 100644 --- a/examples/xhtml/xhtml.xml +++ /dev/null @@ -1,1484 +0,0 @@ - - - - -XHTML 1.0: The Extensible HyperText Markup -Language - - - - - -
- table of contents -
-
-

W3C

- -

XHTML™ 1.0: -The Extensible HyperText Markup Language

- -

A Reformulation of HTML 4 in XML 1.0

- -

W3C Recommendation 26 January 2000

- -
-
This version:
- -
-http://www.w3.org/TR/2000/REC-xhtml1-20000126
-(Postscript version, -PDF version, -ZIP archive, or -Gzip'd TAR archive) -
- -
Latest version:
- -
-http://www.w3.org/TR/xhtml1
- -
Previous version:
- -
-http://www.w3.org/TR/1999/PR-xhtml1-19991210
- -
Authors:
- -
See acknowledgements.
-
- -

Copyright -©2000 W3C® (MIT, INRIA, Keio), All Rights Reserved. W3C liability, -trademark, -document -use and software -licensing rules -apply.

-
-
- -

Abstract

- -

This specification defines XHTML 1.0, a reformulation of HTML 4 -as an XML 1.0 application, and three DTDs corresponding to -the ones defined by HTML 4. The semantics of the elements and -their attributes are defined in the W3C Recommendation for HTML 4. -These semantics provide the foundation for future -extensibility of XHTML. Compatibility with existing HTML user -agents is possible by following a small set of guidelines.

- -

Status of this document

- -

This section describes the status of this document at the time -of its publication. Other documents may supersede this document. The -latest status of this document series is maintained at the W3C.

- -

-This document has been reviewed by W3C Members and other -interested parties and has been endorsed by the Director -as a W3C Recommendation. It is a stable document and may be -used as reference material or cited as a normative -reference from another document. W3C's role in making the -Recommendation is to draw attention to the specification and -to promote its widespread deployment. This enhances the -functionality and interoperability of the Web. -

-

This document has been produced as part of the W3C HTML Activity. The goals of -the HTML Working -Group (members -only) are discussed in the HTML Working Group -charter (members -only).

- -

A list of current W3C Recommendations and other technical documents -can be found at http://www.w3.org/TR.

- -

Public discussion on HTML features takes place on the mailing list www-html@w3.org (archive).

- -

Please report errors in this document to www-html-editor@w3.org.

- -

The list of known errors in this specification is available at http://www.w3.org/2000/01/REC-xhtml1-20000126-errata.

- -

Contents

- -
- -
- - -

1. What is XHTML?

- -

XHTML is a family of current and future document types and modules that -reproduce, subset, and extend HTML 4 [HTML]. XHTML family document types are XML based, -and ultimately are designed to work in conjunction with XML-based user agents. -The details of this family and its evolution are -discussed in more detail in the section on Future -Directions.

- -

XHTML 1.0 (this specification) is the first document type in the XHTML -family. It is a reformulation of the three HTML 4 document types as -applications of XML 1.0 [XML]. It is intended -to be used as a language for content that is both XML-conforming and, if some -simple guidelines are followed, -operates in HTML 4 conforming user agents. Developers who migrate -their content to XHTML 1.0 will realize the following benefits:

- -
    -
  • XHTML documents are XML conforming. As such, they are readily viewed, -edited, and validated with standard XML tools.
    • -
  • XHTML documents can be written to -to operate as well or better than they did before in existing -HTML 4-conforming user agents as well as in new, XHTML 1.0 conforming user -agents.
    • -
  • XHTML documents can utilize applications (e.g. scripts and applets) that rely -upon either the HTML Document Object Model or the XML Document Object Model [DOM].
    • -
  • As the XHTML family evolves, documents conforming to XHTML 1.0 will be more -likely to interoperate within and among various XHTML environments.
    • -
- -

The XHTML family is the next step in the evolution of the Internet. By -migrating to XHTML today, content developers can enter the XML world with all -of its attendant benefits, while still remaining confident in their -content's backward and future compatibility.

- -

1.1 What is HTML 4?

- -

HTML 4 [HTML] is an SGML (Standard -Generalized Markup Language) application conforming to -International Standard ISO 8879, and is widely regarded as the -standard publishing language of the World Wide Web.

- -

SGML is a language for describing markup languages, -particularly those used in electronic document exchange, document -management, and document publishing. HTML is an example of a -language defined in SGML.

- -

SGML has been around since the middle 1980's and has remained -quite stable. Much of this stability stems from the fact that the -language is both feature-rich and flexible. This flexibility, -however, comes at a price, and that price is a level of -complexity that has inhibited its adoption in a diversity of -environments, including the World Wide Web.

- -

HTML, as originally conceived, was to be a language for the -exchange of scientific and other technical documents, suitable -for use by non-document specialists. HTML addressed the problem -of SGML complexity by specifying a small set of structural and -semantic tags suitable for authoring relatively simple documents. -In addition to simplifying the document structure, HTML added -support for hypertext. Multimedia capabilities were added -later.

- -

In a remarkably short space of time, HTML became wildly -popular and rapidly outgrew its original purpose. Since HTML's -inception, there has been rapid invention of new elements for use -within HTML (as a standard) and for adapting HTML to vertical, -highly specialized, markets. This plethora of new elements has -led to compatibility problems for documents across different -platforms.

- -

As the heterogeneity of both software and platforms rapidly -proliferate, it is clear that the suitability of 'classic' HTML 4 -for use on these platforms is somewhat limited.

- -

1.2 What is XML?

- -

XML™ is the shorthand for Extensible Markup -Language, and is an acronym of Extensible Markup Language [XML].

- -

XML was conceived as a means of regaining the power and -flexibility of SGML without most of its complexity. Although a -restricted form of SGML, XML nonetheless preserves most of SGML's -power and richness, and yet still retains all of SGML's commonly -used features.

- -

While retaining these beneficial features, XML removes many of -the more complex features of SGML that make the authoring and -design of suitable software both difficult and costly.

- -

1.3 Why the need for XHTML?

- -

The benefits of migrating to XHTML 1.0 are described above. Some of the -benefits of migrating to XHTML in general are:

- -
    -
  • Document developers and user agent designers are constantly -discovering new ways to express their ideas through new markup. In XML, it is -relatively easy to introduce new elements or additional element -attributes. The XHTML family is designed to accommodate these extensions -through XHTML modules and techniques for developing new XHTML-conforming -modules (described in the forthcoming XHTML Modularization specification). -These modules will permit the combination of existing and -new feature sets when developing content and when designing new user -agents.
    • - -
  • Alternate ways of accessing the Internet are constantly being -introduced. Some estimates indicate that by the year 2002, 75% of -Internet document viewing will be carried out on these alternate -platforms. The XHTML family is designed with general user agent -interoperability in mind. Through a new user agent and document profiling -mechanism, servers, proxies, and user agents will be able to perform -best effort content transformation. Ultimately, it will be possible to -develop XHTML-conforming content that is usable by any XHTML-conforming -user agent.
    • - -
- -

2. Definitions

- -

2.1 Terminology

- -

The following terms are used in this specification. These -terms extend the definitions in -[RFC2119] in ways based upon similar definitions in ISO/IEC -9945-1:1990 [POSIX.1]:

- -
-
Implementation-defined
- -
A value or behavior is implementation-defined when it is left -to the implementation to define [and document] the corresponding -requirements for correct document construction.
- -
May
- -
With respect to implementations, the word "may" is to be -interpreted as an optional feature that is not required in this -specification but can be provided. With respect to Document Conformance, the word "may" means that -the optional feature must not be used. The term "optional" has -the same definition as "may".
- -
Must
- -
In this specification, the word "must" is to be interpreted -as a mandatory requirement on the implementation or on Strictly -Conforming XHTML Documents, depending upon the context. The term -"shall" has the same definition as "must".
- -
Reserved
- -
A value or behavior is unspecified, but it is not allowed to -be used by Conforming Documents nor to be supported by a -Conforming User Agents.
- -
Should
- -
With respect to implementations, the word "should" is to be -interpreted as an implementation recommendation, but not a -requirement. With respect to documents, the word "should" is to -be interpreted as recommended programming practice for documents -and a requirement for Strictly Conforming XHTML Documents.
- -
Supported
- -
Certain facilities in this specification are optional. If a -facility is supported, it behaves as specified by this -specification.
- -
Unspecified
- -
When a value or behavior is unspecified, the specification -defines no portability requirements for a facility on an -implementation even when faced with a document that uses the -facility. A document that requires specific behavior in such an -instance, rather than tolerating any behavior when using that -facility, is not a Strictly Conforming XHTML Document.
-
- -

2.2 General Terms

- -
-
Attribute
- -
An attribute is a parameter to an element declared in the -DTD. An attribute's type and value range, including a possible -default value, are defined in the DTD.
- -
DTD
- -
A DTD, or document type definition, is a collection of XML -declarations that, as a collection, defines the legal structure, -elements, and -attributes that are available for use in a document that -complies to the DTD.
- -
Document
- -
A document is a stream of data that, after being combined -with any other streams it references, is structured such that it -holds information contained within -elements that are organized as defined in the associated -DTD. See Document -Conformance for more information.
- -
Element
- -
An element is a document structuring unit declared in the -DTD. The element's content model is -defined in the DTD, and additional -semantics may be defined in the prose description of the -element.
- -
Facilities
- -
Functionality includes elements, -attributes, and the semantics -associated with those elements and -attributes. An implementation -supporting that functionality is said to provide the necessary -facilities.
- -
Implementation
- -
An implementation is a system that provides collection of -facilities and services that supports -this specification. See User Agent -Conformance for more information.
- -
Parsing
- -
Parsing is the act whereby a -document is scanned, and the information contained within -the document is filtered into the -context of the elements in which the -information is structured.
- -
Rendering
- -
Rendering is the act whereby the information in a document is presented. This presentation is -done in the form most appropriate to the environment (e.g. -aurally, visually, in print).
- -
User Agent
- -
A user agent is an implementation -that retrieves and processes XHTML documents. See User Agent Conformance for more information.
- -
Validation
- -
Validation is a process whereby -documents are verified against the associated DTD, ensuring that the structure, use of elements, and use of -attributes are consistent with the definitions in the -DTD.
- -
Well-formed
- -
A document is well-formed when it -is structured according to the rules defined in Section 2.1 of -the XML 1.0 Recommendation [XML]. -Basically, this definition states that elements, delimited by -their start and end tags, are nested properly within one -another.
-
- - -

3. Normative Definition of -XHTML 1.0

- -

3.1 Document -Conformance

- -

This version of XHTML provides a definition of strictly -conforming XHTML documents, which are restricted to tags and -attributes from the XHTML namespace. See Section 3.1.2 for information on using XHTML -with other namespaces, for instance, to include metadata -expressed in RDF within XHTML documents.

- -

3.1.1 Strictly Conforming -Documents

- -

A Strictly Conforming XHTML Document is a document that -requires only the facilities described as mandatory in this -specification. Such a document must meet all of the following -criteria:

- -
    -
  1. -

    It must validate against one of the three DTDs found in Appendix A.

    -
    2. - -
  2. -

    The root element of the document must be -<html>.

    -
    3. - -
  3. -

    The root element of the document must designate the XHTML -namespace using the xmlns attribute [XMLNAMES]. The namespace for XHTML is -defined to be -http://www.w3.org/1999/xhtml.

    -
    4. - -
  4. -

    There must be a DOCTYPE declaration in the document prior to -the root element. The public identifier included in -the DOCTYPE declaration must reference one of the three DTDs -found in Appendix A using the respective -Formal Public Identifier. The system identifier may be changed to reflect -local system conventions.

    - -
    -<!DOCTYPE html
-     PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-     "DTD/xhtml1-strict.dtd">
-
-<!DOCTYPE html
-     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-     "DTD/xhtml1-transitional.dtd">
-
-<!DOCTYPE html
-     PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
-     "DTD/xhtml1-frameset.dtd">
-
    -
    5. -
- -

Here is an example of a minimal XHTML document.

- -
-
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html
-     PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-    "DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-  <head>
-    <title>Virtual Library</title>
-  </head>
-  <body>
-    <p>Moved to <a href="http://vlib.org/">vlib.org</a>.</p>
-  </body>
-</html>
-
- -

Note that in this example, the XML declaration is included. An XML -declaration like the one above is -not required in all XML documents. XHTML document authors are strongly encouraged to use XML declarations in all their documents. Such a declaration is required -when the character encoding of the document is other than the default UTF-8 or -UTF-16.

- -

3.1.2 Using XHTML with -other namespaces

- -

The XHTML namespace may be used with other XML namespaces -as per [XMLNAMES], although such -documents are not strictly conforming XHTML 1.0 documents as -defined above. Future work by W3C will address ways to specify -conformance for documents involving multiple namespaces.

- -

The following example shows the way in which XHTML 1.0 could -be used in conjunction with the MathML Recommendation:

- -
-
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-  <head>
-    <title>A Math Example</title>
-  </head>
-  <body>
-    <p>The following is MathML markup:</p>
-    <math xmlns="http://www.w3.org/1998/Math/MathML">
-      <apply> <log/>
-        <logbase>
-          <cn> 3 </cn>
-        </logbase>
-        <ci> x </ci>
-      </apply>
-    </math>
-  </body>
-</html>
-
-
- -

The following example shows the way in which XHTML 1.0 markup -could be incorporated into another XML namespace:

- -
-
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- initially, the default namespace is "books" -->
-<book xmlns='urn:loc.gov:books'
-    xmlns:isbn='urn:ISBN:0-395-36341-6' xml:lang="en" lang="en">
-  <title>Cheaper by the Dozen</title>
-  <isbn:number>1568491379</isbn:number>
-  <notes>
-    <!-- make HTML the default namespace for a hypertext commentary -->
-    <p xmlns='http://www.w3.org/1999/xhtml'>
-        This is also available <a href="http://www.w3.org/">online</a>.
-    </p>
-  </notes>
-</book>
-
-
- -

3.2 User Agent -Conformance

- -

A conforming user agent must meet all of the following -criteria:

- -
    -
  1. In order to be consistent with the XML 1.0 Recommendation [XML], the user agent must parse and evaluate -an XHTML document for well-formedness. If the user agent claims -to be a validating user agent, it must also validate documents -against their referenced DTDs according to -[XML].
    2. - -
  2. When the user agent claims to support -facilities defined within this specification or required by -this specification through normative reference, it must do so in -ways consistent with the facilities' definition.
    3. - -
  3. When a user agent processes an XHTML document as generic XML, -it shall only recognize attributes of type -ID (e.g. the id attribute on most XHTML elements) -as fragment identifiers.
    4. - -
  4. If a user agent encounters an element it does not recognize, -it must render the element's content.
    5. - -
  5. If a user agent encounters an attribute it does not -recognize, it must ignore the entire attribute specification -(i.e., the attribute and its value).
    6. - -
  6. If a user agent encounters an attribute value it doesn't -recognize, it must use the default attribute value.
    7. - -
  7. If it encounters an entity reference (other than one -of the predefined entities) for which the User Agent has -processed no declaration (which could happen if the declaration -is in the external subset which the User Agent hasn't read), the entity -reference should be rendered as the characters (starting -with the ampersand and ending with the semi-colon) that -make up the entity reference.
    8. - -
  8. When rendering content, User Agents that encounter -characters or character entity references that are recognized but not renderable should display the document in such a way that it is obvious to the user that normal rendering has not taken place.
    9. - -
  9. -The following characters are defined in [XML] as whitespace characters: - -
      -
    • Space (&#x0020;)
      • -
    • Tab (&#x0009;)
      • -
    • Carriage return (&#x000D;)
      • -
    • Line feed (&#x000A;)
      • -
    - -

    -The XML processor normalizes different system's line end codes into one -single line-feed character, that is passed up to the application. The XHTML -user agent in addition, must treat the following characters as whitespace: -

    - -
      -
    • Form feed (&#x000C;)
      • -
    • Zero-width space (&#x200B;)
      • -
    - -

    -In elements where the 'xml:space' attribute is set to 'preserve', the user -agent must leave all whitespace characters intact (with the exception of -leading and trailing whitespace characters, which should be removed). -Otherwise, whitespace -is handled according to the following rules: -

    - -
      -
    • -All whitespace surrounding block elements should be removed. -
      • -
    • -Comments are removed entirely and do not affect whitespace handling. One -whitespace character on either side of a comment is treated as two white -space characters. -
      • -
    • -Leading and trailing whitespace inside a block element must be removed. -
      • -
    • Line feed characters within a block element must be converted into a -space (except when the 'xml:space' attribute is set to 'preserve'). -
      • -
    • -A sequence of white space characters must be reduced to a single space -character (except when the 'xml:space' attribute is set to 'preserve'). -
      • -
    • -With regard to rendition, -the User Agent should render the content in a -manner appropriate to the language in which the content is written. -In languages whose primary script is Latinate, the ASCII space -character is typically used to encode both grammatical word boundaries and -typographic whitespace; in languages whose script is related to Nagari -(e.g., Sanskrit, Thai, etc.), grammatical boundaries may be encoded using -the ZW 'space' character, but will not typically be represented by -typographic whitespace in rendered output; languages using Arabiform scripts -may encode typographic whitespace using a space character, but may also use -the ZW space character to delimit 'internal' grammatical boundaries (what -look like words in Arabic to an English eye frequently encode several words, -e.g. 'kitAbuhum' = 'kitAbu-hum' = 'book them' == their book); and languages -in the Chinese script tradition typically neither encode such delimiters nor -use typographic whitespace in this way. -
      • -
    - -

    Whitespace in attribute values is processed according to [XML].

    -
    10. -
- - -

4. Differences with HTML 4

- -

Due to the fact that XHTML is an XML application, certain -practices that were perfectly legal in SGML-based HTML 4 [HTML] must be changed.

- -

4.1 Documents must be -well-formed

- -

Well-formedness is a new concept -introduced by [XML]. Essentially this -means that all elements must either have closing tags or be -written in a special form (as described below), and that all the -elements must nest.

- -

Although overlapping is illegal in SGML, it was widely -tolerated in existing browsers.

- -
-

CORRECT: nested elements.

- -

<p>here is an emphasized -<em>paragraph</em>.</p>

-
- -
-

INCORRECT: overlapping elements

- -

<p>here is an emphasized -<em>paragraph.</p></em>

-
- -

4.2 Element and attribute -names must be in lower case

- -

XHTML documents must use lower case for all HTML element and -attribute names. This difference is necessary because XML is -case-sensitive e.g. <li> and <LI> are different -tags.

- -

4.3 For non-empty elements, -end tags are required

- -

In SGML-based HTML 4 certain elements were permitted to omit -the end tag; with the elements that followed implying closure. -This omission is not permitted in XML-based XHTML. All elements -other than those declared in the DTD as EMPTY must -have an end tag.

- -
-

CORRECT: terminated elements

- -

<p>here is a paragraph.</p><p>here is -another paragraph.</p>

-
- -
-

INCORRECT: unterminated elements

- -

<p>here is a paragraph.<p>here is another -paragraph.

-
- -

4.4 Attribute values must -always be quoted

- -

All attribute values must be quoted, even those which appear -to be numeric.

- -
-

CORRECT: quoted attribute values

- -

<table rows="3">

-
- -
-

INCORRECT: unquoted attribute values

- -

<table rows=3>

-
- -

4.5 Attribute -Minimization

- -

XML does not support attribute minimization. Attribute-value -pairs must be written in full. Attribute names such as -compact and checked cannot occur in elements -without their value being specified.

- -
-

CORRECT: unminimized attributes

- -

<dl compact="compact">

-
- -
-

INCORRECT: minimized attributes

- -

<dl compact>

-
- -

4.6 Empty Elements

- -

Empty elements must either have an end tag or the start tag must end with />. For instance, -<br/> or <hr></hr>. See HTML Compatibility Guidelines for information on ways to -ensure this is backward compatible with HTML 4 user agents.

- -
-

CORRECT: terminated empty tags

- -

<br/><hr/>

-
- -
-

INCORRECT: unterminated empty tags

- -

<br><hr>

-
- -

4.7 Whitespace handling in -attribute values

- -

In attribute values, user agents will strip leading and -trailing whitespace from attribute values and map sequences -of one or more whitespace characters (including line breaks) to -a single inter-word space (an ASCII space character for western -scripts). See -Section 3.3.3 of [XML].

- -

4.8 Script and Style -elements

- -

In XHTML, the script and style elements are declared as having -#PCDATA content. As a result, < and -& will be treated as the start of markup, and -entities such as &lt; and &amp; -will be recognized as entity references by the XML processor to -< and & respectively. Wrapping -the content of the script or style element within a -CDATA marked section avoids the expansion of these -entities.

- -
-
-<script>
- <![CDATA[
- ... unescaped script content ...
- ]]>
- </script>
-
-
- -

CDATA sections are recognized by the XML -processor and appear as nodes in the Document Object Model, see - -Section 1.3 of the DOM Level 1 Recommendation [DOM].

- -

An alternative is to use external script and style -documents.

- -

4.9 SGML exclusions

- -

SGML gives the writer of a DTD the ability to exclude specific -elements from being contained within an element. Such -prohibitions (called "exclusions") are not possible in XML.

- -

For example, the HTML 4 Strict DTD forbids the nesting of an -'a' element within another 'a' element -to any descendant depth. It is not possible to spell out such -prohibitions in XML. Even though these prohibitions cannot be -defined in the DTD, certain elements should not be nested. A -summary of such elements and the elements that should not be -nested in them is found in the normative -Appendix B.

- -

4.10 The elements with 'id' and 'name' -attributes

- -

HTML 4 defined the name attribute for the elements -a, -applet, form, frame, -iframe, img, and map. -HTML 4 also introduced -the id attribute. Both of these attributes are designed to be -used as fragment identifiers.

-

In XML, fragment identifiers are of type ID, and -there can only be a single attribute of type ID per element. -Therefore, in XHTML 1.0 the id -attribute is defined to be of type ID. In order to -ensure that XHTML 1.0 documents are well-structured XML documents, XHTML 1.0 -documents MUST use the id attribute when defining fragment -identifiers, even on elements that historically have also had a -name attribute. -See the HTML Compatibility -Guidelines for information on ensuring such anchors are backwards -compatible when serving XHTML documents as media type text/html. -

-

Note that in XHTML 1.0, the name attribute of these -elements is formally deprecated, and will be removed in a -subsequent version of XHTML.

- - -

5. Compatibility Issues

- -

Although there is no requirement for XHTML 1.0 documents to be -compatible with existing user agents, in practice this is easy to -accomplish. Guidelines for creating compatible documents can be -found in Appendix C.

- -

5.1 Internet Media Type

-

As of the publication of this recommendation, the general -recommended MIME labeling for XML-based applications -has yet to be resolved.

- -

However, XHTML Documents which follow the guidelines set forth -in Appendix C, "HTML Compatibility Guidelines" may be -labeled with the Internet Media Type "text/html", as they -are compatible with most HTML browsers. This document -makes no recommendation about MIME labeling of other -XHTML documents.

- - -

6. Future Directions

- -

XHTML 1.0 provides the basis for a family of document types -that will extend and subset XHTML, in order to support a wide -range of new devices and applications, by defining modules and -specifying a mechanism for combining these modules. This -mechanism will enable the extension and sub-setting of XHTML 1.0 -in a uniform way through the definition of new modules.

- -

6.1 Modularizing HTML

- -

As the use of XHTML moves from the traditional desktop user -agents to other platforms, it is clear that not all of the XHTML -elements will be required on all platforms. For example a hand -held device or a cell-phone may only support a subset of XHTML -elements.

- -

The process of modularization breaks XHTML up into a series of -smaller element sets. These elements can then be recombined to -meet the needs of different communities.

- -

These modules will be defined in a later W3C document.

- -

6.2 Subsets and -Extensibility

- -

Modularization brings with it several advantages:

- -
    -
  • -

    It provides a formal mechanism for sub-setting XHTML.

    -
    • - -
  • -

    It provides a formal mechanism for extending XHTML.

    -
    • - -
  • -

    It simplifies the transformation between document types.

    -
    • - -
  • -

    It promotes the reuse of modules in new document types.

    -
    • -
- -

6.3 Document -Profiles

- -

A document profile specifies the syntax and semantics of a set -of documents. Conformance to a document profile provides a basis -for interoperability guarantees. The document profile specifies -the facilities required to process documents of that type, e.g. -which image formats can be used, levels of scripting, style sheet -support, and so on.

- -

For product designers this enables various groups to define -their own standard profile.

- -

For authors this will obviate the need to write several -different versions of documents for different clients.

- -

For special groups such as chemists, medical doctors, or -mathematicians this allows a special profile to be built using -standard HTML elements plus a group of elements geared to the -specialist's needs.

- - -

-Appendix A. DTDs

- -

This appendix is normative.

- -

These DTDs and entity sets form a normative part of this -specification. The complete set of DTD files together with an XML -declaration and SGML Open Catalog is included in the zip file for this specification.

- -

A.1 Document Type -Definitions

- -

These DTDs approximate the HTML 4 DTDs. It is likely that -when the DTDs are modularized, a method of DTD construction will -be employed that corresponds more closely to HTML 4.

- - - -

A.2 Entity Sets

- -

The XHTML entity sets are the same as for HTML 4, but have -been modified to be valid XML 1.0 entity declarations. Note the -entity for the Euro currency sign (&euro; or -&#8364; or &#x20AC;) is defined -as part of the special characters.

- - - - -

Appendix B. Element -Prohibitions

- -

This appendix is normative.

- -

The following elements have prohibitions on which elements -they can contain (see Section 4.9). This -prohibition applies to all depths of nesting, i.e. it contains -all the descendant elements.

- -
a
-
-cannot contain other a elements.
-
pre
-
cannot contain the img, object, -big, small, sub, or -sup elements.
- -
button
-
cannot contain the input, select, -textarea, label, button, -form, fieldset, iframe or -isindex elements.
-
label
-
cannot contain other label elements.
-
form
-
cannot contain other form elements.
-
- - -

Appendix C. -HTML Compatibility Guidelines

- -

This appendix is informative.

- -

This appendix summarizes design guidelines for authors who -wish their XHTML documents to render on existing HTML user -agents.

- -

C.1 Processing Instructions

-

Be aware that processing instructions are rendered on some -user agents. However, also note that when the XML declaration is not included -in a document, the document can only use the default character encodings UTF-8 -or UTF-16.

- -

C.2 Empty Elements

-

Include a space before the trailing / and -> of empty elements, e.g. -<br />, -<hr /> and <img -src="karen.jpg" alt="Karen" />. Also, use the -minimized tag syntax for empty elements, e.g. <br />, as the alternative syntax <br></br> allowed by XML -gives uncertain results in many existing user agents.

- -

C.3 Element Minimization and Empty Element Content

-

Given an empty instance of an element whose content model is -not EMPTY (for example, an empty title or paragraph) -do not use the minimized form (e.g. use -<p> </p> and not -<p />).

- -

C.4 Embedded Style Sheets and Scripts

-

Use external style sheets if your style sheet uses -< or & or ]]> or --. Use -external scripts if your script uses < or -& or ]]> or --. Note that XML parsers -are permitted to silently remove the contents of comments. Therefore, the historical -practice of "hiding" scripts and style sheets within comments to make the -documents backward compatible is likely to not work as expected in XML-based -implementations.

- -

C.5 Line Breaks within Attribute Values

-

Avoid line breaks and multiple whitespace characters within -attribute values. These are handled inconsistently by user -agents.

- -

C.6 Isindex

-

Don't include more than one isindex element in -the document head. The isindex element -is deprecated in favor of the input element.

- -

C.7 The lang and xml:lang Attributes

-

Use both the lang and xml:lang -attributes when specifying the language of an element. The value -of the xml:lang attribute takes precedence.

- -

C.8 Fragment Identifiers

-

In XML, URIs [RFC2396] that end with fragment identifiers of the form -"#foo" do not refer to elements with an attribute -name="foo"; rather, they refer to elements with an -attribute defined to be of type ID, e.g., the -id attribute in HTML 4. Many existing HTML clients don't -support the use of ID-type attributes in this way, -so identical values may be supplied for both of these attributes to ensure -maximum forward and backward compatibility (e.g., <a id="foo" name="foo">...</a>).

- -

Further, since the set of -legal values for attributes of type ID is much smaller than -for those of type CDATA, the type of the name -attribute has been changed to NMTOKEN. This attribute is -constrained such that it can only have the same values as type -ID, or as the Name production in XML 1.0 Section -2.5, production 5. Unfortunately, this constraint cannot be expressed in the -XHTML 1.0 DTDs. Because of this change, care must be taken when -converting existing HTML documents. The values of these attributes -must be unique within the document, valid, and any references to these -fragment identifiers (both -internal and external) must be updated should the values be changed during -conversion.

-

Finally, note that XHTML 1.0 has deprecated the -name attribute of the a, applet, form, frame, iframe, img, and map -elements, and it will be -removed from XHTML in subsequent versions.

- -

C.9 Character Encoding

-

To specify a character encoding in the document, use both the -encoding attribute specification on the xml declaration (e.g. -<?xml version="1.0" -encoding="EUC-JP"?>) and a meta http-equiv statement -(e.g. <meta http-equiv="Content-type" -content='text/html; charset="EUC-JP"' />). The -value of the encoding attribute of the xml processing instruction -takes precedence.

- -

C.10 Boolean Attributes

-

Some HTML user agents are unable to interpret boolean -attributes when these appear in their full (non-minimized) form, -as required by XML 1.0. Note this problem doesn't affect user -agents compliant with HTML 4. The following attributes are -involved: compact, nowrap, -ismap, declare, noshade, -checked, disabled, readonly, -multiple, selected, -noresize, defer.

- -

C.11 Document Object Model and XHTML

-

-The Document Object Model level 1 Recommendation [DOM] -defines document object model interfaces for XML and HTML 4. The HTML 4 -document object model specifies that HTML element and attribute names are -returned in upper-case. The XML document object model specifies that -element and attribute names are returned in the case they are specified. In -XHTML 1.0, elements and attributes are specified in lower-case. This apparent difference can be -addressed in two ways: -

-
    -
  1. Applications that access XHTML documents served as Internet media type -text/html -via the DOM can use the HTML DOM, -and can rely upon element and attribute names being returned in -upper-case from those interfaces.
    2. -
  2. Applications that access XHTML documents served as Internet media types -text/xml or application/xml -can also use the XML DOM. Elements and attributes will be returned in lower-case. -Also, some XHTML elements may or may -not appear -in the object tree because they are optional in the content model -(e.g. the tbody element within -table). This occurs because in HTML 4 some elements were -permitted to be minimized such that their start and end tags are both omitted -(an SGML feature). -This is not possible in XML. Rather than require document authors to insert -extraneous elements, XHTML has made the elements optional. -Applications need to adapt to this -accordingly.
    3. -
- -

C.12 Using Ampersands in Attribute Values

-

-When an attribute value contains an ampersand, it must be expressed as a character -entity reference -(e.g. "&amp;"). For example, when the -href attribute -of the a element refers to a -CGI script that takes parameters, it must be expressed as -http://my.site.dom/cgi-bin/myscript.pl?class=guest&amp;name=user -rather than as -http://my.site.dom/cgi-bin/myscript.pl?class=guest&name=user. -

- -

C.13 Cascading Style Sheets (CSS) and XHTML

- -

The Cascading Style Sheets level 2 Recommendation [CSS2] defines style -properties which are applied to the parse tree of the HTML or XML -document. Differences in parsing will produce different visual or -aural results, depending on the selectors used. The following hints -will reduce this effect for documents which are served without -modification as both media types:

- -
    -
  1. -CSS style sheets for XHTML should use lower case element and -attribute names.
    2. - - -
  2. In tables, the tbody element will be inferred by the parser of an -HTML user agent, but not by the parser of an XML user agent. Therefore -you should always explicitly add a tbody element if it is referred to -in a CSS selector.
    3. - -
  3. Within the XHTML name space, user agents are expected to -recognize the "id" attribute as an attribute of type ID. -Therefore, style sheets should be able to continue using the -shorthand "#" selector syntax even if the user agent does not read -the DTD.
    4. - -
  4. Within the XHTML name space, user agents are expected to -recognize the "class" attribute. Therefore, style sheets should be -able to continue using the shorthand "." selector syntax.
    5. - -
  5. -CSS defines different conformance rules for HTML and XML documents; -be aware that the HTML rules apply to XHTML documents delivered as -HTML and the XML rules apply to XHTML documents delivered as XML.
    6. -
- -

Appendix D. -Acknowledgements

- -

This appendix is informative.

- -

This specification was written with the participation of the -members of the W3C HTML working group:

- -
-
Steven Pemberton, CWI (HTML Working Group Chair)
-Murray Altheim, Sun Microsystems
-Daniel Austin, AskJeeves (CNET: The Computer Network through July 1999)
-Frank Boumphrey, HTML Writers Guild
-John Burger, Mitre
-Andrew W. Donoho, IBM
-Sam Dooley, IBM
-Klaus Hofrichter, GMD
-Philipp Hoschka, W3C
-Masayasu Ishikawa, W3C
-Warner ten Kate, Philips Electronics
-Peter King, Phone.com
-Paula Klante, JetForm
-Shin'ichi Matsui, Panasonic (W3C visiting engineer through September 1999)
-Shane McCarron, Applied Testing and Technology (The Open Group through August -1999)
-Ann Navarro, HTML Writers Guild
-Zach Nies, Quark
-Dave Raggett, W3C/HP (W3C lead for HTML)
-Patrick Schmitz, Microsoft
-Sebastian Schnitzenbaumer, Stack Overflow
-Peter Stark, Phone.com
-Chris Wilson, Microsoft
-Ted Wugofski, Gateway 2000
-Dan Zigmond, WebTV Networks
-
- - -

Appendix E. References

- -

This appendix is informative.

- -
- -
[CSS2]
- -
"Cascading Style Sheets, level 2 (CSS2) Specification", B. -Bos, H. W. Lie, C. Lilley, I. Jacobs, 12 May 1998.
-Latest version available at: -http://www.w3.org/TR/REC-CSS2
- -
[DOM]
- -
"Document Object Model (DOM) Level 1 Specification", Lauren -Wood et al., 1 October 1998.
-Latest version available at: -http://www.w3.org/TR/REC-DOM-Level-1
- -
[HTML]
- -
"HTML 4.01 Specification", D. Raggett, A. Le Hors, I. -Jacobs, 24 December 1999.
-Latest version available at: -http://www.w3.org/TR/html401
- -
[POSIX.1]
- -
"ISO/IEC 9945-1:1990 Information Technology - Portable -Operating System Interface (POSIX) - Part 1: System Application -Program Interface (API) [C Language]", Institute of Electrical -and Electronics Engineers, Inc, 1990.
- -
-[RFC2046]
- -
"RFC2046: Multipurpose Internet Mail Extensions (MIME) Part -Two: Media Types", N. Freed and N. Borenstein, November -1996.
-Available at -http://www.ietf.org/rfc/rfc2046.txt. Note that this RFC -obsoletes RFC1521, RFC1522, and RFC1590.
- -
-[RFC2119]
- -
"RFC2119: Key words for use in RFCs to Indicate Requirement -Levels", S. Bradner, March 1997.
-Available at: -http://www.ietf.org/rfc/rfc2119.txt
- -
-[RFC2376]
- -
"RFC2376: XML Media Types", E. Whitehead, M. Murata, July -1998.
-Available at: -http://www.ietf.org/rfc/rfc2376.txt
- -
-[RFC2396]
- -
"RFC2396: Uniform Resource Identifiers (URI): Generic -Syntax", T. Berners-Lee, R. Fielding, L. Masinter, August -1998.
-This document updates RFC1738 and RFC1808.
-Available at: -http://www.ietf.org/rfc/rfc2396.txt
- -
[XML]
- -
"Extensible Markup Language (XML) 1.0 Specification", T. -Bray, J. Paoli, C. M. Sperberg-McQueen, 10 February 1998.
-Latest version available at: -http://www.w3.org/TR/REC-xml
- -
[XMLNAMES]
- -
"Namespaces in XML", T. Bray, D. Hollander, A. Layman, 14 -January 1999.
-XML namespaces provide a simple method for qualifying names used -in XML documents by associating them with namespaces identified -by URI.
-Latest version available at: -http://www.w3.org/TR/REC-xml-names
- -
-

-

-
-
- table of contents -
- - - diff --git a/examples/xhtml/xhtml1-frameset.dtd b/examples/xhtml/xhtml1-frameset.dtd deleted file mode 100644 --- a/examples/xhtml/xhtml1-frameset.dtd +++ /dev/null @@ -1,1225 +0,0 @@ - - - - - -%HTMLlat1; - - -%HTMLsymbol; - - -%HTMLspecial; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/xhtml/xhtml1-strict.dtd b/examples/xhtml/xhtml1-strict.dtd deleted file mode 100644 --- a/examples/xhtml/xhtml1-strict.dtd +++ /dev/null @@ -1,988 +0,0 @@ - - - - - -%HTMLlat1; - - -%HTMLsymbol; - - -%HTMLspecial; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/xhtml/xhtml1-transitional.dtd b/examples/xhtml/xhtml1-transitional.dtd deleted file mode 100644 --- a/examples/xhtml/xhtml1-transitional.dtd +++ /dev/null @@ -1,1196 +0,0 @@ - - - - - -%HTMLlat1; - - -%HTMLsymbol; - - -%HTMLspecial; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/hxt-filter.cabal b/hxt-filter.cabal --- a/hxt-filter.cabal +++ b/hxt-filter.cabal @@ -1,6 +1,6 @@ -- arch-tag: Haskell XML Toolbox main description file name: hxt-filter -version: 8.3.0 +version: 8.4.0 license: OtherLicense license-file: LICENCE maintainer: Uwe Schmidt @@ -53,15 +53,15 @@ ghc-options: -Wall extensions: MultiParamTypeClasses DeriveDataTypeable FunctionalDependencies FlexibleInstances - build-depends: base >= 4, - haskell98 >= 1, - containers >= 0.1, - directory >= 1, - filepath >= 1, - parsec >= 2.1 && < 3, - HUnit >= 1.2, - network >= 2.1, - HTTP >= 4000.0.4 && < 5000, - process >= 1.0.1, - hxt >= 8.3 + build-depends: base >= 4.2 && < 5, + haskell98 >= 1 && < 2, + containers >= 0.3 && < 1, + directory >= 1 && < 2, + filepath >= 1 && < 2, + parsec >= 2.1 && < 4, + HUnit >= 1.2 && < 2, + network >= 2.1 && < 3, + HTTP >= 4000 && < 5000, + process >= 1.0.1 && < 2, + hxt >= 8.4 && < 9 diff --git a/src/Data/Tree/NTree/Filter.hs b/src/Data/Tree/NTree/Filter.hs --- a/src/Data/Tree/NTree/Filter.hs +++ b/src/Data/Tree/NTree/Filter.hs @@ -905,8 +905,7 @@ performAction :: Monad m => (a -> m b) -> a -> m [a] performAction cmd t - = do - cmd t - return [t] + = cmd t + >> return [t] -- eof ------------------------------------------------------------ diff --git a/src/HXT.hs b/src/HXT.hs deleted file mode 100644 --- a/src/HXT.hs +++ /dev/null @@ -1,5 +0,0 @@ -module HXT -where - -import Text.XML.HXT.DOM as DOM () -import Text.XML.HXT.Parser as P() diff --git a/src/Makefile b/src/Makefile deleted file mode 100644 --- a/src/Makefile +++ /dev/null @@ -1,163 +0,0 @@ -# ------------------------------------------------------------ -# -# global names and dirs - -include ../Version.mk - -HXT_HOME = .. -HXT_HOME_PATH = $(shell cd $(HXT_HOME) ; pwd) -PACKAGE_DIR = $(HXT_HOME_PATH)/lib/$(SOFTWARE) -IMPORT_DIR = imports -HXT_PACKAGE = $(SOFTWARE) - -# ------------------------------------------------------------ -# -# commands - -GHCFLAGS = -Wall -O2 -fglasgow-exts -ignore-package $(SOFTWARE) -GHC = ghc $(GHCFLAGS) -GHCVERSION = $(shell ghc -v 2>&1 | head -n 2 | tail -n 1 | cut -d " " -f 5 | sed 's|^.*ghc-\([0-9.]*\)/package.conf|\1|') - -HXT_PACKAGE_NAME=$(DIST_NAME) - -RM = rm -f - -all : - -packagename : - @echo $(HXT_PACKAGE_NAME) - -# ------------------------------------------------------------ -# -# protocol handler config (for removing http or popen) - -./Text/XML/HXT/Parser/ProtocolHandler.hs : ./Text/XML/HXT/ProtocolHandler/ProtocolHandler.hs - $(MAKE) -C ./Text/XML/HXT/ProtocolHandler default_http - -# ------------------------------------------------------------ -# -# hxt package variables and rules - -HXT_SRC = \ - $(wildcard Control/Monad/*.hs) \ - $(wildcard Data/Tree/NTree/*.hs) \ - $(wildcard System/*.hs) \ - $(wildcard Text/XML/HXT/*.hs) \ - $(wildcard Text/XML/HXT/DOM/*.hs) \ - $(wildcard Text/XML/HXT/Parser/*.hs) \ - $(wildcard Text/XML/HXT/Validator/*.hs) - -HXT_OBJ = $(HXT_SRC:.hs=.o) -HXT_HI = $(HXT_SRC:.hs=.hi) - -HXT_DRIVER = HXT.o -HXT_LIBA = libHS$(HXT_PACKAGE).a -HXT_LIBO = HS$(HXT_PACKAGE).o -HXT_LIB = $(HXT_LIBA) $(HXT_LIBO) -HXT_REQ_PKG = -package parsec -package HTTP -package hxt-8.3.0 - -$(HXT_LIBA) : $(HXT_SRC) - $(GHC) -package-name $(HXT_PACKAGE_NAME) $(HXT_REQ_PKG) --make $(HXT_DRIVER:.o=.hs) - ar crs $@ $(HXT_OBJ) - @echo "# please note: !! GNU ar (at least 2.15.90) does not set exit code on missing .o files !!" - -$(HXT_LIBO) : $(HXT_LIBA) - ld -r --whole-archive -o $@ $< - -# ------------------------------------------------------------ -# - -PROFFLAGS = -Wall -fglasgow-exts $(HXT_REQ_PKG) -prof -auto -ignore-package hxt -ignore-package HTTP -i../profiling - -prof : - ghc $(PROFFLAGS) --make $(HXT_DRIVER:.o=.hs) - -# ------------------------------------------------------------ - -LOCAL_INSTALL_DIR = $(PACKAGE_DIR) -LOCAL_IMPORT_DIR = $(PACKAGE_DIR)/$(IMPORT_DIR) - -PKG_LIB = -PKG_NAME = -PKG_HI = - -install_local_$(HXT_PACKAGE) : $(HXT_LIB) $(SOFTWARE)-package.conf - $(MAKE) install_local_package PKG_NAME=$(HXT_PACKAGE) PKG_LIB="$(HXT_LIB)" PKG_HI="$(HXT_HI)" - -install_local_package : $(PKG_NAME)-package.conf - [ -d $(LOCAL_INSTALL_DIR) ] || mkdir -p $(LOCAL_INSTALL_DIR) - [ -d $(LOCAL_IMPORT_DIR) ] || mkdir -p $(LOCAL_IMPORT_DIR) - cp -f $(PKG_LIB) $(LOCAL_INSTALL_DIR) - tar cvf - $(PKG_HI) | ( cd $(LOCAL_IMPORT_DIR) ; tar xf - ) - [ -f $(LOCAL_INSTALL_DIR)/package.conf ] || echo "[]" > $(LOCAL_INSTALL_DIR)/package.conf - cat $(PKG_NAME)-package.conf \ - | ghc-pkg update - --package-conf=$(LOCAL_INSTALL_DIR)/package.conf - @echo use package with: ghc\(i\) ... -package-conf $(LOCAL_INSTALL_DIR)/package.conf -package $(PKG_NAME) ... - -GHC_INSTALL = $(shell ghc -v 2>&1 | head -n 2 | tail -n 1 | cut -d " " -f 5 | sed 's|/package.conf||') -GHC_INSTALL_DIR = $(GHC_INSTALL)/$(SOFTWARE) -GHC_PKG_CONF = - -install : $(SOFTWARE)-package.conf - @[ -d $(GHC_INSTALL) ] || ( echo "ghc install dir not found" 1>&2 ; exit 1 ) - @[ -w $(GHC_INSTALL) ] || ( echo "you need root access for this target" ; exit 1 ) - [ -d $(GHC_INSTALL_DIR) ] || mkdir -p $(GHC_INSTALL_DIR) - cp -r $(LOCAL_INSTALL_DIR)/*.[ao] $(LOCAL_INSTALL_DIR)/imports $(GHC_INSTALL_DIR) - $(MAKE) install_packages - @echo - @echo use package with: ghc\(i\) ... -package $(HXT_PACKAGE) ... - -uninstall : - @[ -d $(GHC_INSTALL) ] || ( echo "ghc install dir not found" 1>&2 ; exit 1 ) - @[ -w $(GHC_INSTALL) ] || ( echo "you need root access for this target" ; exit 1 ) - $(MAKE) uninstall_packages - rm -rf $(GHC_INSTALL_DIR) - -# ------------------------------------------------------------ - -all : - $(MAKE) install_local_$(HXT_PACKAGE) - -$(SOFTWARE)-package.conf : $(SOFTWARE)-package.hs - ghc -o $(SOFTWARE)-package $(SOFTWARE)-package.hs - ./$(SOFTWARE)-package $(VERSION) "ghc" $(LOCAL_INSTALL_DIR) $(HXT_SRC) > $@ - -../$(SOFTWARE).cabal : $(SOFTWARE)-package.hs Makefile ../Makefile - ghc -o $(SOFTWARE)-package $(SOFTWARE)-package.hs - ./$(SOFTWARE)-package $(VERSION) "cabal" $(GHC_INSTALL_DIR) $(HXT_SRC) > $@ - -install_packages : - runghc $(SOFTWARE)-package.hs $(VERSION) "ghc" $(GHC_INSTALL_DIR) $(HXT_SRC) \ - | ghc-pkg --update-package - -uninstall_packages : - ghc-pkg --remove-package $(HXT_PACKAGE) || true - -clean_packages : - $(MAKE) clean_$(HXT_PACKAGE) - -clean : - $(MAKE) clean_packages - $(MAKE) -C ./Text/XML/HXT/ProtocolHandler clean - rm -rf $(LOCAL_INSTALL_DIR) $(SOFTWARE)-package.conf ../$(SOFTWARE).cabal - -clean_$(HXT_PACKAGE) : - $(RM) $(HXT_DRIVER) $(HXT_DRIVER:.o=.hi) $(HXT_OBJ) $(HXT_HI) $(HXT_LIB) - -# ------------------------------------------------------------ - -DIST = ../$(DIST_NAME) -DIST_DIR = $(DIST)/src -DIST_FILES = Makefile \ - $(HXT_SRC) $(HXT_DRIVER:.o=.hs) $(SOFTWARE)-package.hs \ - ./Text/XML/HXT/ProtocolHandler/ProtocolHandler.hs \ - ./Text/XML/HXT/ProtocolHandler/Makefile - - -dist : - [ -d $(DIST_DIR) ] || mkdir -p $(DIST_DIR) - tar cvf - $(DIST_FILES) | ( cd $(DIST_DIR) ; tar xf - ) - -.PHONY : all install doc clean dist - -# eof ------------------------------------------------------------ diff --git a/src/Text/XML/HXT/DOM/Namespace.hs b/src/Text/XML/HXT/DOM/Namespace.hs --- a/src/Text/XML/HXT/DOM/Namespace.hs +++ b/src/Text/XML/HXT/DOM/Namespace.hs @@ -45,8 +45,8 @@ errs = validateNamespaces t in if null errs then thisM t - else do - liftF this $$< errs + else ( liftF this $$< errs ) + >> return (setStatus c_err "namespace propagation" t) -- ----------------------------------------------------------------------------- diff --git a/src/Text/XML/HXT/DOM/XmlState.hs b/src/Text/XML/HXT/DOM/XmlState.hs --- a/src/Text/XML/HXT/DOM/XmlState.hs +++ b/src/Text/XML/HXT/DOM/XmlState.hs @@ -155,9 +155,8 @@ setSysErrorHandler :: XmlStateFilter () -> XState state () setSysErrorHandler ehf - = do - changeSysState (\ s -> s { sysStateErrorHandler = ehf }) - return () + = changeSysState (\ s -> s { sysStateErrorHandler = ehf }) + >> return () -- | -- get the error handler @@ -183,9 +182,8 @@ setSysParamTree :: String -> XmlTrees -> XState state () setSysParamTree name val - = do - changeSysState (changeSysStateAttrs (addEntry name val)) - return () + = changeSysState (changeSysStateAttrs (addEntry name val)) + >> return () -- | -- set or change a single system parameter of type string. @@ -216,9 +214,8 @@ setSystemParams :: XmlStateFilter state setSystemParams t - = do - changeSysState (changeSysStateAttrs (addEntries (toTreel . getAttrl $ t))) - thisM t + = changeSysState (changeSysStateAttrs (addEntries (toTreel . getAttrl $ t))) + >> thisM t -- ------------------------------------------------------------ @@ -335,7 +332,7 @@ = do sysState0 <- getSysState (res, finalState1) <- io $ run0 (XmlState sysState0 initialUserState1) cmd1 - setSysState (sysState finalState1) + _ <- setSysState (sysState finalState1) return (res, (userState finalState1)) -- | @@ -500,7 +497,7 @@ = performAction ( \ t -> chain' () ( do ehf <- getSysErrorHandler - ehf t + _ <- ehf t return () ) ) @@ -621,9 +618,8 @@ checkStatus :: XmlStateFilter state checkStatus t = if status >= c_err - then do - errorMsgHandler (mkXErrorTree c_warn (errClass status ++ "s detected in " ++ msg) []) - noneM t + then errorMsgHandler (mkXErrorTree c_warn (errClass status ++ "s detected in " ++ msg) []) + >> noneM t else thisM t where diff --git a/src/Text/XML/HXT/Parser/DTDProcessing.hs b/src/Text/XML/HXT/Parser/DTDProcessing.hs --- a/src/Text/XML/HXT/Parser/DTDProcessing.hs +++ b/src/Text/XML/HXT/Parser/DTDProcessing.hs @@ -353,9 +353,8 @@ | isDTDElemNode CONDSECT xn -- conditional section && loc == Internal - = do - issueErr "conditional sections in internal part of the DTD is not allowed" n - return [] + = issueErr "conditional sections in internal part of the DTD is not allowed" n + >> return [] | isDTDElemNode CONDSECT xn -- conditional section && @@ -414,7 +413,7 @@ addPE name t = do trace 2 ("substParamEntity: add entity to env: " ++ xshow [t]) - changeState $ addPeEntry name t + _ <- changeState $ addPeEntry name t return [] substPEref :: DTDStateFilter @@ -568,7 +567,7 @@ = return [] | otherwise = do - checkStandalone + _ <- checkStandalone dtdContent <- ( getXmlEntityContents .>> traceMsg 2 ("processExternalDTD: parsing DTD part for " ++ show sysVal) @@ -579,7 +578,7 @@ ) $ newDocument sysVal trace 2 "processExternalDTD: parsing DTD part done" - traceTree $ mkRootTree [] dtdContent + _ <- traceTree $ mkRootTree [] dtdContent return dtdContent where sysVal = lookup1 k_system al @@ -756,14 +755,14 @@ = return [] | null txt' -- something weird in entity content = do - issueErr ("illegal external parsed entity value for entity " ++ show name) n + _ <- issueErr ("illegal external parsed entity value for entity " ++ show name) n return [] | otherwise -- o.k.: parse the contents = do res' <- liftF (parseXmlGeneralEntityValue ("external parsed entity " ++ show name)) $$< txt' - ( traceSource - .>> - traceTree ) $ mkRootTree (fromAttrl context) res' + _ <- ( traceSource + .>> + traceTree ) $ mkRootTree (fromAttrl context) res' return res' where txt' = (getChildren .> isXText) $$ cl' @@ -775,11 +774,11 @@ case lookupGeEnv name' geEnv' of Just _fct -> do - issueWarn ("entity " ++ show name ++ " already defined, repeated definition ignored") n + _ <- issueWarn ("entity " ++ show name ++ " already defined, repeated definition ignored") n return [] Nothing -> do - changeState $ addGeEntry name' fct' + _ <- changeState $ addGeEntry name' fct' return $ this n -- -------- @@ -803,7 +802,7 @@ = do trace 2 ("substExternalParsed1Time: read and parse external parsed entity " ++ show name) res <- runInLocalURIContext getContents' $ newDocument' context - changeState $ addGeEntry name (substExternalParsed res) + _ <- changeState $ addGeEntry name (substExternalParsed res) substExternalParsed res cx' rl' n' where getContents' :: GeStateFilter @@ -851,7 +850,7 @@ forbidden msg' cx' -- 4.4.4 = do - issueErr ("reference of " ++ msg' ++ show name ++ " forbidden in " ++ cx') n + _ <- issueErr ("reference of " ++ msg' ++ show name ++ " forbidden in " ++ cx') n return [] -- normalize default value in ATTLIST @@ -878,13 +877,13 @@ Just fct -> if name `elem` rl then do - issueErr ("recursive substitution of general entity reference " ++ show ref ++ " not processed") n + _ <- issueErr ("recursive substitution of general entity reference " ++ show ref ++ " not processed") n return nl else do fct cx rl n Nothing -> do - issueErr ("general entity reference " ++ show ref ++ " not processed, no definition found, (forward reference?)") n + _ <- issueErr ("general entity reference " ++ show ref ++ " not processed, no definition found, (forward reference?)") n return nl where nl = this n diff --git a/src/Text/XML/HXT/Parser/HtmlParser.hs b/src/Text/XML/HXT/Parser/HtmlParser.hs --- a/src/Text/XML/HXT/Parser/HtmlParser.hs +++ b/src/Text/XML/HXT/Parser/HtmlParser.hs @@ -120,11 +120,11 @@ in do if null warnings then thisM t' - else do - if noWarnings + else ( if noWarnings then return [] else do issueError $$< warnings + ) >> return (remWarnings t') -- | The pure HTML parser, usually called via 'parseHtmlDoc'. @@ -133,11 +133,9 @@ runHtmlParser :: XmlStateFilter a runHtmlParser t = if null errs - then do - return (replaceChildren res t) - else do - issueError $$< errs - return (setStatus c_err "parsing HTML" t) + then return (replaceChildren res t) + else (issueError $$< errs) + >> return (setStatus c_err "parsing HTML" t) where res = getChildren .> parseHtmlText loc $ t errs = isXError .> neg isWarning $$ res diff --git a/src/Text/XML/HXT/Parser/MainFunctions.hs b/src/Text/XML/HXT/Parser/MainFunctions.hs --- a/src/Text/XML/HXT/Parser/MainFunctions.hs +++ b/src/Text/XML/HXT/Parser/MainFunctions.hs @@ -25,7 +25,7 @@ import Text.XML.HXT.DOM.EditFilters import Text.XML.HXT.DOM.Namespace -import System.IO +-- import System.IO -- ------------------------------------------------------------ diff --git a/src/Text/XML/HXT/Parser/ProtocolHandlerFile.hs b/src/Text/XML/HXT/Parser/ProtocolHandlerFile.hs --- a/src/Text/XML/HXT/Parser/ProtocolHandlerFile.hs +++ b/src/Text/XML/HXT/Parser/ProtocolHandlerFile.hs @@ -42,7 +42,7 @@ perm <- io $ getPermissions source if readable perm then do - h <- io $ try ( openFile source ReadMode ) + h <- io $ try ( openBinaryFile source ReadMode ) case h of Left e -> readErr ( "system error when reading file " diff --git a/src/Text/XML/HXT/Parser/ProtocolHandlerHttpCurl.hs b/src/Text/XML/HXT/Parser/ProtocolHandlerHttpCurl.hs --- a/src/Text/XML/HXT/Parser/ProtocolHandlerHttpCurl.hs +++ b/src/Text/XML/HXT/Parser/ProtocolHandlerHttpCurl.hs @@ -132,7 +132,7 @@ crlf :: Parser () crlf = do - ( Text.ParserCombinators.Parsec.try (string "\r\n") <|> string "\n" ) + _ <- ( Text.ParserCombinators.Parsec.try (string "\r\n") <|> string "\n" ) return () parseResp :: Parser (Int, XmlTrees) @@ -141,7 +141,7 @@ vers <- ( do http <- string "HTTP/" mav <- many1 digit - char '.' + _ <- char '.' miv <- many1 digit return (http ++ mav ++ "." ++ miv) ) diff --git a/src/Text/XML/HXT/Parser/ProtocolHandlerHttpNative.hs b/src/Text/XML/HXT/Parser/ProtocolHandlerHttpNative.hs --- a/src/Text/XML/HXT/Parser/ProtocolHandlerHttpNative.hs +++ b/src/Text/XML/HXT/Parser/ProtocolHandlerHttpNative.hs @@ -43,8 +43,6 @@ -- -- the native http protocol handler -type ResponseString = Response String - -- ------------------------------------------------------------ -- -- the http protocol handler, haskell implementation @@ -84,7 +82,7 @@ where readErr msg = addFatal msg n - getHttp :: Int -> URI -> String -> IO ResponseString + getHttp :: Int -> URI -> String -> IO (Response String) getHttp trc' uri' proxy' = withSocketsDo $ browse ( do @@ -111,7 +109,7 @@ convertResponseStatus (a, b, c) = 100 * a + 10 * b + c - convertResponseHeaders :: ResponseString -> XmlTrees + convertResponseHeaders :: Response String -> XmlTrees convertResponseHeaders r' = cvResponseCode (rspCode r') ++ diff --git a/src/Text/XML/HXT/Parser/XmlOutput.hs b/src/Text/XML/HXT/Parser/XmlOutput.hs --- a/src/Text/XML/HXT/Parser/XmlOutput.hs +++ b/src/Text/XML/HXT/Parser/XmlOutput.hs @@ -74,7 +74,7 @@ putXmlDocToFile :: String -> XmlStateFilter a putXmlDocToFile fn t = do - res <- io $ try (openFile fn WriteMode) + res <- io $ try (openBinaryFile fn WriteMode) case res of Left ioerr -> ( issueFatal (show ioerr) @@ -84,7 +84,7 @@ Right h -> do t' <- hPutXmlDoc h t - io $ try (hClose h) + _ <- io $ try (hClose h) trace 2 ("document written to file: " ++ fn) return t' diff --git a/src/Text/XML/HXT/ProtocolHandler/Makefile b/src/Text/XML/HXT/ProtocolHandler/Makefile deleted file mode 100644 --- a/src/Text/XML/HXT/ProtocolHandler/Makefile +++ /dev/null @@ -1,45 +0,0 @@ -# $Id: Makefile,v 1.1 2004/09/02 19:12:02 hxml Exp $ -# -# Makefile to configure the http handlers to be used -# -# default is: http access may be done via a native http module -# or via an external program curl called via pipes -# the access can be controlled at runtime by option --withCurl -# -# variants: -# -# 1. ONLY_NATIVE_HTTP: does not need the code for calling external programs via pipes -# activate this variant by running "make only_native_http" in this dir before compilation -# -# 2. ONLY_CURL_HTTP: does not need the code for a socked connection and other stuff used by http modules -# activate this variant by running "make only_curl_http" in this dir before compilation -# -# 3. NO_HTTP: does not need any code for http, only local file access is supported -# activate this variant by running "make no_http" in this dir before compilation -# -# reset to default (both variants compiled in and selected by runtime options) by -# running "make default_http" - -source = ProtocolHandler.hs -tmp = ProtocolHandler.tmp -target = ../Parser/ProtocolHandler.hs - -all : - @echo "make a target out of \"only_native_http only_curl_http no_http default_http\"" - -only_native_http : - ghc -E -cpp -DONLY_NATIVE_HTTP=1 -o $(tmp) $(source) ; grep -v '^#' $(tmp) > $(target) - -only_curl_http : - ghc -E -cpp -DONLY_CURL_HTTP=1 -o $(tmp) $(source) ; grep -v '^#' $(tmp) > $(target) - -no_http : - ghc -E -cpp -DNO_HTTP=1 -o $(tmp) $(source) ; grep -v '^#' $(tmp) > $(target) - -default_http : - ghc -E -cpp -o $(tmp) $(source) ; grep -v '^#' $(tmp) > $(target) - -clean : - rm -f $(tmp) - -.PHONY : all only_native_http only_curl_http no_http default_http clean diff --git a/src/Text/XML/HXT/ProtocolHandler/ProtocolHandler.hs b/src/Text/XML/HXT/ProtocolHandler/ProtocolHandler.hs deleted file mode 100644 --- a/src/Text/XML/HXT/ProtocolHandler/ProtocolHandler.hs +++ /dev/null @@ -1,113 +0,0 @@ --- ------------------------------------------------------------ --- --- protocol handler functions --- configuration file --- real handler is generated with cpp - -module Text.XML.HXT.Parser.ProtocolHandler - ( getProtocolHandler - ) - -where - -import Text.XML.HXT.DOM.XmlState - --- ------------------------------------------------------------ --- --- file io and network - -import Data.Maybe - ( fromMaybe - ) - -import Network.URI - ( URI - , uriScheme - ) - -import Text.XML.HXT.Parser.ProtocolHandlerFile - ( getFileContents - ) - -#ifdef ONLY_NATIVE_HTTP - -import Text.XML.HXT.Parser.ProtocolHandlerHttpNative - ( getHttpContentsWithHttp - ) - -#else -#ifdef ONLY_CURL_HTTP - -import Text.XML.HXT.Parser.ProtocolHandlerHttpCurl - ( getHttpContentsWithCurl - ) - -#else -#ifdef NO_HTTP -#else - -import Text.XML.HXT.Parser.ProtocolHandlerHttpNativeOrCurl - ( getHttpContentsNativeOrWithCurl - ) - -#endif -#endif -#endif - --- ------------------------------------------------------------ --- - -getProtocolHandler :: String -> (URI -> XmlStateFilter a) -getProtocolHandler proto - = fromMaybe getUnsupported handler - where - handler = lookup proto protocolHandler - --- --- the fall back protocol handler - -getUnsupported :: URI -> XmlStateFilter a -getUnsupported uri - = addFatal ( "unsupported protocol " - ++ show (uriScheme uri) - ++ " in URI: " - ++ show uri - ) - --- ------------------------------------------------------------ --- --- the table of potocol handlers --- looked up in getProtocolHandler - -protocolHandler :: [(String, URI -> XmlStateFilter a)] -protocolHandler - = [ ("file", getFileContents) - , ("http", - -#ifdef ONLY_NATIVE_HTTP - - getHttpContentsWithHttp - -#else -#ifdef ONLY_CURL_HTTP - - getHttpContentsWithCurl - -#else -#ifdef NO_HTTP - - getUnsupported - -#else - - getHttpContentsNativeOrWithCurl - -#endif -#endif -#endif - ) - ] - --- ------------------------------------------------------------ - - diff --git a/src/Text/XML/HXT/Validator/DocTransformation.hs b/src/Text/XML/HXT/Validator/DocTransformation.hs --- a/src/Text/XML/HXT/Validator/DocTransformation.hs +++ b/src/Text/XML/HXT/Validator/DocTransformation.hs @@ -37,10 +37,7 @@ import Text.XML.HXT.Validator.AttributeValueValidation -import Data.Maybe import Data.List - - -- | -- Lookup-table which maps element names to their transformation functions. The diff --git a/src/Text/XML/HXT/Validator/DocValidation.hs b/src/Text/XML/HXT/Validator/DocValidation.hs --- a/src/Text/XML/HXT/Validator/DocValidation.hs +++ b/src/Text/XML/HXT/Validator/DocValidation.hs @@ -29,8 +29,6 @@ import Text.XML.HXT.Validator.AttributeValueValidation import Text.XML.HXT.Validator.XmlRE -import Data.Maybe - -- | -- Lookup-table which maps element names to their validation functions. The -- validation functions are XmlFilters. diff --git a/src/Text/XML/HXT/Validator/Validation.hs b/src/Text/XML/HXT/Validator/Validation.hs --- a/src/Text/XML/HXT/Validator/Validation.hs +++ b/src/Text/XML/HXT/Validator/Validation.hs @@ -48,8 +48,8 @@ ) where runValidation t - = do - issueError $$< res + = ( issueError $$< res ) + >> ( if null errs then ( traceMsg 1 "transforming validated document" .>> diff --git a/src/hxt-filter-package.hs b/src/hxt-filter-package.hs deleted file mode 100644 --- a/src/hxt-filter-package.hs +++ /dev/null @@ -1,114 +0,0 @@ -module Main -where - -import Data.List -import System.Environment - -part1 :: [String] -part1 - = [ "-- arch-tag: Haskell XML Toolbox main description file" - , "name: hxt-filter" - ] - -version :: String -version - = "version: " - -part2 :: [String] -part2 - = [ "license: OtherLicense" - , "license-file: LICENCE" - , "maintainer: Uwe Schmidt " - , "stability: stable" - , "category: XML" - , "synopsis: A collection of tools for processing XML with Haskell (Filter variant). " - , "description: The Haskell XML Toolbox bases on the ideas of HaXml and HXML." ++ - " This package is a compatibitlity package for old software working with the filter approach like in HaXml." ++ - " For new projects it's recomended to use the arrow based library (hxt)." - , "homepage: http://www.fh-wedel.de/~si/HXmlToolbox/index.html" - , "copyright: Copyright (c) 2005-2009 Uwe Schmidt" - ] - -part3a :: [String] -part3a - = [ "tested-with: ghc-6.10" - , "exposed: True" - , "exposed-modules:" - ] - -part3b :: [String] -part3b - = [ "build-type: Simple" - , "cabal-version: >=1.6" - , "" - , "library" - , " exposed-modules:" - ] - -part4a :: String -> [String] -part4a dir - = [ "hs-source-dirs: ." - , "ghc-options: -Wall -O2 -fglasgow-exts" - , "import-dirs: " ++ dir ++ "/imports" - , "library-dirs: " ++ dir - , "hs-libraries: HShxt-filter" - , "depends: base-4.0.0.0," - , " haskell98-1.0.1.0," - , " HUnit-1.2.0.3," - , " HTTP-3001.1.4," - , " parsec-2.1.0.1," - , " network-2.2.0.1," - , " containers-0.2.0.0," - , " directory-1.0.0.2," - , " process-1.0.1.0," - , " hxt-8.3.0" - ] - -part4b :: [String] -part4b - = [ " hs-source-dirs: src" - , " ghc-options: -Wall" - , " extensions: MultiParamTypeClasses DeriveDataTypeable FunctionalDependencies FlexibleInstances" - , "" - , " build-depends: base >= 4," - , " haskell98 >= 1," - , " containers >= 0.1," - , " directory >= 1," - , " filepath >= 1," - , " parsec >= 2.1 && < 3," - , " HUnit >= 1.2," - , " network >= 2.1," - , " HTTP >= 4000.0.4 && < 5000," - , " process >= 1.0.1," - , " hxt >= 8.3" - ] - -main :: IO() -main - = do - vers : cabal : installdir : modules <- getArgs - putStrLn (cabalFile vers cabal installdir modules) - -cabalFile :: String -> String -> String -> [String] -> String -cabalFile vers cabal installdir modules - = unlines $ - part1 ++ - [ version ++ vers ] ++ - part2 ++ - ( if isCabal - then part3b - else part3a - ) ++ - [ml modules] ++ - ( if isCabal - then part4b - else part4a installdir - ) - where - isCabal = cabal == "cabal" - ml = foldr1 (\ x y -> x ++ ",\n" ++ y) . sort . map editPath - editPath = (" " ++) . map slash2dot . reverse . drop 1 . dropWhile (/= '.') . reverse . removeLeadingDot - slash2dot '/' = '.' - slash2dot c = c - removeLeadingDot ('.':'/':path) = path - removeLeadingDot path = path