Next: , Previous: sxml simple, Up: Standard Library


8.5 (sxml ssax)

8.5.1 Overview

Functional XML parsing framework
SAX/DOM and SXML parsers with support for XML Namespaces and validation

This is a package of low-to-high level lexing and parsing procedures that can be combined to yield a SAX, a DOM, a validating parser, or a parser intended for a particular document type. The procedures in the package can be used separately to tokenize or parse various pieces of XML documents. The package supports XML Namespaces, internal and external parsed entities, user-controlled handling of whitespace, and validation. This module therefore is intended to be a framework, a set of "Lego blocks" you can use to build a parser following any discipline and performing validation to any degree. As an example of the parser construction, this file includes a semi-validating SXML parser.

The present XML framework has a "sequential" feel of SAX yet a "functional style" of DOM. Like a SAX parser, the framework scans the document only once and permits incremental processing. An application that handles document elements in order can run as efficiently as possible. Unlike a SAX parser, the framework does not require an application register stateful callbacks and surrender control to the parser. Rather, it is the application that can drive the framework – calling its functions to get the current lexical or syntax element. These functions do not maintain or mutate any state save the input port. Therefore, the framework permits parsing of XML in a pure functional style, with the input port being a monad (or a linear, read-once parameter).

Besides the port, there is another monad – seed. Most of the middle- and high-level parsers are single-threaded through the seed. The functions of this framework do not process or affect the seed in any way: they simply pass it around as an instance of an opaque datatype. User functions, on the other hand, can use the seed to maintain user's state, to accumulate parsing results, etc. A user can freely mix his own functions with those of the framework. On the other hand, the user may wish to instantiate a high-level parser: SSAX:make-elem-parser or SSAX:make-parser. In the latter case, the user must provide functions of specific signatures, which are called at predictable moments during the parsing: to handle character data, element data, or processing instructions (PI). The functions are always given the seed, among other parameters, and must return the new seed.

From a functional point of view, XML parsing is a combined pre-post-order traversal of a "tree" that is the XML document itself. This down-and-up traversal tells the user about an element when its start tag is encountered. The user is notified about the element once more, after all element's children have been handled. The process of XML parsing therefore is a fold over the raw XML document. Unlike a fold over trees defined in [1], the parser is necessarily single-threaded – obviously as elements in a text XML document are laid down sequentially. The parser therefore is a tree fold that has been transformed to accept an accumulating parameter [1,2].

Formally, the denotational semantics of the parser can be expressed as

      parser:: (Start-tag -> Seed -> Seed) ->
     	   (Start-tag -> Seed -> Seed -> Seed) ->
     	   (Char-Data -> Seed -> Seed) ->
     	   XML-text-fragment -> Seed -> Seed
      parser fdown fup fchar "<elem attrs> content </elem>" seed
       = fup "<elem attrs>" seed
     	(parser fdown fup fchar "content" (fdown "<elem attrs>" seed))
     
      parser fdown fup fchar "char-data content" seed
       = parser fdown fup fchar "content" (fchar "char-data" seed)
     
      parser fdown fup fchar "elem-content content" seed
       = parser fdown fup fchar "content" (
     	parser fdown fup fchar "elem-content" seed)

Compare the last two equations with the left fold

      fold-left kons elem:list seed = fold-left kons list (kons elem seed)

The real parser created by SSAX:make-parser is slightly more complicated, to account for processing instructions, entity references, namespaces, processing of document type declaration, etc.

The XML standard document referred to in this module ishttp://www.w3.org/TR/1998/REC-xml-19980210.html

The present file also defines a procedure that parses the text of an XML document or of a separate element into SXML, an S-expression-based model of an XML Information Set. SXML is also an Abstract Syntax Tree of an XML document. SXML is similar but not identical to DOM; SXML is particularly suitable for Scheme-based XML/HTML authoring, SXPath queries, and tree transformations. See SXML.html for more details. SXML is a term implementation of evaluation of the XML document [3]. The other implementation is context-passing.

The present frameworks fully supports the XML Namespaces Recommendation:http://www.w3.org/TR/REC-xml-names/ Other links:

[1]
Jeremy Gibbons, Geraint Jones, "The Under-appreciated Unfold," Proc. ICFP'98, 1998, pp. 273-279.
[2]
Richard S. Bird, The promotion and accumulation strategies in transformational programming, ACM Trans. Progr. Lang. Systems, 6(4):487-504, October 1984.
[3]
Ralf Hinze, "Deriving Backtracking Monad Transformers," Functional Pearl. Proc ICFP'00, pp. 186-197.

8.5.2 Usage

— Function: current-ssax-error-port

— Function: with-ssax-error-to-port port thunk

— Function: xml-token? _
      -- Scheme Procedure: pair? x
          Return `#t' if X is a pair; otherwise return `#f'.
     
      

— Special Form: xml-token-kind token

— Special Form: xml-token-head token

— Function: make-empty-attlist

— Function: attlist-add attlist name-value

— Function: attlist-null? _
      -- Scheme Procedure: null? x
          Return `#t' iff X is the empty list, else `#f'.
     
      

— Function: attlist-remove-top attlist

— Function: attlist->alist attlist

— Function: attlist-fold kons knil lis1

— Function: define-parsed-entity! entity str

Define a new parsed entity. entity should be a symbol.

Instances of &entity; in XML text will be replaced with the string str, which will then be parsed.

— Function: reset-parsed-entity-definitions!

Restore the set of parsed entity definitions to its initial state.

— Function: ssax:uri-string->symbol uri-str

— Function: ssax:skip-internal-dtd port

— Function: ssax:read-pi-body-as-string port

— Function: ssax:reverse-collect-str-drop-ws fragments

— Function: ssax:read-markup-token port

— Function: ssax:read-cdata-body port str-handler seed

— Function: ssax:read-char-ref port

— Function: ssax:read-attributes port entities

— Function: ssax:complete-start-tag tag-head port elems entities namespaces

— Function: ssax:read-external-id port

— Function: ssax:read-char-data port expect-eof? str-handler seed

— Function: ssax:xml->sxml port namespace-prefix-assig

— Special Form: ssax:make-parser . kw-val-pairs

— Special Form: ssax:make-pi-parser orig-handlers

— Special Form: ssax:make-elem-parser my-new-level-seed my-finish-element my-char-data-handler my-pi-handlers