From dlichteblau at common-lisp.net  Sun Feb 11 12:09:33 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 11 Feb 2007 07:09:33 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/pull
Message-ID: <20070211120933.C4CD253069@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/pull
In directory clnet:/tmp/cvs-serv5263/pull

Log Message:
Directory /project/cxml/cvsroot/cxml/pull added to the repository





From dlichteblau at common-lisp.net  Sun Feb 11 12:54:28 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 11 Feb 2007 07:54:28 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/klacks
Message-ID: <20070211125428.3C4B32B11D@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/klacks
In directory clnet:/tmp/cvs-serv10428/klacks

Log Message:
Directory /project/cxml/cvsroot/cxml/klacks added to the repository





From dlichteblau at common-lisp.net  Sun Feb 11 18:21:20 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 11 Feb 2007 13:21:20 -0500 (EST)
Subject: [cxml-cvs] CVS cxml
Message-ID: <20070211182120.A34C475093@common-lisp.net>

Update of /project/cxml/cvsroot/cxml
In directory clnet:/tmp/cvs-serv26091

Modified Files:
	cxml.asd 
Log Message:
klacks parser


--- /project/cxml/cvsroot/cxml/cxml.asd	2006/09/13 15:58:36	1.13
+++ /project/cxml/cvsroot/cxml/cxml.asd	2007/02/11 18:21:20	1.14
@@ -109,6 +109,18 @@
      (:file "dom-sax"         :depends-on ("package")))
     :depends-on (:cxml-xml))
 
