HaXml - Haskell utilities for processing XML
        --------------------------------------------

Installation instructions:
We currently support nhc98, ghc, and Hugs.  The automatic configuration
detects which compilers/interpreters you have, and prepares a build
tree for each.  Installation requires write-permission on the system
directories of the compiler/interpreter - the libraries and interfaces
can then be used as "-package HaXml" (for ghc/nhc98 - no extra options
required for Hugs).  The standalone tools are installed to a directory of
your choice.

    ./configure
    make
    make install

Options to configure are:
    --buildwith=...  e.g. ghc-6.2,        to build for a specific compiler
    --prefix=...     e.g. /usr/local/bin, installation location for HaXml tools

Complaints to:  :-)
    Malcolm.Wallace@cs.york.ac.uk

P.S.
    For those building on Windows /without/ Cygwin, you can avoid the need
    for configure/make steps by simply running the minimal build script in
        Build.bat
    You will need to edit it for the location of your compiler etc.

----
What this package contains:

  docs/                 Some rudimentary HTML documentation about the libraries.
  docs/HaXml/           Haddock-generated API documentation.
  examples/             Some small examples of how the libraries/tools are used.

  src/Text/XML/HaXml/   Numerous support modules for processing XML.
                        (The main APIs are as follows:)
        Types.hs        Defines a (generic) representation for any XML document.
        Parse.hs        Parses an XML document into the generic representation.
        ParseLazy.hs    A more space-efficient parser.
        Pretty.hs       Pretty-prints an XML document.
        Validate.hs     Validates an XML document against a DTD.
        Combinators.hs  Provides the combinators described in the ICFP'99 paper
                        together with some other useful functions.
        SAX.hs          A simple SAX-like stream-event-parser.
        Wrappers.hs     Simple top-level wrappers for processing a single
                        document using the combinators.
        XmlContent.hs   A replacement class for Show/Read, to translate Haskell
                        values to/from XML documents.  Can be derived by DrIFT
                        and/or DtdToHaskell.
        TypeMapping.hs  Defines an explicit representation for Haskell types,
                        allowing generation of a DTD from a Haskell value.
        OneOfN.hs       Some support types (OneOf2 - OneOf20) for code
                        generated by tools/DtdToHaskell.

  src/Text/XML/HaXml/Html       Extra support modules for processing HTML.
        Parse.hs        An error-correcting HTML parser, produces the generic
                        XML representation.
        Pretty.hs       An HTML-specific pretty-printer.
        Generate.hs     Some useful combinators for generating HTML content.

  src/tools/            Standalone tools based on the library above.
        DtdToHaskell    Translates an XML doc containing a DTD into a Haskell
                        module containing data/newtype definitions.
        Xtract          A structured 'grep' for XML docs, loosely based on
                        the XPath and XQL query languages.
        Validate        A simple validation tool for XML docs.  Give it a DTD
                        file and an XML file, and it reports all validation
                        errors it can find.
        Canonicalise    A 'cat' filter for XML docs, shows our "standard"
                        parsing and pretty-printing behaviour.
        MkOneOf         Generates a OneOfN type, given an N, together with
                        its required instance of XmlContent.  Sometimes types
                        larger than OneOf20 are required in code generated by
                        DtdToHaskell.

  src/Text/XML/HaXml/Xtract     Internal APIs of the Xtract tool.
        Parse.hs        Parse an XPath query to produce a filter.
        Combinators.hs  Modified version of the standard combinators.

  src/Text/XML/HaXml/DtdToHaskell       Internal APIs of the DtdToHaskell tool.
        TypeDef.hs      A representation of the Haskell types corresponding
                        to an XML DTD, and a pretty printer for them.
        Convert.hs      Convert the standard DTD representation to the
                        Haskell-like TypeDef representation.
        Instance.hs     Generate appropriate XmlContent class instances for
                        the TypeDefs.

----