Text.XML.HaXml.ParseLazy

HaXml-1.25.4: Utilities for manipulating XML documents

Safe Haskell | None
Language | Haskell98

Text.XML.HaXml.ParseLazy

Contents

- Parse a whole document
- Parse just a DTD
- Parse a partial document
- Individual parsers for use with xmlParseWith and module SAX
- These general utility functions don't belong here

Description

A non-validating XML parser. For the input grammar, see http://www.w3.org/TR/REC-xml.

Synopsis

- xmlParse :: String -> String -> Document Posn
- dtdParse :: String -> String -> Maybe DocTypeDecl
- xmlParseWith :: XParser a -> [(Posn, TokenT)] -> (Either String a, [(Posn, TokenT)])
- document :: XParser (Document Posn)
- element :: XParser (Element Posn)
- content :: XParser (Content Posn)
- comment :: XParser Comment
- chardata :: XParser CharData
- reference :: XParser Reference
- doctypedecl :: XParser DocTypeDecl
- processinginstruction :: XParser ProcessingInstruction
- elemtag :: XParser ElemTag
- qname :: XParser QName
- name :: XParser Name
- tok :: TokenT -> XParser TokenT
- elemOpenTag :: XParser ElemTag
- elemCloseTag :: QName -> XParser ()
- emptySTs :: SymTabs
- type XParser a = Parser SymTabs (Posn, TokenT) a
- fst3 :: (a, b, c) -> a
- snd3 :: (a, b, c) -> b
- thd3 :: (a, b, c) -> c

# Parse a whole document

xmlParse :: String -> String -> Document Posn #

To parse a whole document, `xmlParse file content` takes a filename (for generating error reports) and the string content of that file. A parse error causes program failure, with message to stderr.

# Parse just a DTD

dtdParse :: String -> String -> Maybe DocTypeDecl #

To parse just a DTD, `dtdParse file content` takes a filename (for generating error reports) and the string content of that file. If no DTD was found, you get `Nothing` rather than an error. However, if a DTD is found but contains errors, the program crashes.

# Parse a partial document

xmlParseWith :: XParser a -> [(Posn, TokenT)] -> (Either String a, [(Posn, TokenT)]) #

To parse a partial document, e.g. from an XML-based stream protocol, where you may later want to get more document elements from the same stream. Arguments are: a parser for the item you want, and the already-lexed input to parse from. Returns the item you wanted (or an error message), plus the remainder of the input.

# Individual parsers for use with xmlParseWith and module SAX

document :: XParser (Document Posn) #

Return an entire XML document including prolog and trailing junk.

element :: XParser (Element Posn) #

Return a complete element including all its inner content.

content :: XParser (Content Posn) #

Return a content particle, e.g. text, element, reference, etc

comment :: XParser Comment #

Return an XML comment.

chardata :: XParser CharData #

Return parsed freetext (i.e. until the next markup)

reference :: XParser Reference #

Return either a general entity reference, or a character reference.

doctypedecl :: XParser DocTypeDecl #

Return a DOCTYPE decl, indicating a DTD.

processinginstruction :: XParser ProcessingInstruction #

Parse a processing instruction.

elemtag :: XParser ElemTag #

Parse only the parts between angle brackets in an element tag.

qname :: XParser QName #

Return a qualified name (although the namespace qualification is not processed here; this is merely to get the correct type).

name :: XParser Name #

Return just a name, e.g. element name, attribute name.

tok :: TokenT -> XParser TokenT #

Return the next token from the input only if it matches the given token.

elemOpenTag :: XParser ElemTag #

For use with stream parsers - returns the complete opening element tag.

elemCloseTag :: QName -> XParser () #

For use with stream parsers - accepts a closing tag, provided it matches the given element name.

emptySTs :: SymTabs #

Some empty symbol tables for GE and PE references.

type XParser a = Parser SymTabs (Posn, TokenT) a #

XParser is just a specialisation of the PolyStateLazy parser.

# These general utility functions don't belong here

fst3 :: (a, b, c) -> a #

snd3 :: (a, b, c) -> b #

thd3 :: (a, b, c) -> c #