+(asdf:defsystem :cxml-klacks
+    :default-component-class closure-source-file
+    :pathname (merge-pathnames
+               "klacks/"
+               (make-pathname :name nil :type nil :defaults *load-truename*))
+    :serial t
+    :components
+    ((:file "package")
+     (:file "klacks")
+     (:file "klacks-impl"))
+    :depends-on (:cxml-xml))
+
 (asdf:defsystem :cxml-test
     :default-component-class closure-source-file
     :pathname (merge-pathnames
@@ -117,4 +129,6 @@
     :components ((:file "domtest") (:file "xmlconf"))
     :depends-on (:cxml-xml :cxml-dom))
 
-(asdf:defsystem :cxml :components () :depends-on (:cxml-dom :cxml-test))
+(asdf:defsystem :cxml
+    :components ()
+    :depends-on (:cxml-dom :cxml-klacks :cxml-test))



From dlichteblau at common-lisp.net  Sun Feb 11 18:21:20 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 11 Feb 2007 13:21:20 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/dom
Message-ID: <20070211182120.E104C100B@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/dom
In directory clnet:/tmp/cvs-serv26091/dom

Modified Files:
	dom-builder.lisp 
Log Message:
klacks parser


--- /project/cxml/cvsroot/cxml/dom/dom-builder.lisp	2005/12/27 01:35:14	1.10
+++ /project/cxml/cvsroot/cxml/dom/dom-builder.lisp	2007/02/11 18:21:20	1.11
@@ -38,7 +38,9 @@
     (push document (element-stack handler))))
 
 (defmethod sax:end-document ((handler dom-builder))
-  (setf (slot-value (document handler) 'dtd) (cxml::dtd cxml::*ctx*))
+  (setf (slot-value (document handler) 'dtd)
+	;; FIXME!
+	(and cxml::*ctx* (cxml::dtd cxml::*ctx*)))
   (let ((doctype (dom:doctype (document handler))))
     (when doctype
       (setf (slot-value (dom:entities doctype) 'read-only-p) t)



From dlichteblau at common-lisp.net  Sun Feb 11 18:21:21 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 11 Feb 2007 13:21:21 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/klacks
Message-ID: <20070211182121.B1000120A0@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/klacks
In directory clnet:/tmp/cvs-serv26091/klacks

Added Files:
	klacks-impl.lisp klacks.lisp package.lisp 
Log Message:
klacks parser



--- /project/cxml/cvsroot/cxml/klacks/klacks-impl.lisp	2007/02/11 18:21:21	NONE
+++ /project/cxml/cvsroot/cxml/klacks/klacks-impl.lisp	2007/02/11 18:21:21	1.1
;;; -*- Mode: Lisp; readtable: runes; -*-
;;;  (c) copyright 2007 David Lichteblau

;;; This library is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU Library General Public
;;; License as published by the Free Software Foundation; either
;;; version 2 of the License, or (at your option) any later version.
;;;
;;; This library is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;;; Library General Public License for more details.
;;;
;;; You should have received a copy of the GNU Library General Public
;;; License along with this library; if not, write to the
;;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;;; Boston, MA  02111-1307  USA.

(in-package :cxml)

(defclass cxml-source (klacks:source)
    (;; args to make-source
     (context :initarg :context)
     (validate :initarg :validate)
     (root :initarg :root)
     (dtd :initarg :dtd)
     (error-culprit :initarg :error-culprit)
     ;; current state
     (continuation)
     (current-key :initform nil)
     (current-values)
     (current-attributes)
     (cdata-section-p :reader klacks:current-cdata-section-p)
     ;; extra with-source magic
     (data-behaviour :initform :DTD)
     (namespace-stack :initform (list *initial-namespace-bindings*))
     (temporary-streams :initform nil)
     (scratch-pad :initarg :scratch-pad)
     (scratch-pad-2 :initarg :scratch-pad-2)
     (scratch-pad-3 :initarg :scratch-pad-3)
     (scratch-pad-4 :initarg :scratch-pad-4)))

(defmethod klacks:close-source ((source cxml-source))
  (dolist (xstream (slot-value source 'temporary-streams))
    ;; fixme: error handling?
    (close-xstream xstream)))

(defmacro with-source ((source &rest slots) &body body)
  (let ((s (gensym)))
    `(let* ((,s ,source)
	    (*ctx* (slot-value ,s 'context))
	    (*validate* (slot-value ,s 'validate))
	    (*data-behaviour* (slot-value source 'data-behaviour))
	    (*namespace-bindings* (car (slot-value source 'namespace-stack)))
	    (*scratch-pad* (slot-value source 'scratch-pad))
	    (*scratch-pad-2* (slot-value source 'scratch-pad-2))
	    (*scratch-pad-3* (slot-value source 'scratch-pad-3))
	    (*scratch-pad-4* (slot-value source 'scratch-pad-4)))
       (handler-case
	   (with-slots (, at slots) ,s
	     , at body)
	 (runes-encoding:encoding-error (c)
	   (wf-error (slot-value ,s 'error-culprit) "~A" c))))))

(defun fill-source (source)
  (with-slots (current-key current-values continuation) source
    (unless current-key
      (setf current-key :bogus)
      (setf continuation (funcall continuation))
      (assert (not (eq current-key :bogus))))))

(defmethod klacks:peek ((source cxml-source))
  (with-source (source current-key current-values)
    (fill-source source)
    (apply #'values current-key current-values)))

(defmethod klacks:peek-value ((source cxml-source))
  (with-source (source current-key current-values)
    (fill-source source)
    (apply #'values current-values)))

(defmethod klacks:consume ((source cxml-source))
  (with-source (source current-key current-values)
    (fill-source source)
    (multiple-value-prog1
	(apply #'values current-key current-values)
      (setf current-key nil))))

(defmethod klacks:map-attributes (fn (source cxml-source))
  (dolist (a (slot-value source 'current-attributes))
    (funcall fn
	     (sax:attribute-namespace-uri a)
	     (sax:attribute-local-name a)
	     (sax:attribute-qname a)
	     (sax:attribute-value a)
	     (sax:attribute-specified-p a))))

(defmethod klacks:list-attributes ((source cxml-source))
  (slot-value source 'current-attributes))

(defun make-source
    (input &rest args
     &key validate dtd root entity-resolver disallow-internal-subset
	  pathname)
  (declare (ignore validate dtd root entity-resolver disallow-internal-subset))
  (etypecase input
    (xstream
      (let ((*ctx* nil))
	(let ((zstream (make-zstream :input-stack (list input))))
	  (peek-rune input)
	  (with-scratch-pads ()
	    (apply #'%make-source
		   zstream
		   (loop
		       for (name value) on args by #'cddr
		       unless (eq name :pathname)
		       append (list name value)))))))
    (stream
      (let ((xstream (make-xstream input)))
	(setf (xstream-name xstream)
	      (make-stream-name
	       :entity-name "main document"
	       :entity-kind :main
	       :uri (pathname-to-uri
		     (merge-pathnames (or pathname (pathname input))))))
	(apply #'make-source xstream args)))
    (pathname
      (let* ((xstream
	      (make-xstream (open input :element-type '(unsigned-byte 8))))
	     (source (apply #'make-source
			    xstream
			    :pathname input
			    args)))
	(push xstream (slot-value source 'temporary-streams))
	source))
    (rod
      (let ((xstream (string->xstream input)))
	(setf (xstream-name xstream)
	      (make-stream-name
	       :entity-name "main document"
	       :entity-kind :main
	       :uri nil))
	(apply #'make-source xstream args)))))

(defun %make-source
    (input &key validate dtd root entity-resolver disallow-internal-subset
		error-culprit)
  ;; check types of user-supplied arguments for better error messages:
  (check-type validate boolean)
  (check-type dtd (or null extid))
  (check-type root (or null rod))
  (check-type entity-resolver (or null function symbol))
  (check-type disallow-internal-subset boolean)
  (let* ((context
	  (make-context :handler nil
			:main-zstream input
			:entity-resolver entity-resolver
			:disallow-internal-subset disallow-internal-subset))
	 (source
	  (make-instance 'cxml-source
	    :context context
	    :validate validate
	    :dtd dtd
	    :root root
	    :error-culprit error-culprit
	    :scratch-pad *scratch-pad*
	    :scratch-pad-2 *scratch-pad-2*
	    :scratch-pad-3 *scratch-pad-3*
	    :scratch-pad-4 *scratch-pad-4*)))
    (setf (slot-value source 'continuation)
	  (lambda () (klacks/xmldecl source input)))
    source))

(defun klacks/xmldecl (source input)
  (with-source (source current-key current-values)
    (let ((hd (p/xmldecl input)))
      (setf current-key :start-document)
      (setf current-values
	    (when hd
	      (list (xml-header-version hd)
		    (xml-header-encoding hd)
		    (xml-header-standalone-p hd))))
      (lambda ()
	(klacks/misc*-2 source input
			(lambda ()
			  (klacks/doctype source input)))))))

(defun klacks/misc*-2 (source input successor)
  (with-source (source current-key current-values)
    (multiple-value-bind (cat sem) (peek-token input)
      (case cat
	(:COMMENT
	  (setf current-key :comment)
	  (setf current-values (list sem))
	  (consume-token input)
	  (lambda () (klacks/misc*-2 source input successor)))
	(:PI
	  (setf current-key :processing-instruction)
	  (setf current-values (list (car sem) (cdr sem)))
	  (consume-token input)
	  (lambda () (klacks/misc*-2 source input successor)))
	(:S
	  (consume-token input)
	  (klacks/misc*-2 source input successor))
	(t
	  (funcall successor))))))

(defun klacks/doctype (source input)
  (with-source (source current-key current-values validate dtd)
    (let ((cont (lambda () (klacks/finish-doctype source input)))
	  ignoreme name extid)
      (prog1
	  (cond
	    ((eq (peek-token input) :<!DOCTYPE)
	      (setf (values ignoreme name extid)
		    (p/doctype-decl input dtd))
	      (lambda () (klacks/misc*-2 source input cont)))
	    (dtd
	      (setf (values ignoreme name extid)
		    (synthesize-doctype dtd input))
	      cont)
	    ((and validate (not dtd))
	      (validity-error "invalid document: no doctype"))
	    (t
	      (return-from klacks/doctype
		(funcall cont))))
	(setf current-key :dtd)
	(setf current-values
	      (list name (extid-public extid) (extid-system extid)))))))

(defun klacks/finish-doctype (source input)
  (with-source (source current-key current-values root data-behaviour)
    (ensure-dtd)
    (when root
      (setf (model-stack *ctx*) (list (make-root-model root))))
    (setf data-behaviour :DOC)
    (setf *data-behaviour* :DOC)
    (fix-seen-< input)
    (let* ((final
	    (lambda ()
	      (klacks/eof source input)))
	   (next
	    (lambda ()
	      (setf data-behaviour :DTD)
	      (setf *data-behaviour* :DTD)
	      (klacks/misc*-2 source input final))))
      (klacks/element source input next))))

(defun klacks/eof (source input)
  (with-source (source current-key current-values)
    (p/eof input)
    (setf current-key :end-document)
    (setf current-values nil)
    (lambda () (klacks/nil source))))

(defun klacks/nil (source)
  (with-source (source current-key current-values)
    (setf current-key nil)
    (setf current-values nil)
    (labels ((klacks/done () #'klacks/done))
      #'klacks/done)))

(defun klacks/element (source input cont)
  (with-source (source current-key current-values current-attributes)
    (multiple-value-bind (cat n-b new-b uri lname qname attrs) (p/sztag input)
      (declare (ignore new-b))
      (setf current-key :start-element)
      (setf current-values (list uri lname qname))
      (setf current-attributes attrs)
      (if (eq cat :stag)
	  (lambda ()
	    (klacks/element-2 source input n-b cont))
	  (lambda ()
	    (klacks/ztag source cont))))))

(defun klacks/ztag (source cont)
  (with-source (source current-key current-values current-attributes)
    (setf current-key :end-element)
    (setf current-attributes nil)
    ;; fixme: (undeclare-namespaces new-b)
    (validate-end-element *ctx* (third current-values))
    cont))

(defun klacks/element-2 (source input n-b cont)
  (with-source (source
		current-key current-values current-attributes namespace-stack)
    (let ((values* current-values))
      (setf current-attributes nil)
      (push n-b namespace-stack)
      (let ((finish
	     (lambda ()
	       (pop namespace-stack)
	       (klacks/element-3 source input values* cont))))
	(klacks/content source input finish)))))

(defun klacks/element-3 (source input tag-values cont)
  (with-source (source current-key current-values current-attributes)
    (setf current-key :end-element)
    (setf current-values tag-values)
    (let ((qname (third tag-values)))
      (p/etag input qname)
      ;; fixme: (undeclare-namespaces new-b)
      (validate-end-element *ctx* qname))
    cont))

(defun klacks/content (source input cont)
  (with-source (source current-key current-values cdata-section-p)
    (let ((recurse (lambda () (klacks/content source input cont))))
      (multiple-value-bind (cat sem) (peek-token input)
	(case cat
	  ((:stag :ztag)
	    (klacks/element source input recurse))
	  ((:CDATA)
	    (process-characters input sem)
	    (setf current-key :characters)
	    (setf current-values (list sem))
	    (setf cdata-section-p nil)
	    recurse)
	  ((:ENTITY-REF)
	    (let ((name sem))
	      (consume-token input)
	      (klacks/entity-reference source input name recurse)))
	  ((:<!\[)
	    (setf current-key :characters)
	    (setf current-values (list (process-cdata-section input sem)))
	    (setf cdata-section-p t)
	    recurse)
	  ((:PI)
	    (setf current-key :processing-instruction)
	    (setf current-values (list (car sem) (cdr sem)))
	    (consume-token input)
	    recurse)
	  ((:COMMENT)
	    (setf current-key :comment)
	    (setf current-values (list sem))
	    (consume-token input)
	    recurse)
	  (otherwise
	    (funcall cont)))))))

(defun klacks/entity-reference (source zstream name cont)
  (assert (not (zstream-token-category zstream)))
  (with-source (source temporary-streams)
    (let ((new-xstream (entity->xstream zstream name :general nil)))
      (push new-xstream temporary-streams)
      (push :stop (zstream-input-stack zstream))
      (zstream-push new-xstream zstream)
      (let ((next
	     (lambda ()
	       (klacks/entity-reference-2 source zstream new-xstream cont))))
	(etypecase (checked-get-entdef name :general)
	  (internal-entdef
	    (klacks/content source zstream next))
	  (external-entdef
	    (klacks/ext-parsed-ent source zstream next)))))))

(defun klacks/entity-reference-2 (source zstream new-xstream cont)
  (with-source (source temporary-streams)
    (unless (eq (peek-token zstream) :eof)
      (wf-error zstream "Trailing garbage. - ~S" (peek-token zstream)))
    (assert (eq (peek-token zstream) :eof))
    (assert (eq (pop (zstream-input-stack zstream)) new-xstream))
    (assert (eq (pop (zstream-input-stack zstream)) :stop))
    (setf (zstream-token-category zstream) nil)
    (setf temporary-streams (remove new-xstream temporary-streams))
    (close-xstream new-xstream)
    (funcall cont)))

(defun klacks/ext-parsed-ent (source input cont)
  (with-source (source)
    (when (eq (peek-token input) :xml-decl)
      (let ((hd (parse-text-decl (cdr (nth-value 1 (peek-token input))))))
	(setup-encoding input hd))
      (consume-token input))
    (set-full-speed input)
    (klacks/content source input cont)))

#+(or)
(trace CXML::KLACKS/DOCTYPE 
       CXML::KLACKS/EXT-PARSED-ENT 
       CXML::KLACKS/MISC*-2 
       CXML::KLACKS/ENTITY-REFERENCE 
       CXML::KLACKS/ENTITY-REFERENCE-2 
       CXML::KLACKS/ELEMENT 
       CXML::KLACKS/ZTAG 
       CXML::KLACKS/XMLDECL 
       CXML::KLACKS/FINISH-DOCTYPE 
       CXML::KLACKS/ELEMENT-3 
       CXML::KLACKS/EOF 
       CXML::KLACKS/ELEMENT-2 
       CXML::KLACKS/CONTENT )
--- /project/cxml/cvsroot/cxml/klacks/klacks.lisp	2007/02/11 18:21:21	NONE
+++ /project/cxml/cvsroot/cxml/klacks/klacks.lisp	2007/02/11 18:21:21	1.1
;;; -*- Mode: Lisp; readtable: runes; -*-
;;;  (c) copyright 2007 David Lichteblau

;;; This library is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU Library General Public
;;; License as published by the Free Software Foundation; either
;;; version 2 of the License, or (at your option) any later version.
;;;
;;; This library is distributed in the hope that it will be useful,

[86 lines skipped]
--- /project/cxml/cvsroot/cxml/klacks/package.lisp	2007/02/11 18:21:21	NONE
+++ /project/cxml/cvsroot/cxml/klacks/package.lisp	2007/02/11 18:21:21	1.1

[124 lines skipped]


From dlichteblau at common-lisp.net  Sun Feb 11 18:21:22 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 11 Feb 2007 13:21:22 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/xml
Message-ID: <20070211182122.CCE3E1A007@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/xml
In directory clnet:/tmp/cvs-serv26091/xml

Modified Files:
	package.lisp xml-parse.lisp 
Log Message:
klacks parser


--- /project/cxml/cvsroot/cxml/xml/package.lisp	2006/12/02 13:21:37	1.13
+++ /project/cxml/cvsroot/cxml/xml/package.lisp	2007/02/11 18:21:21	1.14
@@ -83,4 +83,6 @@
    #:make-namespace-normalizer
    #:make-whitespace-normalizer
    #:rod-to-utf8-string
-   #:utf8-string-to-rod))
+   #:utf8-string-to-rod
+
+   #:make-source))
--- /project/cxml/cvsroot/cxml/xml/xml-parse.lisp	2006/09/16 07:52:59	1.64
+++ /project/cxml/cvsroot/cxml/xml/xml-parse.lisp	2007/02/11 18:21:22	1.65
@@ -68,11 +68,11 @@
 ;;    :stag (<name> . <atts>)           ;start tag
 ;;    :etag (<name> . <atts>)           ;end tag
 ;;    :ztag (<name> . <atts>)           ;empty tag
-;;    :<!element
-;;    :<!entity
-;;    :<!attlist
-;;    :<!notation
-;;    :<!doctype
+;;    :<!ELEMENT
+;;    :<!ENTITY
+;;    :<!ATTLIST
+;;    :<!NOTATION
+;;    :<!DOCTYPE
 ;;    :<![
 ;;    :comment <content>
 
@@ -194,11 +194,13 @@
 
 (defvar *expand-pe-p* nil)
 
-(defparameter *namespace-bindings*
+(defparameter *initial-namespace-bindings*
   '((#"" . nil)
     (#"xmlns" . #"http://www.w3.org/2000/xmlns/")
     (#"xml" . #"http://www.w3.org/XML/1998/namespace")))
 
+(defparameter *namespace-bindings* *initial-namespace-bindings*)
+
 ;;;; ---------------------------------------------------------------------------
 ;;;; xstreams
 ;;;;
@@ -2571,22 +2573,16 @@
 		       :main-zstream input
                        :entity-resolver entity-resolver
                        :disallow-internal-subset disallow-internal-subset))
-        (*validate* validate))
+        (*validate* validate)
+	(*namespace-bindings* *initial-namespace-bindings*))
     (sax:start-document handler)
     ;; document ::= XMLDecl? Misc* (doctypedecl Misc*)? element Misc*
     ;; Misc ::= Comment | PI |  S
     ;; xmldecl::='<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
     ;; sddecl::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"'))
-    ;;
-    ;; we will use the attribute-value parser for the xml decl.
     (let ((*data-behaviour* :DTD))
       ;; optional XMLDecl?
-      (cond ((eq (peek-token input) :xml-decl)
-             (let ((hd (parse-xml-decl (cdr (nth-value 1 (peek-token input))))))
-               (setf (standalone-p *ctx*) (eq (xml-header-standalone-p hd) :yes))
-               (setup-encoding input hd))
-             (read-token input)))
-      (set-full-speed input)
+      (p/xmldecl input)
       ;; Misc*
       (p/misc*-2 input)
       ;; (doctypedecl Misc*)?
@@ -2595,13 +2591,7 @@
           (p/doctype-decl input dtd)
           (p/misc*-2 input))
         (dtd
-          (let ((dummy (string->xstream "<!DOCTYPE dummy>")))
-            (setf (xstream-name dummy)
-                  (make-stream-name
-                   :entity-name "dummy doctype"
-                   :entity-kind :main
-                   :uri (zstream-base-sysid input)))
-            (p/doctype-decl (make-zstream :input-stack (list dummy)) dtd)))
+	  (synthesize-doctype dtd input))
         ((and validate (not dtd))
           (validity-error "invalid document: no doctype")))
       (ensure-dtd)
@@ -2610,28 +2600,65 @@
         (setf (model-stack *ctx*) (list (make-root-model root))))
       ;; element
       (let ((*data-behaviour* :DOC))
-	(when (eq (peek-token input) :seen-<)
-	  (multiple-value-bind (c s)
-	      (read-token-after-|<| input (car (zstream-input-stack input)))
-	    (setf (zstream-token-category input) c
-		  (zstream-token-semantic input) s)))
+	(fix-seen-< input)
         (p/element input))
       ;; optional Misc*
       (p/misc*-2 input)
-      (unless (eq (peek-token input) :eof)
-        (wf-error input "Garbage at end of document."))
-      (when *validate*
-        (maphash (lambda (k v)
-                   (unless v
-                     (validity-error "(11) IDREF: ~S not defined" (rod-string k))))
-                 (id-table *ctx*))
-
-        (dolist (name (referenced-notations *ctx*))
-          (unless (find-notation name (dtd *ctx*))
-            (validity-error "(23) Notation Declared: ~S" (rod-string name)))))
+      (p/eof input)
       (sax:end-document handler))))
 
+(defun synthesize-doctype (dtd input)
+  (let ((dummy (string->xstream "<!DOCTYPE dummy>")))
+    (setf (xstream-name dummy)
+	  (make-stream-name
+	   :entity-name "dummy doctype"
+	   :entity-kind :main
+	   :uri (zstream-base-sysid input)))
+    (p/doctype-decl (make-zstream :input-stack (list dummy)) dtd)))
+
+(defun fix-seen-< (input)
+  (when (eq (peek-token input) :seen-<)
+    (multiple-value-bind (c s)
+	(read-token-after-|<| input (car (zstream-input-stack input)))
+      (setf (zstream-token-category input) c
+	    (zstream-token-semantic input) s))))
+
+(defun p/xmldecl (input)
+  ;; we will use the attribute-value parser for the xml decl.
+  (prog1
+      (when (eq (peek-token input) :xml-decl)
+	(let ((hd (parse-xml-decl (cdr (nth-value 1 (peek-token input))))))
+	  (setf (standalone-p *ctx*) (eq (xml-header-standalone-p hd) :yes))
+	  (setup-encoding input hd)
+	  (read-token input)
+	  hd))
+    (set-full-speed input)))
+
+(defun p/eof (input)
+  (unless (eq (peek-token input) :eof)
+    (wf-error input "Garbage at end of document."))
+  (when *validate*
+    (maphash (lambda (k v)
+	       (unless v
+		 (validity-error "(11) IDREF: ~S not defined" (rod-string k))))
+	     (id-table *ctx*))
+
+    (dolist (name (referenced-notations *ctx*))
+      (unless (find-notation name (dtd *ctx*))
+	(validity-error "(23) Notation Declared: ~S" (rod-string name))))))
+
 (defun p/element (input)
+  (multiple-value-bind (cat n-b new-b uri lname qname attrs) (p/sztag input)
+    (sax:start-element (handler *ctx*) uri lname qname attrs)
+    (when (eq cat :stag)
+      (let ((*namespace-bindings* n-b))
+	(p/content input))
+      (p/etag input qname))
+    (sax:end-element (handler *ctx*) uri lname qname)
+    (undeclare-namespaces new-b)
+    (validate-end-element *ctx* qname)))
+
+(defun p/sztag (input)
   (multiple-value-bind (cat sem) (read-token input)
     (case cat
       ((:stag :ztag))
@@ -2657,28 +2684,39 @@
 	    (setf attrs
 		  (remove-if (compose #'xmlns-attr-p #'sax:attribute-qname)
 			     attrs))) 
-	  (cond
-	    ((eq cat :ztag)
-	      (sax:start-element (handler *ctx*) uri local-name name attrs)
-	      (sax:end-element (handler *ctx*) uri local-name name))
-		
-	    ((eq cat :stag)
-	      (sax:start-element (handler *ctx*) uri local-name name attrs)
-	      (p/content input)
-	      (multiple-value-bind (cat2 sem2) (read-token input)
-		(unless (and (eq cat2 :etag)
-			     (eq (car sem2) name))
-		  (wf-error input "Bad nesting. ~S / ~S"
-			    (mu name)
-			    (mu (cons cat2 sem2))))
-		(when (cdr sem2)
-		  (wf-error input "no attributes allowed in end tag")))
-	      (sax:end-element (handler *ctx*) uri local-name name))
-		
-	    (t
-	      (wf-error input "Expecting element, got ~S." cat))))
-	(undeclare-namespaces new-namespaces))
-      (validate-end-element *ctx* name))))
+	  (values cat
+		  *namespace-bindings*
+		  new-namespaces
+		  uri local-name name attrs))))))
+
+(defun p/etag (input qname)
+  (multiple-value-bind (cat2 sem2) (read-token input)
+    (unless (and (eq cat2 :etag)
+		 (eq (car sem2) qname))
+      (wf-error input "Bad nesting. ~S / ~S"
+		(mu qname)
+		(mu (cons cat2 sem2))))
+    (when (cdr sem2)
+      (wf-error input "no attributes allowed in end tag"))))
+
+(defun process-characters (input sem)
+  (consume-token input)
+  (when (search #"]]>" sem)
+    (wf-error input "']]>' not allowed in CharData"))
+  (validate-characters *ctx* sem))
+
+(defun process-cdata-section (input)
+  (consume-token input)
+  (let ((input (car (zstream-input-stack input))))
+    (unless (and (rune= #/C (read-rune input))
+		 (rune= #/D (read-rune input))
+		 (rune= #/A (read-rune input))
+		 (rune= #/T (read-rune input))
+		 (rune= #/A (read-rune input))
+		 (rune= #/\[ (read-rune input)))
+      (wf-error input "After '<![', 'CDATA[' is expected."))
+    (validate-characters *ctx* #"hack")	;anything other than whitespace
+    (read-cdata-sect input)))
 
 (defun p/content (input)
   ;; [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
@@ -2688,10 +2726,7 @@
        (p/element input)
        (p/content input))
       ((:CDATA)
-       (consume-token input)
-       (when (search #"]]>" sem)
-	 (wf-error input "']]>' not allowed in CharData"))
-       (validate-characters *ctx* sem)
+       (process-characters input sem)
        (sax:characters (handler *ctx*) sem)
        (p/content input))
       ((:ENTITY-REF)
@@ -2709,21 +2744,11 @@
 					     (peek-token input))))))
           (p/content input))))
       ((:<!\[)
-       (consume-token input)
-       (cons
-        (let ((input (car (zstream-input-stack input))))
-          (unless (and (rune= #/C (read-rune input))
-                       (rune= #/D (read-rune input))
-                       (rune= #/A (read-rune input))
-                       (rune= #/T (read-rune input))
-                       (rune= #/A (read-rune input))
-                       (rune= #/\[ (read-rune input)))
-            (wf-error input "After '<![', 'CDATA[' is expected."))
-	  (validate-characters *ctx* #"hack") ;anything other than whitespace
-	  (sax:start-cdata (handler *ctx*))
-	  (sax:characters (handler *ctx*) (read-cdata-sect input))
-	  (sax:end-cdata (handler *ctx*)))
-        (p/content input)))
+       (let ((data (process-cdata-section input)))
+	 (sax:start-cdata (handler *ctx*))
+	 (sax:characters (handler *ctx*) data)
+	 (sax:end-cdata (handler *ctx*)))
+       (p/content input))
       ((:PI)
        (consume-token input)
        (sax:processing-instruction (handler *ctx*) (car sem) (cdr sem))



From dlichteblau at common-lisp.net  Sun Feb 18 11:07:39 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 06:07:39 -0500 (EST)
Subject: [cxml-cvs] CVS cxml
Message-ID: <20070218110739.CD0E01B016@common-lisp.net>

Update of /project/cxml/cvsroot/cxml
In directory clnet:/tmp/cvs-serv7372

Modified Files:
	README.html 
Log Message:
klacks documentation


--- /project/cxml/cvsroot/cxml/README.html	2006/09/16 07:52:59	1.27
+++ /project/cxml/cvsroot/cxml/README.html	2007/02/18 11:07:39	1.28
@@ -86,11 +86,12 @@
     <p>
       CXML implements a <a
       href="http://www.w3.org/TR/REC-xml-names/">namespace-aware</a>,
-      validating SAX-like <a
+      validating <a
       href="http://www.w3.org/TR/2000/REC-xml-20001006">XML&nbsp;1.0</a>
       parser as well as the <a
       href="http://www.w3.org/TR/DOM-Level-2-Core/">DOM&nbsp;Level&nbsp;2&nbsp;Core</a>
-      interfaces.
+      interfaces.  Two parser interfaces are offered, one SAX-like, the
+      other similar to StAX.
     </p>
 
     <p>
@@ -107,8 +108,9 @@
 
     <a name="changes"/>
     <h2>Recent Changes</h2>
-    <p class="nomargin"><tt>rel-2006-xx-yy</tt></p>
+    <p class="nomargin"><tt>rel-2007-xx-yy</tt></p>
     <ul class="nomargin">
+      <li>New StAX-like parser interface.</li>
       <li>Serialization fixes (thanks to Nathan Bird, Donavon Keithley).</li>
       <li>characters.lisp cleanup (thanks to Nathan Bird).</li>
       <li>Namespace normalizer bugfixes.</li>



From dlichteblau at common-lisp.net  Sun Feb 18 11:07:39 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 06:07:39 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/doc
Message-ID: <20070218110739.0B63B1B015@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/doc
In directory clnet:/tmp/cvs-serv7372/doc

Modified Files:
	quickstart.html 
Log Message:
klacks documentation


--- /project/cxml/cvsroot/cxml/doc/quickstart.html	2006/01/23 21:53:24	1.7
+++ /project/cxml/cvsroot/cxml/doc/quickstart.html	2007/02/18 11:07:39	1.8
@@ -94,5 +94,22 @@
     structure (<a href="xmls-compat.html">read more</a>):</p>
     <pre>* <b>(cxml:parse-file "example.xml" (cxml-xmls:make-xmls-builder))</b>
 ("test" (("a" "b")) ("child" NIL))</pre>
+
+    <p>Use klacks to read events from the parser incrementally.  The
+    following example looks only for :start-element and :end-element
+    events and prints them (<a href="klacks.html">read more</a>):</p>
+    <pre>* <b>(klacks:with-open-source
+    (s (cxml:make-source #p"example.xml"))
+  (loop
+      for key = (klacks:peek s)
+      while key
+      do
+	(case key
+	  (:start-element
+	    (format t "~A {" (klacks:current-qname s)))
+	  (:end-element
+	    (format t "}")))
+	(klacks:consume s)))</b>
+test {child {}}</pre>
   </body>
 </html>



From dlichteblau at common-lisp.net  Sun Feb 18 11:07:40 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 06:07:40 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/klacks
Message-ID: <20070218110740.75FA91E003@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/klacks
In directory clnet:/tmp/cvs-serv7372/klacks

Modified Files:
	klacks-impl.lisp 
Log Message:
klacks documentation


--- /project/cxml/cvsroot/cxml/klacks/klacks-impl.lisp	2007/02/11 18:21:20	1.1
+++ /project/cxml/cvsroot/cxml/klacks/klacks-impl.lisp	2007/02/18 11:07:40	1.2
@@ -249,6 +249,7 @@
 (defun klacks/eof (source input)
   (with-source (source current-key current-values)
     (p/eof input)
+    (klacks:close-source source)
     (setf current-key :end-document)
     (setf current-values nil)
     (lambda () (klacks/nil source))))



From dlichteblau at common-lisp.net  Sun Feb 18 11:07:58 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 06:07:58 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/doc
Message-ID: <20070218110758.80E4032040@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/doc
In directory clnet:/tmp/cvs-serv7463/doc

Added Files:
	klacks.html 
Log Message:
klacks documentation



--- /project/cxml/cvsroot/cxml/doc/klacks.html	2007/02/18 11:07:58	NONE
+++ /project/cxml/cvsroot/cxml/doc/klacks.html	2007/02/18 11:07:58	1.1
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
  <head>
    <title>Closure XML</title>
    <link rel="stylesheet" type="text/css" href="cxml.css"/>
  </head>
  <body>
    <div class="sidebar">
      <div class="sidebar-title">
	<a href="README.html">Closure XML</a>
      </div>
      <div class="sidebar-main">
      <ul class="main">
	<li>
          <a href="installation.html">Installing Closure XML</a>
          <ul class="sub">
	    <li><a href="installation.html#download"><b>Download</b></a></li>
	    <li><a href="installation.html#implementations">Implementation-specific notes</a></li>
	    <li><a href="installation.html#compilation">Compilation</a></li>
	    <li><a href="installation.html#tests">Tests</a></li>
          </ul>
	</li>
        <li>
          <ul class="hack">
            <li>
              <a href="quickstart.html"><b>Quick-Start Example</b></a>
            </li>
          </ul>
        </li>
	<li>
          <a href="using.html">SAX parser</a>
          <ul class="sub">
            <li><a href="using.html#parser">Parsing and Validating</a></li>
            <li><a href="using.html#serialization">Serialization</a></li>
            <li><a href="using.html#misc">Miscellaneous SAX handlers</a></li>
            <li><a href="using.html#rods">Recoders</a></li>
            <li><a href="using.html#dtdcache">Caching of DTD Objects</a></li>
            <li><a href="using.html#catalogs">XML Catalogs</a></li>
	    <li><a href="using.html#sax">SAX Interface</a></li>
          </ul>
	</li>
	<li>
          <a href="klacks.html">Klacks parser</a>
          <ul class="hack">
            <li><a href="klacks.html#parsing">Parsing incrementally</a></li>
            <li><a href="klacks.html#sax">Bridging Klacks and SAX</a></li>
          </ul>
        </li>
	<li>
          <a href="dom.html">DOM implementation</a>
          <ul class="sub">
            <li><a href="dom.html#parser">Parsing with the DOM builder</a></li>
            <li><a href="dom.html#serialization">Serialization</a></li>
	    <li><a href="dom.html#mapping">DOM/Lisp mapping</a></li>
          </ul>
	</li>
	<li>
          <ul class="hack">
            <li><a href="xmls-compat.html">XMLS Builder</a></li>
          </ul>
        </li>
      </ul>
      </div>
    </div>

    <h1>Klacks parser</h1>
    <p>
      The Klacks parser provides an alternative parsing interface,
      similar in concept to Java's <a
      href="http://jcp.org/en/jsr/detail?id=173">Streaming API for
      XML</a> (StAX).
    </p>
    <p>
      It implements a streaming, "pull-based" API.  This is different
      from SAX, which is a "push-based" model.
    </p>
    <p>
      Klacks is implemented using the same code base as the SAX parser
      and has the same parsing characteristics (validation, namespace
      support, entity resolution) while offering a more flexible interface
      than SAX.
    </p>

    <h3>Example</h3>
    <p>
      The following example illustrates creation of a klacks <tt>source</tt>,
      use of the <tt>consume</tt> function to read individual events,
      and shows some of the most common event types.
    </p>
    <pre>* <b>(defparameter *source* (cxml:make-source "&lt;example>text&lt;/example>"))</b>
*SOURCE*
* <b>(klacks:consume *source*)</b>
:START-DOCUMENT
* <b>(klacks:consume *source*)</b>
:START-ELEMENT
NIL                      ;namespace URI
"example"                ;local name
"example"                ;qualified name
* <b>(klacks:consume *source*)</b>
:CHARACTERS
"text"
* <b>(klacks:consume *source*)</b>
:END-ELEMENT
NIL
"example"
"example"
* <b>(klacks:consume *source*)</b>
:END-DOCUMENT
* <b>(klacks:consume *source*)</b>
NIL</pre>

    <h3>Klacks sources</h3>
    <p>
      To parse using Klacks, create an XML <tt>source</tt> first.
    </p>
    <p>
      <div class="def">Function CXML:MAKE-SOURCE (input &key validate
      dtd root entity-resolver disallow-external-subset pathname)</div>
      Create and return a source for <tt>input</tt>.
    </p>
    <p>
      Exact behaviour depends on <tt>input</tt>, which can
      be one of the following types:
    </p>
    <ul>
      <li>
	<tt>pathname</tt> -- a Common Lisp pathname.  
	Open the file specified by the pathname and create a source for
	the resulting stream.  See below for information on how to
        close the stream.
      </li>
      <li><tt>stream</tt> -- a Common Lisp stream with element-type
        <tt>(unsigned-byte 8)</tt>.  See below for information on how to
        close the stream.
      </li>
      <li>
	<tt>octets</tt> -- an <tt>(unsigned-byte 8)</tt> array.
	The array is parsed directly, and interpreted according to the
	encoding it specifies.
      </li>
      <li>
	<tt>string</tt>/<tt>rod</tt> -- a rod (or <tt>string</tt> on
	unicode-capable implementations).
	Parses an XML document from the input string that has already
	undergone external-format decoding.
      </li>
    </ul>
    <p>
      <b>Closing streams:</b> Sources can refer to Lisp streams that
      need to be closed after parsing.  This includes a stream passed
      explicitly as <tt>input</tt>, a stream created implicitly for the
      <tt>pathname</tt> case, as well as any streams created
      automatically for external parsed entities referred to by the
      document.
    </p>
    <p>
      All these stream get closed automatically if end of file is
      reached normally.  Use <tt>klacks:close-source</tt> or
      <tt>klacks:with-open-source</tt> to ensure that the streams get
      closed otherwise.
    </p>
    <p>
      <b>Keyword arguments</b> have the same meaning as with the SAX parser,
      please refer to the documentation of <a
      href="using.html#parser">parse-file</a> for more information:
    </p>
    <ul>
      <li>
        <tt>validate</tt>
      </li>
      <li>
        <tt>dtd</tt>
      </li>
      <li><tt>root</tt>
      </li>
      <li>
        <tt>entity-resolver</tt>
      </li>
      <li>
        <tt>disallow-internal-subset</tt>
      </li>
    </ul>
    <p>
      In addition, the following argument is for types of <tt>input</tt>
      other than <tt>pathname</tt>:
    </p>
    <ul>
      <li>
        <tt>pathname</tt> -- If specified, defines the base URI of the
        document based on this pathname instance.
      </li>
    </ul>

    <p>
      Events are read from the stream using the following functions:
    </p>
    <p>
      <div class="def">Function KLACKS:PEEK (source)</div>
     <p> => :start-document<br/>
          or => :start-document, version, encoding, standalonep<br/>
          or => :dtd, name, public-id, system-id<br/>
          or => :start-element, uri, lname, qname<br/>
          or => :end-element, uri, lname, qname<br/>
          or => :characters, data<br/>
          or => :processing-instruction, target, data<br/>
          or => :comment, data<br/>
          or => :end-document, data<br/>
          or => nil
    </p>
    <p>
      <tt>peek</tt> returns the current event's key and main values.
    </p>
    <p>
      <div class="def">Function KLACKS:CONSUME (source) => key, value*</div>
    </p>
    <p>
      Return the same values <tt>peek</tt> would, and in addition
      advance the source forward to the next event.
    </p>
    <p>
      <div class="def">Function KLACKS:PEEK-VALUE (source) => value*</div>
    </p>
    <p>
      Like <tt>peek</tt>, but return only the values, not the key.
    </p>
    <p>
      <div class="def">Function KLACKS:CURRENT-URI (source) => uri</div>
      <div class="def">Function KLACKS:CURRENT-LNAME (source) => string</div>
      <div class="def">Function KLACKS:CURRENT-QNAME (source) => string</div>
    </p>
    <p>
     If the current event is :start-element or :end-element, return the
     corresponding value.  Else, signal an error.
    </p>
    <p>
      <div class="def">Function KLACKS:CURRENT-CHARACTERS (source) => string</div>
    </p>
    <p>
     If the current event is :characters, return the character data
     value.  Else, signal an error.
    </p>
    <p>
      <div class="def">Function KLACKS:CURRENT-CDATA-SECTION-P (source) => boolean</div>
    </p>
    <p>
     If the current event is :characters, determine whether the data was
     specified using a CDATA section in the source document.  Else,
     signal an error.
    </p>
    <p>
      <div class="def">Function KLACKS:MAP-ATTRIBUTES (fn source)</div>
    </p>
    <p>
     Call <tt>fn</tt> for each attribute of the current start tag in
     turn, and pass the following values as arguments to the function:
	<ul>
	  <li>namespace uri</li>
	  <li>local name</li>
	  <li>qualified name</li>
	  <li>attribute value</li>
	  <li>a boolean indicating whether the attribute was specified
	  explicitly in the source document, rather than defaulted from
	  a DTD</li>
	</ul>
     Only valid for :start-element.
    </p>
    <p>
     Return a list of SAX attribute structures for the current start tag.
     Only valid for :start-element.
    </p>

    <p>
      <div class="def">Function KLACKS:CLOSE-SOURCE (source)</div>
      Close all streams referred to by <tt>source</tt>.
    </p>
    <p>
      <div class="def">Macro KLACKS:WITH-OPEN-SOURCE ((var source) &body body)</div>
      Evaluate <tt>source</tt> to create a source object, bind it to
      symbol <tt>var</tt> and evaluate <tt>body</tt> as an implicit progn.
      Call <tt>klacks:close-source</tt> to close the source after
      exiting <tt>body</tt>, whether normally or abnormally.
    </p>
  </body>
</html>


From dlichteblau at common-lisp.net  Sun Feb 18 12:35:50 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 07:35:50 -0500 (EST)
Subject: [cxml-cvs] CVS cxml
Message-ID: <20070218123550.47F527D163@common-lisp.net>

Update of /project/cxml/cvsroot/cxml
In directory clnet:/tmp/cvs-serv24418

Added Files:
	README 
Removed Files:
	README.html 
Log Message:
use xsl to build the html documentation from xml



--- /project/cxml/cvsroot/cxml/README	2007/02/18 12:35:50	NONE
+++ /project/cxml/cvsroot/cxml/README	2007/02/18 12:35:50	1.1

Closure XML Parser

   An XML parser written in Common Lisp.

   Closure XML was written by Gilbert Baumann (unk6 at
   rz.uni-karlsruhe.de) as part of the Closure web browser.

   Contributions to the parser by
     * Henrik Motakef (hmot at henrik-motakef.de)
     * David Lichteblau (david at lichteblau.com)

   CXML implements a namespace-aware, validating XML 1.0 parser
   as well as the DOM Level 2 Core interfaces. Two parser interfaces
   are offered, one SAX-like, the other similar to StAX.

   CXML is licensed under Lisp-LGPL.

   Send bug reports to cxml-devel at common-lisp.net
   (http://common-lisp.net/cgi-bin/mailman/listinfo/cxml-devel)


Documentation

   Please refer to http://common-lisp.net/project/cxml/ for details.

   The documentation is also available in the doc/ subdirectory of this
   source distribution, run `make' in that directory to build HTML
   for the XML sources (requires xsltproc).


From dlichteblau at common-lisp.net  Sun Feb 18 12:35:50 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 07:35:50 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/doc
Message-ID: <20070218123550.B419F7E003@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/doc
In directory clnet:/tmp/cvs-serv24418/doc

Added Files:
	GNUmakefile dom.xml html.xsl index.xml installation.xml 
	klacks.xml quickstart.xml sax.xml xmls-compat.xml 
Removed Files:
	dom.html installation.html klacks.html quickstart.html 
	using.html xmls-compat.html 
Log Message:
use xsl to build the html documentation from xml



--- /project/cxml/cvsroot/cxml/doc/GNUmakefile	2007/02/18 12:35:50	NONE
+++ /project/cxml/cvsroot/cxml/doc/GNUmakefile	2007/02/18 12:35:50	1.1
all: dom.html index.html installation.html klacks.html quickstart.html sax.html xmls-compat.html

%.html: %.xml html.xsl
	xsltproc html.xsl $< >$@
--- /project/cxml/cvsroot/cxml/doc/dom.xml	2007/02/18 12:35:50	NONE
+++ /project/cxml/cvsroot/cxml/doc/dom.xml	2007/02/18 12:35:50	1.1
<documentation title="CXML W3C DOM">
  <h1>W3C DOM</h1>
  <p>
    CXML implements the DOM Level 2 Core interfaces.&#160; For details
    on DOM, please refer to the <a
				   href="http://www.w3.org/TR/DOM-Level-2-Core/core.html">specification</a>.
  </p>

  <a name="parser"/>
  <h3>Parsing into DOM</h3>
  <p>
    To parse an XML document into a DOM tree, use the SAX parser with a
    DOM builder as the SAX handler.  Example:
  </p>
  <pre>(cxml:parse-file "test.xml" (cxml-dom:make-dom-builder))</pre>
  <p>
    <div class="def">Function CXML-DOM:MAKE-DOM-BUILDER ()</div>
    Create a SAX handler which builds a DOM document.
    <p>
    </p>
    This functions returns a DOM builder that will work with the default
    configuration of the SAX parser and is guaranteed to use
    characters/strings instead of runes/rods, if that makes a
    difference on the Lisp in question.
    <p>
    </p>
    This is the same as <tt>rune-dom:make-dom-builder</tt> on Lisps
    with Unicode support, and the same as
    <tt>utf8-dom:make-dom-builder</tt> otherwise.
  </p>

  <p>
    <div class="def">Function RUNE-DOM:MAKE-DOM-BUILDER ()</div>
    Create a SAX handler which builds a DOM document using runes and rods.
  </p>

  <p>
    <div class="def">Function UTF8-DOM:MAKE-DOM-BUILDER ()</div>
    (Only on Lisps without Unicode support:)
    Create a SAX handler which builds a DOM document using
    UTF-8-encoded strings.
  </p>

  <a name="serialization"/>
  <h3>Serializing DOM</h3>
  <p>
    To serialize a DOM document, use a SAX serialization sink as the
    argument to <tt>dom:map-document</tt>, which generates SAX events
    for the DOM tree.
  </p>
  <p>
    Applications dealing with namespaces might want to inject a
    <a href="sax.html#misc">namespace normalizer</a> into the
    sink chain.
  </p>
  <p>
    <div class="def">Function DOM:MAP-DOCUMENT (handler document &amp;key include-xmlns-attributes include-default-values include-doctype)</div>
    Traverse a DOM document and call SAX functions as if an XML
    representation of the document was processed by a SAX parser.
  </p>
  <p>Keyword arguments:</p>
  <ul>
    <li>
      <tt>include-xmlns-attributes</tt> -- defaults to
      <tt>sax:*include-xmlns-attributes*</tt>
    </li>
    <li>
      <tt>include-doctype</tt> -- One of <tt>nil</tt> (no doctype
      declaration), <tt>:full-internal-subset</tt> (include a doctype
      declaration and the full internal subset), or
      <tt>:canonical-notations</tt> (write a doctype declaration
      with an internal subset including only notations, as required
      for canonical serialization).
    </li>
    <li>
      <tt>include-default-values</tt> -- include attribute nodes with nil
      <tt>dom:specified</tt>.
    </li>
    <li>
      <tt>recode</tt> -- (ignored on Lisps with Unicode support.) If
      true, recode UTF-8 strings to rods.   Defaults to true if used
      with a UTF-8 DOM document.  It can be set to false manually to
      suppress recoding in this case.
    </li>
  </ul>

  <a name="mapping"/>
  <h3>DOM/Lisp mapping</h3>
  <p>
    Note that there is no "standard" DOM mapping for Lisp.
  </p>
  <p>
    DOM is <a
	      href="http://www.w3.org/TR/DOM-Level-2-Core/idl-definitions.html">specified
      in CORBA IDL</a>, but it refrains from using object-oriented IDL
    features, allowing for a much more natural Lisp implemenation than
    the the ordinary IDL/Lisp mapping would.&#160;
    Differences between CXML's DOM and the direct IDL/Lisp mapping:
  </p>
  <ul>
    <li>
      DOM function names are symbols in the <tt>DOM</tt> package (not
      the <tt>OP</tt> package).
    </li>
    <li>
      DOM functions have proper required arguments, not a huge
      <tt>&amp;rest</tt> lambda list.
    </li>
    <li>
      Although most IDL interfaces are implemented as CLOS classes by
      CXML, the Lisp types of DOM objects is not documented and cannot
      be relied upon.&#160; A node's type can be determined using
      <tt>dom:node-type</tt> instead.
    </li>
    <li>
      <tt>DOMString</tt> is mapped to <tt>rod</tt>, which is either
      an <tt>(unsigned-byte 16)</tt> array type or a string type.
    </li>
    <li>
      The IDL/Lisp mapping maps CORBA enums to Lisp keywords.&#160;
      Unfortunately, the DOM IDL does not use enums.&#160; Instead,
      both exception types and node types are defined integer
      constants.&#160; CXML chooses to ignore this definition and uses
      keywords instead.
    </li>
    <li>
      DOM uses StudlyCaps.&#160; Lisp programmers don't.&#160; We
      insert <tt>#\-</tt> before every upper case letter preceded by a
      lower case letter and before every upper case letter which is
      followed by a lower case letter, but preceded by a capital
      letter.&#160; This algorithms leads to the natural Lisp spelling
      of DOM function names.
    </li>
    <li>
      Implementation note: DOM's <tt>NodeList</tt> does not
      necessarily map to a native "sequence" type.&#160; (For example,
      node lists are objects in Java, not arrays.)&#160;
      <tt>NodeList</tt> is specified to reflect changes done after a
      node list was created, so node lists cannot be Lisp lists.&#160;
      (A node list could be implemented as a CLOS object pointing to
      said list though.)&#160; Instead, CXML currently implements node
      lists as adjustable vectors.&#160; Note that code which relies on
      this implementation and uses Lisp sequence functions
      instead of sticking to <tt>dom:item</tt> and <tt>dom:length</tt>
      is not portable.&#160; As a compromise, you can use our
      extensions <tt>dom:map-node-list</tt> or
      <tt>dom:do-node-list</tt>, which can be implemented portably.
    </li>
  </ul>
</documentation>
--- /project/cxml/cvsroot/cxml/doc/html.xsl	2007/02/18 12:35:50	NONE
+++ /project/cxml/cvsroot/cxml/doc/html.xsl	2007/02/18 12:35:50	1.1
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
  <xsl:output method="html"
	      indent="yes"
	      doctype-public="-//W3C//DTD HTML 4.01 Transitional//EN"
	      doctype-system="http://www.w3.org/TR/html4/loose.dtd"/>

	      <xsl:template match="@*|node()">
  <xsl:copy>
    <xsl:apply-templates select="@*|node()"/>
  </xsl:copy>	
</xsl:template>

  <xsl:template match="documentation">
    <html>
      <head>
	<title>
	  <xsl:value-of select="@title"/>
	</title>
	<link rel="stylesheet" type="text/css" href="cxml.css"/>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
      </head>
      <body>
    <div class="sidebar">
      <div class="sidebar-title">
	<a href="index.html">Closure XML</a>
      </div>
      <div class="sidebar-main">
      <ul class="main">
	<li>
          <a href="installation.html">Installing Closure XML</a>
          <ul class="sub">
	    <li><a href="installation.html#download"><b>Download</b></a></li>
	    <li><a href="installation.html#implementations">Implementation-specific notes</a></li>
	    <li><a href="installation.html#compilation">Compilation</a></li>
	    <li><a href="installation.html#tests">Tests</a></li>
          </ul>
	</li>
        <li>
          <ul class="hack">
            <li>
              <a href="quickstart.html"><b>Quick-Start Example</b></a>
            </li>
          </ul>
        </li>
	<li>
          <a href="sax.html">SAX parsing and serialization</a>
          <ul class="sub">
            <li><a href="sax.html#parser">Parsing and Validating</a></li>
            <li><a href="sax.html#serialization">Serialization</a></li>
            <li><a href="sax.html#misc">Miscellaneous SAX handlers</a></li>
            <li><a href="sax.html#rods">Recoders</a></li>
            <li><a href="sax.html#dtdcache">Caching of DTD Objects</a></li>
            <li><a href="sax.html#catalogs">XML Catalogs</a></li>
	    <li><a href="sax.html#sax">SAX Interface</a></li>
          </ul>
	</li>
	<li>
          <a href="klacks.html">Klacks parser</a>
          <ul class="sub">
            <li><a href="klacks.html#parsing">Parsing incrementally</a></li>
            <li><a href="klacks.html#sax">Bridging Klacks and SAX</a></li>
          </ul>
        </li>
	<li>
          <a href="dom.html">DOM implementation</a>
          <ul class="sub">
            <li><a href="dom.html#parser">Parsing with the DOM builder</a></li>
            <li><a href="dom.html#serialization">Serialization</a></li>
	    <li><a href="dom.html#mapping">DOM/Lisp mapping</a></li>
          </ul>
	</li>
	<li>
          <ul class="hack">
            <li><a href="xmls-compat.html">XMLS Builder</a></li>
          </ul>
        </li>
      </ul>
      </div>
    </div>
	  <xsl:apply-templates/>
      </body>
    </html>
  </xsl:template>

</xsl:stylesheet>
--- /project/cxml/cvsroot/cxml/doc/index.xml	2007/02/18 12:35:50	NONE
+++ /project/cxml/cvsroot/cxml/doc/index.xml	2007/02/18 12:35:50	1.1
<documentation title="Closure XML">
    <h1>Closure XML Parser</h1>

    <p>An XML parser written in Common Lisp.</p>

    <p>
      Closure XML was written by <a
      href="http://www.stud.uni-karlsruhe.de/~unk6/">Gilbert Baumann</a>
      (unk6 at rz.uni-karlsruhe.de) as part of the Closure web
      browser.<br/>
      Contributions to the parser by
    </p>
    <ul>
      <li>
        Henrik Motakef (hmot at henrik-motakef.de)<br/>
        (SAX layer; namespace support)
      </li>
      <li>
        <a href="mailto:david at lichteblau.com">David Lichteblau</a> for <a
        href="http://www.knowledgetools.de">knowledgeTools</a>
        (conversion into an independent package; DOM bug fixing; validation)
        and <a href="http://www.headcraft.de/">headcraft</a>
        (most september/october 2004 changes) and privately (changes
        since then).
      </li>
    </ul>

    <p>
      CXML implements a <a
      href="http://www.w3.org/TR/REC-xml-names/">namespace-aware</a>,
      validating <a
      href="http://www.w3.org/TR/2000/REC-xml-20001006">XML&#160;1.0</a>
      parser as well as the <a
      href="http://www.w3.org/TR/DOM-Level-2-Core/">DOM&#160;Level&#160;2&#160;Core</a>
      interfaces.  Two parser interfaces are offered, one SAX-like, the
      other similar to StAX.
    </p>

    <p>
      CXML is licensed under Lisp-LGPL.
    </p>

    <p>
      Send bug reports to <a
      href="mailto:cxml-devel at common-lisp.net">cxml-devel at common-lisp.net</a>
      (<a
      href="http://common-lisp.net/cgi-bin/mailman/listinfo/cxml-devel">list
      information</a>).
    </p>

    <a name="changes"/>
    <h2>Recent Changes</h2>
    <p class="nomargin"><tt>rel-2007-xx-yy</tt></p>
    <ul class="nomargin">
      <li>New StAX-like parser interface.</li>
      <li>Serialization fixes (thanks to Nathan Bird, Donavon Keithley).</li>
      <li>characters.lisp cleanup (thanks to Nathan Bird).</li>
      <li>Namespace normalizer bugfixes.</li>
      <li>Minor changes: clone-node on document as an extension.  DOM
      class hierarchy reworked.  New function parse-empty-document.
      Fixed the DOM serializer to not throw away local names.
      Fixed a long-standing bug in the parser for documents without a
      doctype. ANSI conformance fixes.</li>
    </ul>
    <p class="nomargin"><tt>rel-2006-01-05</tt></p>
    <ul class="nomargin">
      <li>Implemented DOM 2 Core.</li>
      <li>Error handling overhaul.</li>
      <li>UTF-8 string support in DOM on Lisps without Unicode characters.</li>
      <li>Sink API has been changed.</li>
      <li>Support internal subset serialization.</li>
      <li>Whitespace normalizer.</li>
      <li>Gilbert Baumann has clarified the license as Lisp-LGPL.</li>
      <li>Use trivial-gray-streams.</li>
    </ul>
    <p class="nomargin"><tt>rel-2005-06-25</tt></p>
    <ul class="nomargin">
      <li>Port to OpenMCL (thanks to Rudi Schlatte).</li>
      <li>Port to LispWorks (thanks to Edi Weitz).</li>
      <li>Minor new features: <tt>include-default-values</tt> argument to
      <tt>make-xmls-builder</tt>; <tt>handler</tt> argument
      to <tt>parse-dtd-stream</tt>; SAX proxy class</li>
      <li>Various bugfixes.</li>
    </ul>
    <p class="nomargin"><tt>patch-357</tt> (2004-10-10)</p>
    <ul class="nomargin">
      <li>Auto-detect unicode support for better asdf-installability.</li>
      <li>Use the puri library for Sys-ID handling.</li>
      <li>Semi-automatic caching of DTD instances.</li>
      <li>Support user-defined entity resolvers.</li>
      <li>Support for Oasis XML Catalogs.</li>
      <li>xhtmlgen version of Franz htmlgen.</li>
      <li>Fixes for SBCL's unicode support.</li>
    </ul>
    <p class="nomargin"><tt>patch-306</tt> (2004-09-03)</p>
    <ul class="nomargin">
      <li>Event-based serialization which does not require DOM documents</li>
      <li>XMLS compatiblity</li>
      <li>minor bugfixes (thread safety; should work on clisp again)</li>
    </ul>
    <p class="nomargin"><tt>patch-279</tt> (2004-05-11)</p>
    <ul class="nomargin">
      <li>Validation</li>
      <li>bugfixes; XHTML DTD parses again; corrected SAX entity handling</li>
    </ul>
    <p class="nomargin"><tt>patch-204</tt></p>
    <ul class="nomargin">
      <li>Renamed package <tt>XML</tt> to <tt>CXML</tt>.</li>
      <li>The unparse functions support non-canonical output now.</li>
    </ul>
    <p class="nomargin"><tt>patch-191</tt> (2004-03-18)</p>
    <ul class="nomargin">
      <li>Initial release.</li>
    </ul>
</documentation>
--- /project/cxml/cvsroot/cxml/doc/installation.xml	2007/02/18 12:35:50	NONE
+++ /project/cxml/cvsroot/cxml/doc/installation.xml	2007/02/18 12:35:50	1.1
<documentation title="CXML Installation">
    <h1>Installation of Closure XML</h1>

    <a name="download"/>
    <h2>Download</h2>
    <ul>
      <li>
        <div><a href="http://common-lisp.net/project/cxml/download/">tarballs</a></div>
      </li>
      <li>
        <div>
      Anoncvs (<a href="http://common-lisp.net/cgi-bin/viewcvs.cgi/cxml/?cvsroot=cxml">browse</a>):
      <pre>$ export CVSROOT=:pserver:anonymous at common-lisp.net:/project/cxml/cvsroot
$ cvs login
Logging in to :pserver:anonymous at common-lisp.net:2401/project/cxml/cvsroot
CVS password: anonymous
$ cvs co cxml</pre>
        </div>
      </li>
    </ul>

    <a name="implementations"/>
    <h2>Implementation-specific notes</h2>
    <p>
      CXML should be portable to all Common Lisp implementations
      supported by <a
      href="http://common-lisp.net/project/cl-plus-ssl/#trivial-gray-streams">trivial-gray-streams</a>.
    </p>
    <ul>
      <li>
	The SBCL port uses 16 bit surrogate characters instead of taking
	advantage of SBCL's full 21 bit character support.
      </li>
    </ul>

    <a name="compilation"/>
    <h2>Compilation</h2>
    <p>
      <a href="http://www.cliki.net/asdf">ASDF</a> is used for
      compilation.  The following instructions assume that ASDF has
      already been loaded.
    </p>

    <p>
      <b>Prerequisites.</b>
      CXML needs the <a href="http://www.cliki.net/Puri">puri</a> library

[58 lines skipped]
--- /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 12:35:50	NONE
+++ /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 12:35:50	1.1

[276 lines skipped]
--- /project/cxml/cvsroot/cxml/doc/quickstart.xml	2007/02/18 12:35:50	NONE
+++ /project/cxml/cvsroot/cxml/doc/quickstart.xml	2007/02/18 12:35:50	1.1

[332 lines skipped]
--- /project/cxml/cvsroot/cxml/doc/sax.xml	2007/02/18 12:35:50	NONE
+++ /project/cxml/cvsroot/cxml/doc/sax.xml	2007/02/18 12:35:50	1.1

[944 lines skipped]
--- /project/cxml/cvsroot/cxml/doc/xmls-compat.xml	2007/02/18 12:35:50	NONE
+++ /project/cxml/cvsroot/cxml/doc/xmls-compat.xml	2007/02/18 12:35:50	1.1

[1018 lines skipped]


From dlichteblau at common-lisp.net  Sun Feb 18 14:35:14 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 09:35:14 -0500 (EST)
Subject: [cxml-cvs] CVS cxml
Message-ID: <20070218143514.DAD23111CC@common-lisp.net>

Update of /project/cxml/cvsroot/cxml
In directory clnet:/tmp/cvs-serv13701

Modified Files:
	cxml.asd 
Log Message:
klacks fixes


--- /project/cxml/cvsroot/cxml/cxml.asd	2007/02/11 18:21:20	1.14
+++ /project/cxml/cvsroot/cxml/cxml.asd	2007/02/18 14:35:14	1.15
@@ -127,7 +127,7 @@
                "test/"
                (make-pathname :name nil :type nil :defaults *load-truename*))
     :components ((:file "domtest") (:file "xmlconf"))
-    :depends-on (:cxml-xml :cxml-dom))
+    :depends-on (:cxml-xml :cxml-klacks :cxml-dom))
 
 (asdf:defsystem :cxml
     :components ()



From dlichteblau at common-lisp.net  Sun Feb 18 14:35:15 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 09:35:15 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/doc
Message-ID: <20070218143515.28576120A0@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/doc
In directory clnet:/tmp/cvs-serv13701/doc

Modified Files:
	klacks.xml 
Log Message:
klacks fixes


--- /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 12:35:50	1.1
+++ /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 14:35:14	1.2
@@ -215,4 +215,11 @@
       Call <tt>klacks:close-source</tt> to close the source after
       exiting <tt>body</tt>, whether normally or abnormally.
     </p>
+
+    <h3>Bridging Klacks and SAX</h3>
+    <p>
+      <div class="def">Function KLACKS:SERIALIZE-SOURCE (source handler)</div>
+      Read all klacks events from <tt>source</tt> and send them as SAX
+      events to the SAX <tt>handler</tt>.
+    </p>
 </documentation>



From dlichteblau at common-lisp.net  Sun Feb 18 14:35:15 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 09:35:15 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/dom
Message-ID: <20070218143515.5D943120A0@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/dom
In directory clnet:/tmp/cvs-serv13701/dom

Modified Files:
	dom-builder.lisp 
Log Message:
klacks fixes


--- /project/cxml/cvsroot/cxml/dom/dom-builder.lisp	2007/02/11 18:21:20	1.11
+++ /project/cxml/cvsroot/cxml/dom/dom-builder.lisp	2007/02/18 14:35:15	1.12
@@ -37,10 +37,11 @@
     (setf (document handler) document)
     (push document (element-stack handler))))
 
+;; fixme
+(defmethod sax::dtd ((handler dom-builder) dtd)
+  (setf (slot-value (document handler) 'dtd) dtd))
+
 (defmethod sax:end-document ((handler dom-builder))
-  (setf (slot-value (document handler) 'dtd)
-	;; FIXME!
-	(and cxml::*ctx* (cxml::dtd cxml::*ctx*)))
   (let ((doctype (dom:doctype (document handler))))
     (when doctype
       (setf (slot-value (dom:entities doctype) 'read-only-p) t)



From dlichteblau at common-lisp.net  Sun Feb 18 14:35:16 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 09:35:16 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/klacks
Message-ID: <20070218143516.55840120A2@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/klacks
In directory clnet:/tmp/cvs-serv13701/klacks

Modified Files:
	klacks-impl.lisp klacks.lisp 
Log Message:
klacks fixes


--- /project/cxml/cvsroot/cxml/klacks/klacks-impl.lisp	2007/02/18 11:07:40	1.2
+++ /project/cxml/cvsroot/cxml/klacks/klacks-impl.lisp	2007/02/18 14:35:15	1.3
@@ -31,7 +31,7 @@
      (current-values)
      (current-attributes)
      (cdata-section-p :reader klacks:current-cdata-section-p)
-     ;; extra with-source magic
+     ;; extra WITH-SOURCE magic
      (data-behaviour :initform :DTD)
      (namespace-stack :initform (list *initial-namespace-bindings*))
      (temporary-streams :initform nil)
@@ -126,13 +126,18 @@
 	(apply #'make-source xstream args)))
     (pathname
       (let* ((xstream
-	      (make-xstream (open input :element-type '(unsigned-byte 8))))
-	     (source (apply #'make-source
-			    xstream
-			    :pathname input
-			    args)))
-	(push xstream (slot-value source 'temporary-streams))
-	source))
+	      (make-xstream (open input :element-type '(unsigned-byte 8)))))
+	(setf (xstream-name xstream)
+	      (make-stream-name
+	       :entity-name "main document"
+	       :entity-kind :main
+	       :uri (pathname-to-uri (merge-pathnames input))))
+	(let ((source (apply #'make-source
+			     xstream
+			     :pathname input
+			     args)))
+	  (push xstream (slot-value source 'temporary-streams))
+	  source)))
     (rod
       (let ((xstream (string->xstream input)))
 	(setf (xstream-name xstream)
@@ -152,8 +157,7 @@
   (check-type entity-resolver (or null function symbol))
   (check-type disallow-internal-subset boolean)
   (let* ((context
-	  (make-context :handler nil
-			:main-zstream input
+	  (make-context :main-zstream input
 			:entity-resolver entity-resolver
 			:disallow-internal-subset disallow-internal-subset))
 	 (source
@@ -167,6 +171,7 @@
 	    :scratch-pad-2 *scratch-pad-2*
 	    :scratch-pad-3 *scratch-pad-3*
 	    :scratch-pad-4 *scratch-pad-4*)))
+    (setf (handler context) (make-instance 'klacks-dtd-handler :source source))
     (setf (slot-value source 'continuation)
 	  (lambda () (klacks/xmldecl source input)))
     source))
@@ -208,25 +213,26 @@
 (defun klacks/doctype (source input)
   (with-source (source current-key current-values validate dtd)
     (let ((cont (lambda () (klacks/finish-doctype source input)))
-	  ignoreme name extid)
+	  l)
       (prog1
 	  (cond
 	    ((eq (peek-token input) :<!DOCTYPE)
-	      (setf (values ignoreme name extid)
-		    (p/doctype-decl input dtd))
+	      (setf l (cdr (p/doctype-decl input dtd)))
 	      (lambda () (klacks/misc*-2 source input cont)))
 	    (dtd
-	      (setf (values ignoreme name extid)
-		    (synthesize-doctype dtd input))
+	      (setf l (cdr (synthesize-doctype dtd input)))
 	      cont)
 	    ((and validate (not dtd))
 	      (validity-error "invalid document: no doctype"))
 	    (t
 	      (return-from klacks/doctype
 		(funcall cont))))
-	(setf current-key :dtd)
-	(setf current-values
-	      (list name (extid-public extid) (extid-system extid)))))))
+	(destructuring-bind (&optional name extid) l
+	  (setf current-key :dtd)
+	  (setf current-values
+		(list name
+		      (and extid (extid-public extid))
+		      (and extid (extid-system extid)))))))))
 
 (defun klacks/finish-doctype (source input)
   (with-source (source current-key current-values root data-behaviour)
@@ -323,7 +329,7 @@
 	      (klacks/entity-reference source input name recurse)))
 	  ((:<!\[)
 	    (setf current-key :characters)
-	    (setf current-values (list (process-cdata-section input sem)))
+	    (setf current-values (list (process-cdata-section input)))
 	    (setf cdata-section-p t)
 	    recurse)
 	  ((:PI)
@@ -376,6 +382,58 @@
     (set-full-speed input)
     (klacks/content source input cont)))
 
+
+;;;; terrible kludges
+
+(defclass klacks-dtd-handler ()
+    ((handler-source :initarg :source :reader handler-source)
+     (internal-subset-p :initform nil :accessor handler-internal-subset-p)))
+
+(defmethod sax:start-internal-subset ((handler klacks-dtd-handler))
+  (setf (slot-value (handler-source handler) 'internal-declarations) '())
+  (setf (handler-internal-subset-p handler) t))
+
+(defmethod sax:end-internal-subset ((handler klacks-dtd-handler))
+  (setf (handler-internal-subset-p handler) nil))
+
+(defmethod sax:entity-resolver ((handler klacks-dtd-handler) fn)
+  (setf (slot-value (handler-source handler) 'dom-impl-entity-resolver) fn))
+
+(defmethod sax::dtd ((handler klacks-dtd-handler) dtd)
+  (setf (slot-value (handler-source handler) 'dom-impl-dtd) dtd))
+
+(defmethod sax:end-dtd ((handler klacks-dtd-handler))
+  (let ((source (handler-source handler)))
+    (when (slot-boundp source 'internal-declarations)
+      (setf (slot-value source 'internal-declarations)
+	    (reverse (slot-value source 'internal-declarations)))
+      (setf (slot-value source 'external-declarations)
+	    (reverse (slot-value source 'external-declarations))))))
+
+(macrolet
+    ((defhandler (name &rest args)
+	 `(defmethod ,name ((handler klacks-dtd-handler) , at args)
+	    (let ((source (handler-source handler))
+		  (spec (list ',name , at args)))
+	      (if (handler-internal-subset-p handler)
+		  (push spec (slot-value source 'internal-declarations))
+		  (push spec (slot-value source 'external-declarations)))))))
+  (defhandler sax:unparsed-entity-declaration
+      name public-id system-id notation-name)
+  (defhandler sax:external-entity-declaration
+      kind name public-id system-id)
+  (defhandler sax:internal-entity-declaration
+      kind name value)
+  (defhandler sax:notation-declaration
+      name public-id system-id)
+  (defhandler sax:element-declaration
+      name model)
+  (defhandler sax:attribute-declaration
+      element-name attribute-name type default))
+
+
+;;;; debugging
+
 #+(or)
 (trace CXML::KLACKS/DOCTYPE 
        CXML::KLACKS/EXT-PARSED-ENT 
--- /project/cxml/cvsroot/cxml/klacks/klacks.lisp	2007/02/11 18:21:20	1.1
+++ /project/cxml/cvsroot/cxml/klacks/klacks.lisp	2007/02/18 14:35:15	1.2
@@ -18,7 +18,13 @@
 
 (in-package :cxml)
 
-(defclass klacks:source () ())
+(defclass klacks:source ()
+    (
+     ;; fixme, terrible DTD kludges
+     (internal-declarations)
+     (external-declarations :initform nil)
+     (dom-impl-dtd :initform nil)
+     (dom-impl-entity-resolver :initform nil)))
 
 (defgeneric klacks:close-source (source))
 
@@ -83,7 +89,19 @@
 	  (sax:comment handler a))
 	(:dtd
 	  (sax:start-dtd handler a b c)
-	  (sax:end-dtd handler))
+	  (when (slot-boundp source 'internal-declarations)
+	    (sax:start-internal-subset handler)
+	    (serialize-declaration-kludge
+	     (slot-value source 'internal-declarations)
+	     handler)
+	    (sax:end-internal-subset handler))
+	  (serialize-declaration-kludge
+	   (slot-value source 'external-declarations)
+	   handler)
+	  (sax:end-dtd handler)
+	  (sax:entity-resolver handler
+			       (slot-value source 'dom-impl-entity-resolver))
+	  (sax::dtd handler (slot-value source 'dom-impl-dtd)))
 	(:start-element
 	  (sax:start-element handler a b c (klacks:list-attributes source)))
 	(:end-element
@@ -93,3 +111,8 @@
 	(t
 	  (error "unexpected klacks key: ~A" key)))
       (klacks:consume source))))
+
+(defun serialize-declaration-kludge (list handler)
+  (loop
+      for (fn . args) in list
+      do (apply fn handler args)))



From dlichteblau at common-lisp.net  Sun Feb 18 14:35:16 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 09:35:16 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/test
Message-ID: <20070218143516.8A599120A2@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/test
In directory clnet:/tmp/cvs-serv13701/test

Modified Files:
	xmlconf.lisp 
Log Message:
klacks fixes


--- /project/cxml/cvsroot/cxml/test/xmlconf.lisp	2006/08/20 11:48:58	1.13
+++ /project/cxml/cvsroot/cxml/test/xmlconf.lisp	2007/02/18 14:35:16	1.14
@@ -75,8 +75,19 @@
 		     :if-exists :supersede)
       (run-all-tests directory))))
 
-(defun run-all-tests (directory)
-  (let* ((pathname (merge-pathnames "xmlconf.xml" directory))
+(defvar *parser-fn* 'sax-test)
+
+(defun sax-test (filename handler &rest args)
+  (apply #'cxml:parse-file filename handler :recode nil args))
+
+(defun klacks-test (filename handler &rest args)
+  (klacks:with-open-source
+      (s (apply #'cxml:make-source (pathname filename) args))
+    (klacks:serialize-source s handler)))
+
+(defun run-all-tests (parser-fn directory)
+  (let* ((*parser-fn* parser-fn)
+	 (pathname (merge-pathnames "xmlconf.xml" directory))
          (builder (rune-dom:make-dom-builder))
          (xmlconf (cxml:parse-file pathname builder :recode nil))
          (ntried 0)
@@ -123,10 +134,9 @@
 
 (defmethod run-test ((class null) pathname output description &rest args)
   (declare (ignore description))
-  (let ((document (apply #'cxml:parse-file
+  (let ((document (apply *parser-fn*
                          pathname
                          (rune-dom:make-dom-builder)
-			 :recode nil
                          args)))
     (cond
       ((null output)
@@ -163,10 +173,10 @@
        (handler-case
            (progn
              (format t " [validating:]")
-             (cxml:parse-file pathname
-			      (rune-dom:make-dom-builder)
-			      :recode nil
-			      :validate t)
+             (funcall *parser-fn*
+		      pathname
+		      (rune-dom:make-dom-builder)
+		      :validate t)
              (error "validity error not detected")
              nil)
          (cxml:validity-error ()
@@ -179,10 +189,10 @@
   (handler-case
       (progn
          (format t " [not validating:]")
-	(cxml:parse-file pathname
-			 (rune-dom:make-dom-builder)
-			 :recode nil
-			 :validate nil)
+	(funcall *parser-fn*
+		 pathname
+		 (rune-dom:make-dom-builder)
+		 :validate nil)
 	(error "well-formedness violation not detected")
       nil)
     (cxml:well-formedness-violation ()
@@ -191,10 +201,10 @@
   (handler-case
       (progn
 	(format t " [validating:]")
-	(cxml:parse-file pathname
-			 (rune-dom:make-dom-builder)
-			 :recode nil
-			 :validate t)
+	(funcall *parser-fn*
+		 pathname
+		 (rune-dom:make-dom-builder)
+		 :validate t)
 	(error "well-formedness violation not detected")
       nil)
     (cxml:well-formedness-violation ()
@@ -206,4 +216,9 @@
       t)))
 
 #+(or)
-(xmlconf::run-all-tests "/home/david/2001/XML-Test-Suite/xmlconf/")
+(xmlconf::run-all-tests 'xmlconf::sax-test
+			"/home/david/2001/XML-Test-Suite/xmlconf/")
+
+#+(or)
+(xmlconf::run-all-tests 'xmlconf::klacks-test
+			"/home/david/2001/XML-Test-Suite/xmlconf/")



From dlichteblau at common-lisp.net  Sun Feb 18 15:27:30 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 10:27:30 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/doc
Message-ID: <20070218152730.CAEFE2E1BF@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/doc
In directory clnet:/tmp/cvs-serv24285/doc

Modified Files:
	html.xsl klacks.xml 
Log Message:
new argument :buffering to make-source


--- /project/cxml/cvsroot/cxml/doc/html.xsl	2007/02/18 12:35:50	1.1
+++ /project/cxml/cvsroot/cxml/doc/html.xsl	2007/02/18 15:27:30	1.2
@@ -57,8 +57,8 @@
 	<li>
           <a href="klacks.html">Klacks parser</a>
           <ul class="sub">
-            <li><a href="klacks.html#parsing">Parsing incrementally</a></li>
-            <li><a href="klacks.html#sax">Bridging Klacks and SAX</a></li>
+            <li><a href="klacks.html#sources">Parsing incrementally</a></li>
+            <li><a href="klacks.html#klacksax">Bridging Klacks and SAX</a></li>
           </ul>
         </li>
 	<li>
--- /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 14:35:14	1.2
+++ /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 15:27:30	1.3
@@ -45,7 +45,8 @@
 * <b>(klacks:consume *source*)</b>
 NIL</pre>
 
-    <h3>Klacks sources</h3>
+    <a name="sources"/>
+    <h3>Parsing incrementally using sources</h3>
     <p>
       To parse using Klacks, create an XML <tt>source</tt> first.
     </p>
@@ -96,8 +97,22 @@
       closed otherwise.
     </p>
     <p>
-      <b>Keyword arguments</b> have the same meaning as with the SAX parser,
-      please refer to the documentation of <a
+      <b>Buffering:</b> By default, the Klacks parser performs buffering
+      of octets being read from the stream as an optimization.  This can
+      result in unwanted blocking if the stream is a socket and the
+      parser tries to read more data than required to parse the current
+      event.  Use <tt>:buffering nil</tt> to disable this optimization.
+    </p>
+    <ul>
+      <li>
+        <tt>buffering</tt> -- Boolean, defaults to <tt>t</tt>.  If
+        enabled, read data several kilobytes at time.  If disabled,
+        read only single bytes at a time.
+      </li>
+    </ul>
+    <p>
+      The following <b>keyword arguments</b> have the same meaning as
+      with the SAX parser, please refer to the documentation of <a
       href="sax.html#parser">parse-file</a> for more information:
     </p>
     <ul>
@@ -216,6 +231,7 @@
       exiting <tt>body</tt>, whether normally or abnormally.
     </p>
 
+    <a name="klacksax"/>
     <h3>Bridging Klacks and SAX</h3>
     <p>
       <div class="def">Function KLACKS:SERIALIZE-SOURCE (source handler)</div>



From dlichteblau at common-lisp.net  Sun Feb 18 15:27:31 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 10:27:31 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/klacks
Message-ID: <20070218152731.06CBB2E1C9@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/klacks
In directory clnet:/tmp/cvs-serv24285/klacks

Modified Files:
	klacks-impl.lisp 
Log Message:
new argument :buffering to make-source


--- /project/cxml/cvsroot/cxml/klacks/klacks-impl.lisp	2007/02/18 14:35:15	1.3
+++ /project/cxml/cvsroot/cxml/klacks/klacks-impl.lisp	2007/02/18 15:27:30	1.4
@@ -101,10 +101,12 @@
 (defun make-source
     (input &rest args
      &key validate dtd root entity-resolver disallow-internal-subset
-	  pathname)
+	  (buffering t) pathname)
   (declare (ignore validate dtd root entity-resolver disallow-internal-subset))
   (etypecase input
     (xstream
+      (when (and (not buffering) (< 1 (runes::xstream-speed input)))
+	(warn "make-source called with !buffering, but xstream is buffering"))
       (let ((*ctx* nil))
 	(let ((zstream (make-zstream :input-stack (list input))))
 	  (peek-rune input)
@@ -113,10 +115,10 @@
 		   zstream
 		   (loop
 		       for (name value) on args by #'cddr
-		       unless (eq name :pathname)
+		       unless (member name '(:pathname :buffering))
 		       append (list name value)))))))
     (stream
-      (let ((xstream (make-xstream input)))
+      (let ((xstream (make-xstream input :speed (if buffering 8192 1))))
 	(setf (xstream-name xstream)
 	      (make-stream-name
 	       :entity-name "main document"
@@ -126,7 +128,8 @@
 	(apply #'make-source xstream args)))
     (pathname
       (let* ((xstream
-	      (make-xstream (open input :element-type '(unsigned-byte 8)))))
+	      (make-xstream (open input :element-type '(unsigned-byte 8))
+			    :speed (if buffering 8192 1))))
 	(setf (xstream-name xstream)
 	      (make-stream-name
 	       :entity-name "main document"



From dlichteblau at common-lisp.net  Sun Feb 18 16:46:33 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 11:46:33 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/doc
Message-ID: <20070218164633.0A7F258204@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/doc
In directory clnet:/tmp/cvs-serv3570/doc

Modified Files:
	html.xsl klacks.xml 
Log Message:
find-element, find-event


--- /project/cxml/cvsroot/cxml/doc/html.xsl	2007/02/18 15:27:30	1.2
+++ /project/cxml/cvsroot/cxml/doc/html.xsl	2007/02/18 16:46:32	1.3
@@ -58,7 +58,9 @@
           <a href="klacks.html">Klacks parser</a>
           <ul class="sub">
             <li><a href="klacks.html#sources">Parsing incrementally</a></li>
+            <li><a href="klacks.html#convenience">Convenience functions</a></li>
             <li><a href="klacks.html#klacksax">Bridging Klacks and SAX</a></li>
+            <li><a href="klacks.html#klacksax">Examples</a></li>
           </ul>
         </li>
 	<li>
--- /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 15:27:30	1.3
+++ /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 16:46:32	1.4
@@ -16,34 +16,9 @@
       support, entity resolution) while offering a more flexible interface
       than SAX.
     </p>
-
-    <h3>Example</h3>
     <p>
-      The following example illustrates creation of a klacks <tt>source</tt>,
-      use of the <tt>consume</tt> function to read individual events,
-      and shows some of the most common event types.
+      See below for <a href="#examples">examples</a>.
     </p>
-    <pre>* <b>(defparameter *source* (cxml:make-source "&lt;example>text&lt;/example>"))</b>
-*SOURCE*
-* <b>(klacks:consume *source*)</b>
-:START-DOCUMENT
-* <b>(klacks:consume *source*)</b>
-:START-ELEMENT
-NIL                      ;namespace URI
-"example"                ;local name
-"example"                ;qualified name
-* <b>(klacks:consume *source*)</b>
-:CHARACTERS
-"text"
-* <b>(klacks:consume *source*)</b>
-:END-ELEMENT
-NIL
-"example"
-"example"
-* <b>(klacks:consume *source*)</b>
-:END-DOCUMENT
-* <b>(klacks:consume *source*)</b>
-NIL</pre>
 
     <a name="sources"/>
     <h3>Parsing incrementally using sources</h3>
@@ -161,11 +136,11 @@
       <tt>peek</tt> returns the current event's key and main values.
     </p>
     <p>
-      <div class="def">Function KLACKS:CONSUME (source) => key, value*</div>
+      <div class="def">Function KLACKS:PEEK-NEXT (source) => key, value*</div>
     </p>
     <p>
-      Return the same values <tt>peek</tt> would, and in addition
-      advance the source forward to the next event.
+      Advance the source forward to the next event and returns it
+      like <tt>peek</tt> would.
     </p>
     <p>
       <div class="def">Function KLACKS:PEEK-VALUE (source) => value*</div>
@@ -174,6 +149,13 @@
       Like <tt>peek</tt>, but return only the values, not the key.
     </p>
     <p>
+      <div class="def">Function KLACKS:CONSUME (source) => key, value*</div>
+    </p>
+    <p>
+      Return the same values <tt>peek</tt> would, and in addition
+      advance the source forward to the next event.
+    </p>
+    <p>
       <div class="def">Function KLACKS:CURRENT-URI (source) => uri</div>
       <div class="def">Function KLACKS:CURRENT-LNAME (source) => string</div>
       <div class="def">Function KLACKS:CURRENT-QNAME (source) => string</div>
@@ -231,11 +213,124 @@
       exiting <tt>body</tt>, whether normally or abnormally.
     </p>
 
+    <a name="convenience"/>
+    <h3>Convenience functions</h3>
+    <p>
+      <div class="def">Function KLACKS:FIND-EVENT (source key)</div>
+      Read events from <tt>source</tt> and discard them until an event
+      of type <i>key</i> is found.  Return values like <tt>peek</tt>, or
+      NIL if no such event was found.
+    </p>
+    <p>
+      <div class="def">Function KLACKS:FIND-ELEMENT (source &amp;optional
+      lname uri)</div>
+      Read events from <tt>source</tt> and discard them until an event
+      of type :start-element is found with matching local name and
+      namespace uri is found.   If <tt>lname</tt> is <tt>nil</tt>, any
+      tag name matches.  If <tt>uri</tt> is <tt>nil</tt>, any
+      namespace matches. Return values like <tt>peek</tt> or NIL if no
+      such event was found.
+    </p>
+
     <a name="klacksax"/>
     <h3>Bridging Klacks and SAX</h3>
     <p>
+      <div class="def">Function KLACKS:SERIALIZE-EVENT (source handler)</div>
+      Send the current klacks events from <tt>source</tt> as a SAX
+      events to the SAX <tt>handler</tt> and consume it.
+    </p>
+    <p>
+      <div class="def">Function KLACKS:SERIALIZE-ELEMENT (source handler
+      &amp;key document-events)</div>
+      Read all klacks events from the following <tt>:start-element</tt> to
+      its <tt>:end-element</tt> and send them as SAX events
+      to <tt>handler</tt>.  When this function is called, the current
+      event must be <tt>:start-element</tt>, else an error is
+      signalled.  With <tt>document-events</tt> (the default),
+      <tt>sax:start-document</tt> and <tt>sax:end-document</tt> events
+      are sent around the element.
+    </p>
+    <p>
       <div class="def">Function KLACKS:SERIALIZE-SOURCE (source handler)</div>
       Read all klacks events from <tt>source</tt> and send them as SAX
       events to the SAX <tt>handler</tt>.
     </p>
+
+    <a name="examples"/>
+    <h3>Examples</h3>
+    <p>
+      The following example illustrates creation of a klacks <tt>source</tt>,
+      use of the <tt>peek-next</tt> function to read individual events,
+      and shows some of the most common event types.
+    </p>
+    <pre>* <b>(defparameter *source* (cxml:make-source "&lt;example>text&lt;/example>"))</b>
+*SOURCE*
+
+* <b>(klacks:peek-next *source*)</b>
+:START-DOCUMENT
+
+* <b>(klacks:peek-next *source*)</b>
+:START-ELEMENT
+NIL                      ;namespace URI
+"example"                ;local name
+"example"                ;qualified name
+
+* <b>(klacks:peek-next *source*)</b>
+:CHARACTERS
+"text"
+
+* <b>(klacks:peek-next *source*)</b>
+:END-ELEMENT
+NIL
+"example"
+"example"
+
+* <b>(klacks:peek-next *source*)</b>
+:END-DOCUMENT
+
+* <b>(klacks:peek-next *source*)</b>
+NIL</pre>
+
+    <p>
+      In this example, <tt>find-element</tt> is used to skip over the
+      uninteresting events until the opening <tt>child1</tt> tag is
+      found.  Then <tt>serialize-element</tt> is used to generate SAX
+      events for the following element, including its children, and an
+      xmls-compatible list structure is build from those
+      events.  <tt>find-element</tt> skips over whitespace,
+      and <tt>find-event</tt> is used to parse up
+      to <tt>:end-document</tt>, ensuring that the source has been
+      closed.
+    </p>
+    <pre>* <b>(defparameter *source*
+      (cxml:make-source "&lt;example>
+                           &lt;child1>&lt;p>foo&lt;/p>&lt;/child1>
+                           &lt;child2 bar='baz'/>
+                         &lt;/example>"))</b>
+*SOURCE*
+
+* <b>(klacks:find-element *source* "child1")</b>
+:START-ELEMENT
+NIL
+"child1"
+"child1"
+
+* <b>(klacks:serialize-element *source* (cxml-xmls:make-xmls-builder))</b>
+("child1" NIL ("p" NIL "foo"))
+
+* <b>(klacks:find-element *source*)</b>
+:START-ELEMENT
+NIL
+"child2"
+"child2"
+
+*  <b>(klacks:serialize-element *source* (cxml-xmls:make-xmls-builder))</b>
+("child2" (("bar" "baz")))
+
+* <b>(klacks:find-event *source* :end-document)</b>
+:END-DOCUMENT
+NIL
+NIL
+NIL
+</pre>
 </documentation>



From dlichteblau at common-lisp.net  Sun Feb 18 16:46:33 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 11:46:33 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/klacks
Message-ID: <20070218164633.469675C000@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/klacks
In directory clnet:/tmp/cvs-serv3570/klacks

Modified Files:
	klacks-impl.lisp klacks.lisp package.lisp 
Log Message:
find-element, find-event


--- /project/cxml/cvsroot/cxml/klacks/klacks-impl.lisp	2007/02/18 15:27:30	1.4
+++ /project/cxml/cvsroot/cxml/klacks/klacks-impl.lisp	2007/02/18 16:46:33	1.5
@@ -79,6 +79,12 @@
     (fill-source source)
     (apply #'values current-values)))
 
+(defmethod klacks:peek-next ((source cxml-source))
+  (with-source (source current-key current-values)
+    (setf current-key nil)
+    (fill-source source)
+    (apply #'values current-key current-values)))
+
 (defmethod klacks:consume ((source cxml-source))
   (with-source (source current-key current-values)
     (fill-source source)
--- /project/cxml/cvsroot/cxml/klacks/klacks.lisp	2007/02/18 14:35:15	1.2
+++ /project/cxml/cvsroot/cxml/klacks/klacks.lisp	2007/02/18 16:46:33	1.3
@@ -69,9 +69,9 @@
     (check-type key (member :characters))
     characters))
 
-(defun klacks:serialize-source (source handler)
-  (loop
-    (multiple-value-bind (key a b c) (klacks:peek source)
+(defun klacks:serialize-event (source handler)
+  (multiple-value-bind (key a b c) (klacks:peek source)
+    (let ((result nil))
       (case key
 	(:start-document
 	  (sax:start-document handler))
@@ -107,12 +107,66 @@
 	(:end-element
 	  (sax:end-element handler a b c))
 	(:end-document
-	  (return (sax:end-document handler)))
+	  (setf result (sax:end-document handler)))
+	((nil)
+	  (error "serialize-event read past end of document"))
 	(t
 	  (error "unexpected klacks key: ~A" key)))
-      (klacks:consume source))))
+      (klacks:consume source)
+      result)))
 
 (defun serialize-declaration-kludge (list handler)
   (loop
       for (fn . args) in list
       do (apply fn handler args)))
+
+(defun klacks:serialize-source (source handler)
+  (loop
+    (let ((document (klacks:serialize-event source handler)))
+      (when document
+	(return document)))))
+
+(defun klacks:serialize-element (source handler &key (document-events t))
+  (unless (eq (klacks:peek source) :start-element)
+    (error "not at start of element"))
+  (when document-events
+    (sax:start-document handler))
+  (labels ((recurse ()
+	     (klacks:serialize-event source handler)
+	     (loop
+	       (let ((key (klacks:peek source)))
+		 (ecase key
+		   (:start-element (recurse))
+		   (:end-element (return))
+		   ((:characters :comment :processing-instruction)
+		     (klacks:serialize-event source handler)))))
+	     (klacks:serialize-event source handler)))
+    (recurse))
+  (when document-events
+    (sax:end-document handler)))
+
+(defun klacks:find-element (source &optional lname uri)
+  (loop
+    (multiple-value-bind (key current-uri current-lname current-qname)
+	(klacks:peek-next source)
+      (case key
+	((nil)
+	  (return nil))
+	(:start-element
+	  (when (and (eq key :start-element)
+		     (or (null lname)
+			 (equal lname (klacks:current-lname source)))
+		     (or (null uri)
+			 (equal uri (klacks:current-uri source))))
+	    (return
+	      (values key current-uri current-lname current-qname))))))))
+
+(defun klacks:find-event (source key)
+  (loop
+    (multiple-value-bind (this a b c)
+	(klacks:peek-next source)
+      (cond
+	((null this)
+	  (return nil))
+	((eq this key)
+	  (return (values this a b c)))))))
--- /project/cxml/cvsroot/cxml/klacks/package.lisp	2007/02/11 18:21:21	1.1
+++ /project/cxml/cvsroot/cxml/klacks/package.lisp	2007/02/18 16:46:33	1.2
@@ -24,6 +24,11 @@
 
 	   #:peek
 	   #:peek-value
+	   #:peek-next
+	   #:consume
+
+	   #:find-element
+	   #:find-event
 
 	   #:map-attributes
 	   #:list-attributes
@@ -33,6 +38,6 @@
 	   #:current-characters
 	   #:current-cdata-section-p
 	   
-	   #:consume
-
+	   #:serialize-event
+	   #:serialize-element
 	   #:serialize-source))



From dlichteblau at common-lisp.net  Sun Feb 18 16:50:53 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 11:50:53 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/doc
Message-ID: <20070218165053.91E6B61026@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/doc
In directory clnet:/tmp/cvs-serv4173

Modified Files:
	index.xml 
Log Message:
release


--- /project/cxml/cvsroot/cxml/doc/index.xml	2007/02/18 12:35:50	1.1
+++ /project/cxml/cvsroot/cxml/doc/index.xml	2007/02/18 16:50:53	1.2
@@ -50,7 +50,7 @@
 
     <a name="changes"/>
     <h2>Recent Changes</h2>
-    <p class="nomargin"><tt>rel-2007-xx-yy</tt></p>
+    <p class="nomargin"><tt>rel-2007-02-18</tt></p>
     <ul class="nomargin">
       <li>New StAX-like parser interface.</li>
       <li>Serialization fixes (thanks to Nathan Bird, Donavon Keithley).</li>



From dlichteblau at common-lisp.net  Sun Feb 18 17:30:52 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 12:30:52 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/doc
Message-ID: <20070218173052.D6A301A09B@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/doc
In directory clnet:/tmp/cvs-serv11705

Modified Files:
	klacks.xml 
Log Message:
typo


--- /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 16:46:32	1.4
+++ /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 17:30:52	1.5
@@ -236,8 +236,8 @@
     <h3>Bridging Klacks and SAX</h3>
     <p>
       <div class="def">Function KLACKS:SERIALIZE-EVENT (source handler)</div>
-      Send the current klacks events from <tt>source</tt> as a SAX
-      events to the SAX <tt>handler</tt> and consume it.
+      Send the current klacks event from <tt>source</tt> as a SAX
+      event to the SAX <tt>handler</tt> and consume it.
     </p>
     <p>
       <div class="def">Function KLACKS:SERIALIZE-ELEMENT (source handler



From dlichteblau at common-lisp.net  Sun Feb 18 17:35:37 2007
From: dlichteblau at common-lisp.net (dlichteblau)
Date: Sun, 18 Feb 2007 12:35:37 -0500 (EST)
Subject: [cxml-cvs] CVS cxml/doc
Message-ID: <20070218173537.752661E003@common-lisp.net>

Update of /project/cxml/cvsroot/cxml/doc
In directory clnet:/tmp/cvs-serv12078

Modified Files:
	klacks.xml 
Log Message:
typo


--- /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 17:30:52	1.5
+++ /project/cxml/cvsroot/cxml/doc/klacks.xml	2007/02/18 17:35:37	1.6
@@ -296,7 +296,7 @@
       uninteresting events until the opening <tt>child1</tt> tag is
       found.  Then <tt>serialize-element</tt> is used to generate SAX
       events for the following element, including its children, and an
-      xmls-compatible list structure is build from those
+      xmls-compatible list structure is built from those
       events.  <tt>find-element</tt> skips over whitespace,
       and <tt>find-event</tt> is used to parse up
       to <tt>:end-document</tt>, ensuring that the source has been