From banderson at common-lisp.net Tue Feb 7 16:09:23 2006
From: banderson at common-lisp.net (banderson at common-lisp.net)
Date: Tue, 7 Feb 2006 10:09:23 -0600 (CST)
Subject: [cl-xml-cvs] r1 - branches tags trunk
Message-ID: <20060207160923.185BA7600D@common-lisp.net>
Author: banderson
Date: Tue Feb 7 10:09:22 2006
New Revision: 1
Added:
branches/
tags/
trunk/
Log:
basic repos structure
From banderson at common-lisp.net Wed Feb 8 23:58:17 2006
From: banderson at common-lisp.net (banderson at common-lisp.net)
Date: Wed, 8 Feb 2006 17:58:17 -0600 (CST)
Subject: [cl-xml-cvs] r3 - tags/0.918
Message-ID: <20060208235817.8ED7C7400B@common-lisp.net>
Author: banderson
Date: Wed Feb 8 17:58:17 2006
New Revision: 3
Added:
tags/0.918/
- copied from r2, trunk/
Log:
tagging the 0.918 release
From banderson at common-lisp.net Mon Feb 13 19:05:26 2006
From: banderson at common-lisp.net (banderson at common-lisp.net)
Date: Mon, 13 Feb 2006 13:05:26 -0600 (CST)
Subject: [cl-xml-cvs] r5 - branches/sbcl-0.9.x-testing
Message-ID: <20060213190526.AB2574A083@common-lisp.net>
Author: banderson
Date: Mon Feb 13 13:05:26 2006
New Revision: 5
Added:
branches/sbcl-0.9.x-testing/
- copied from r4, trunk/
Log:
start branch for getting SBCL to compile/load the lib
From banderson at common-lisp.net Tue Feb 14 16:32:23 2006
From: banderson at common-lisp.net (banderson at common-lisp.net)
Date: Tue, 14 Feb 2006 10:32:23 -0600 (CST)
Subject: [cl-xml-cvs] r6 - branches/sbcl-0.9.x-testing
Message-ID: <20060214163223.325AE5000E@common-lisp.net>
Author: banderson
Date: Tue Feb 14 10:32:22 2006
New Revision: 6
Removed:
branches/sbcl-0.9.x-testing/define-system.lisp
Log:
some re-arranging from old releases
From banderson at common-lisp.net Tue Feb 14 16:32:37 2006
From: banderson at common-lisp.net (banderson at common-lisp.net)
Date: Tue, 14 Feb 2006 10:32:37 -0600 (CST)
Subject: [cl-xml-cvs] r7 - branches/sbcl-0.9.x-testing/atn-parser
Message-ID: <20060214163237.995CC5000E@common-lisp.net>
Author: banderson
Date: Tue Feb 14 10:32:37 2006
New Revision: 7
Removed:
branches/sbcl-0.9.x-testing/atn-parser/
Log:
some re-arranging from old releases
From banderson at common-lisp.net Tue Feb 14 17:52:43 2006
From: banderson at common-lisp.net (banderson at common-lisp.net)
Date: Tue, 14 Feb 2006 11:52:43 -0600 (CST)
Subject: [cl-xml-cvs] r8 - in branches/sbcl-0.9.x-testing/code: atn-parser
xparser xquerydatamodel
Message-ID: <20060214175243.205F27D010@common-lisp.net>
Author: banderson
Date: Tue Feb 14 11:52:41 2006
New Revision: 8
Modified:
branches/sbcl-0.9.x-testing/code/atn-parser/ebnf-tokenizer.lisp
branches/sbcl-0.9.x-testing/code/xparser/xml-printer.lisp
branches/sbcl-0.9.x-testing/code/xparser/xml-stream-coding.lisp
branches/sbcl-0.9.x-testing/code/xquerydatamodel/xqdm-classes.lisp
Log:
some re-arranging from old releases
Modified: branches/sbcl-0.9.x-testing/code/atn-parser/ebnf-tokenizer.lisp
==============================================================================
--- branches/sbcl-0.9.x-testing/code/atn-parser/ebnf-tokenizer.lisp (original)
+++ branches/sbcl-0.9.x-testing/code/atn-parser/ebnf-tokenizer.lisp Tue Feb 14 11:52:41 2006
@@ -1 +1,553 @@
-;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: bnf-parser; -*-
#|
added ',' and '->' to grammar
explicit quoted string reader
productions id for [[#]]
fixed incorrect readers for square brackets
readtable mods as function
fixed premature termination bug in comment-reader
corrected eof errors in [,] readers
modified // comment reader to recognize both (CR LF) newline forms
|#
(in-package "BNF-PARSER")
(defparameter *bnf-readtable* (copy-readtable nil))
(defparameter *ansi-cl-readtable* (copy-readtable nil))
(defparameter *metasymbols*
'(|\|| * ? + - |)| |(| |'| |::=| |#[| |^| |[| |[[| |]| |]]| |/*| |/**| |//| |*/| \; \, |->| |{| |}| |'(|
)
"nb. all metasymbols must appear here. any other text is coerced to a string.
they must also be correctly categorized in ebnf-grammar.atn. anything else
will aslo be treated as a symbol.")
(defun defsymbol-reader (stream char)
(declare (ignore char))
(set-macro-character #\: #'(lambda (s c) (declare (ignore s c)))
nil
*bnf-readtable*)
(read-char stream)
(read-char stream)
(set-macro-character #\: #'defsymbol-reader nil *bnf-readtable*)
'|::=| )
(defun \'reader (stream term-char)
(coerce (loop for char = (read-char stream)
until (eql char term-char)
collect (if (eql char #\\) (read-char stream) char))
'string))
(defun [reader (stream char)
(declare (ignore char))
(cond ((char= #\[ (peek-char nil stream nil nil))
(read-char stream)
'[[)
(t '[)))
(defun ]reader (stream char)
(declare (ignore char))
(cond ((char= #\] (peek-char nil stream nil nil))
(read-char stream)
']])
(t '])))
(defun \#reader (stream char)
(set-macro-character #\[ #'(lambda (s c) (declare (ignore s c)) #\[)
nil
*bnf-readtable*)
(prog1
(cond ((eql (peek-char nil stream nil nil) #\[)
(read-char stream)
'|#[|)
((eql (peek-char nil stream nil nil) #\')
#\#)
(t (read-number-string stream char)))
(set-macro-character #\[ #'[reader nil *bnf-readtable*)))
(defun /reader (stream char)
(cond ((char= (peek-char nil stream nil nil) #\/)
(read-char stream)
(let ((char nil))
(loop (unless (setf char (read-char stream nil nil)) (return))
(when (member char '(#\return #\linefeed)) (return)))
:comment))
((char= (peek-char nil stream nil nil) #\*)
(read-comment-string stream)
:comment)
(t char)))
(defun read-comment-string (stream &aux (output (make-string-output-stream)))
(write-char #\/ output)
(write-char (read-char stream) output)
(loop with dispatch-char
for char = (read-char stream nil nil)
while char
do (cond ((and dispatch-char (char= #\/ char))
(write-char char output)
(return-from read-comment-string (get-output-stream-string output)))
((char= char #\*) (setf dispatch-char t))
(t (setf dispatch-char nil)))
(write-char char output)))
(defun read-number-string (stream char &aux (output (make-string-output-stream)))
(let ((*readtable* (copy-readtable nil)))
(set-syntax-from-char #\- #\a *readtable*)
(set-syntax-from-char #\# #\a *readtable*)
(write-char char output)
(do ((i 0 (1+ i))
(nc (peek-char nil stream nil nil)
(peek-char nil stream nil nil)))
((or (null nc) (member nc '(#\] #\- #\space)))
(get-output-stream-string output))
(write-char (read-char stream) output))))
(defun -reader (stream char)
(declare (ignore char))
(let ((next (peek-char nil stream nil nil)))
(if (eql next #\>)
(progn (read-char stream) '|->|)
'-)))
(defun initialize-bnf-readtable (readtable)
(flet ((char-name-reader (name)
#'(lambda (stream char)
(declare (ignore stream char))
name)))
(if (fboundp 'readtable-case) (setf (readtable-case readtable) :preserve))
(set-macro-character #\| (char-name-reader '\|) nil readtable)
(set-macro-character #\* (char-name-reader '*) nil readtable)
(set-macro-character #\? (char-name-reader '?) nil readtable)
(set-macro-character #\+ (char-name-reader '+) nil readtable)
(set-macro-character #\( (char-name-reader '\() nil readtable)
(set-macro-character #\) (char-name-reader '\)) nil readtable)
(set-macro-character #\- #'-reader nil readtable)
(set-macro-character #\^ (char-name-reader '\^) nil readtable)
(set-macro-character #\[ '[reader nil readtable)
(set-macro-character #\] ']reader nil readtable)
(set-macro-character #\{ (char-name-reader '\{) nil readtable)
(set-macro-character #\} (char-name-reader '\}) nil readtable)
(set-macro-character #\# #'\#reader nil readtable)
(set-macro-character #\, (char-name-reader '\,) nil readtable)
(set-macro-character #\: #'defsymbol-reader nil readtable)
(set-macro-character #\; (char-name-reader '\;) nil readtable)
;; (set-syntax-from-char #\/ #\" readtable)
(set-macro-character #\/ #'/reader nil readtable)
(set-syntax-from-char #\" #\a readtable)
;; 20010301.jaa reinstated
(set-syntax-from-char #\# #\a readtable)
;; 20010605.ms (set-syntax-from-char #\' #\" readtable)
(set-macro-character #\' '\'reader nil readtable)
;; 20010122.jaa
(set-macro-character #\. (char-name-reader '\.) nil readtable)
))
(initialize-bnf-readtable *bnf-readtable*)
(defun bnf-reader (bnf-str &aux (*readtable* *bnf-readtable*)
#+:aclpc (allegro::*read-case* :leave))
(loop with bnf-length = (length bnf-str)
with open-range
with tokens
with start = 0
if (< start bnf-length)
do
(multiple-value-bind (expr end)
(read-from-string bnf-str nil nil :start start)
;; (print expr)
(cond ((null expr)
(return-from bnf-reader (nreverse tokens)))
((eq expr :comment)
(setf start end))
(t
(cond ((member expr *metasymbols*)
(cond ((eq expr '\[) (setf open-range t))
((eq expr '\]) (setf open-range nil)))
(push expr tokens))
((stringp expr) ;; terminale
(cond ((and (> (length expr) 0) (char= (char expr 0) #\#) ;; leave non-hex as string
(not (find-if #'(lambda (c) (not (digit-char-p c 16))) expr)))
(cond (open-range
;; Range ohne terminale delimiter
(push expr tokens))
(t (push '\' tokens)
;; the originl pushed a number ?
;; (push (hex-string-to-number expr) tokens)
(push (make-string 1 :initial-element (code-char (hex-string-to-number expr))) tokens)
(push '\' tokens))))
(t (push '\' tokens)
(push expr tokens)
(push '\' tokens))))
((numberp expr)
(push (format nil "~A" expr) tokens))
(t (push (string expr) tokens)))
(setf start end))))
else return (nreverse tokens)))
(defun hex-string-to-number (expr)
(let ((*readtable* *ansi-cl-readtable*))
(read-from-string expr)))
(defun alternative-chars (str)
(format nil "~{'~A'~^ | ~}" (coerce str 'list)))
(defun sequence-chars (str)
(format nil "~{'~A'~^ ~}" (coerce str 'list)))
(defmethod hexstring ((object character))
(let ((*print-base* 16))
(format nil "#x~A" (char-code object))))
#|
(hexstring #\a)
(alternative-chars "adfa")
(sequence-chars "adf")
(bnf-reader "[a b c]")
(defun hex-string-to-char (expr)
(let ((*readtable* *ansi-cl-readtable*))
(code-char (read-from-string expr))))
(defun read-number-string (stream char &aux (output (make-string-output-stream)))
(write-char char output)
(let ((*readtable* (copy-readtable nil)))
(set-syntax-from-char #\- #\a *readtable*)
(loop
for nc = (peek-char nil stream nil nil)
for i from 0
while (and nc (char/= nc #\] #\- #\# #\space))
do (write-char (read-char stream) output))
(get-output-stream-string output)))
;; Beispiele
(bnf-reader "// doc Dies
s ::= /* comment */ 'a'")
;; note the escaping form when evaluating tests strings ...
(bnf-reader "SingleQuote ::= '\\'' ")
(bnf-reader "DoubleQuote ::= '\"' ")
(bnf-to-atn
(bnf-object-tree
(caar (callparser 'ebnf
(bnf-reader "root ::= cell+ cell ::= [2,3 -> 'foo']")))))
(bnf-to-atn
(bnf-object-tree
(caar (callparser 'ebnf
(bnf-reader "s ::= #[print foo] [^#xd-#xh] | [^#x45#x45] | [#x45-#x65] #[print a]")))))
(write-source
(bnf-to-atn
"test ::= 'a' range '.' range ::= [a-z] | [^U-Z]")
"TestParser")
;;; #[print a]
;;; terminal-delimiter ::= '''
(bnf-object-tree
(callparser 'ebnf
(bnf-reader
"ebnf ::= definition+
definition ::= symbol defsymbol rhs
rhs ::= qexpr+ | alternative
qexpr ::= (symbol | group) occurrence?
group ::= leftpar (qexpr+ | alternative) rightpar
alternative ::= qexpr oneof (qexpr | alternative)
symbol ::= terminal | nonterminal
nonterminal ::= token
terminal ::= terminal-delimiter token terminal-delimiter
leftpar ::= '('
rightpar ::= ')'
oneof ::= '|'
defsymbol ::= '::='
occurrence ::= '+' | '*' | '?'") ) )
|#
\ No newline at end of file
+;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: bnf-parser; -*-
+
+
+
+#|
+
+
+
+
+
+
+
+ added ',' and '->' to grammar
+
+ explicit quoted string reader
+
+ productions id for [[#]]
+
+ fixed incorrect readers for square brackets
+
+ readtable mods as function
+
+ fixed premature termination bug in comment-reader
+
+
+
+
+
+|#
+
+
+
+(in-package "BNF-PARSER")
+
+
+
+(defparameter *bnf-readtable* (copy-readtable nil))
+
+(defparameter *ansi-cl-readtable* (copy-readtable nil))
+
+(defparameter *metasymbols*
+
+ '(|\|| * ? + - |)| |(| |'| |::=| |#[| |^| |[| |[[| |]| |]]| |/*| |/**| |//| |*/| \; \, |->| |{| |}| |'(|
+
+ )
+
+ "nb. all metasymbols must appear here. any other text is coerced to a string.
+
+ they must also be correctly categorized in ebnf-grammar.atn. anything else
+
+ will aslo be treated as a symbol.")
+
+
+
+(defun defsymbol-reader (stream char)
+
+ (declare (ignore char))
+
+ (set-macro-character #\: #'(lambda (s c) (declare (ignore s c)))
+
+ nil
+
+ *bnf-readtable*)
+
+ (read-char stream)
+
+ (read-char stream)
+
+ (set-macro-character #\: #'defsymbol-reader nil *bnf-readtable*)
+
+ '|::=| )
+
+
+
+(defun \'reader (stream term-char)
+
+ (coerce (loop for char = (read-char stream)
+
+ until (eql char term-char)
+
+ collect (if (eql char #\\) (read-char stream) char))
+
+ 'string))
+
+
+
+(defun [reader (stream char)
+
+ (declare (ignore char))
+
+ (cond ((char= #\[ (peek-char nil stream))
+
+ (read-char stream)
+
+ '[[)
+
+ (t '[)))
+
+
+
+(defun ]reader (stream char)
+
+ (declare (ignore char))
+
+ (cond ((char= #\] (peek-char nil stream))
+
+ (read-char stream)
+
+ ']])
+
+ (t '])))
+
+
+
+(defun \#reader (stream char)
+
+ (set-macro-character #\[ #'(lambda (s c) (declare (ignore s c)) #\[)
+
+ nil
+
+ *bnf-readtable*)
+
+ (prog1
+
+ (cond ((eql (peek-char nil stream nil nil) #\[)
+
+ (read-char stream)
+
+ '|#[|)
+
+ ((eql (peek-char nil stream nil nil) #\')
+
+ #\#)
+
+ (t (read-number-string stream char)))
+
+ (set-macro-character #\[ #'[reader nil *bnf-readtable*)))
+
+
+
+(defun /reader (stream char)
+
+ (cond ((char= (peek-char nil stream nil nil) #\/)
+
+ (read-char stream)
+
+ (let ((*readtable* *ansi-cl-readtable*))
+
+ (read-line stream)
+
+ :comment))
+
+ ((char= (peek-char nil stream nil nil) #\*)
+
+ (read-comment-string stream)
+
+ :comment)
+
+ (t char)))
+
+
+
+(defun read-comment-string (stream &aux (output (make-string-output-stream)))
+
+ (write-char #\/ output)
+
+ (write-char (read-char stream) output)
+
+ (loop with dispatch-char
+
+ for char = (read-char stream nil nil)
+
+ while char
+
+ do (cond ((and dispatch-char (char= #\/ char))
+
+ (write-char char output)
+
+ (return-from read-comment-string (get-output-stream-string output)))
+
+ ((char= char #\*) (setf dispatch-char t))
+
+ (t (setf dispatch-char nil)))
+
+ (write-char char output)))
+
+
+
+(defun read-number-string (stream char &aux (output (make-string-output-stream)))
+
+ (let ((*readtable* (copy-readtable nil)))
+
+ (set-syntax-from-char #\- #\a *readtable*)
+
+ (set-syntax-from-char #\# #\a *readtable*)
+
+ (write-char char output)
+
+ (do ((i 0 (1+ i))
+
+ (nc (peek-char nil stream nil nil)
+
+ (peek-char nil stream nil nil)))
+
+ ((or (null nc) (member nc '(#\] #\- #\space)))
+
+ (get-output-stream-string output))
+
+ (write-char (read-char stream) output))))
+
+
+
+(defun -reader (stream char)
+
+ (declare (ignore char))
+
+ (let ((next (peek-char nil stream nil nil)))
+
+ (if (eql next #\>)
+
+ (progn (read-char stream) '|->|)
+
+ '-)))
+
+
+
+(defun initialize-bnf-readtable (readtable)
+
+ (flet ((char-name-reader (name)
+
+ #'(lambda (stream char)
+
+ (declare (ignore stream char))
+
+ name)))
+
+ (if (fboundp 'readtable-case) (setf (readtable-case readtable) :preserve))
+
+ (set-macro-character #\| (char-name-reader '\|) nil readtable)
+
+ (set-macro-character #\* (char-name-reader '*) nil readtable)
+
+ (set-macro-character #\? (char-name-reader '?) nil readtable)
+
+ (set-macro-character #\+ (char-name-reader '+) nil readtable)
+
+ (set-macro-character #\( (char-name-reader '\() nil readtable)
+
+ (set-macro-character #\) (char-name-reader '\)) nil readtable)
+
+ (set-macro-character #\- #'-reader nil readtable)
+
+ (set-macro-character #\^ (char-name-reader '\^) nil readtable)
+
+ (set-macro-character #\[ '[reader nil readtable)
+
+ (set-macro-character #\] ']reader nil readtable)
+
+ (set-macro-character #\{ (char-name-reader '\{) nil readtable)
+
+ (set-macro-character #\} (char-name-reader '\}) nil readtable)
+
+ (set-macro-character #\# #'\#reader nil readtable)
+
+ (set-macro-character #\, (char-name-reader '\,) nil readtable)
+
+ (set-macro-character #\: #'defsymbol-reader nil readtable)
+
+ (set-macro-character #\; (char-name-reader '\;) nil readtable)
+
+ ;; (set-syntax-from-char #\/ #\" readtable)
+
+ (set-macro-character #\/ #'/reader nil readtable)
+
+ (set-syntax-from-char #\" #\a readtable)
+
+ ;; 20010301.jaa reinstated
+
+ (set-syntax-from-char #\# #\a readtable)
+
+ ;; 20010605.ms (set-syntax-from-char #\' #\" readtable)
+
+ (set-macro-character #\' '\'reader nil readtable)
+
+ ;; 20010122.jaa
+
+ (set-macro-character #\. (char-name-reader '\.) nil readtable)
+
+ ))
+
+
+
+(initialize-bnf-readtable *bnf-readtable*)
+
+
+
+
+
+(defun bnf-reader (bnf-str &aux (*readtable* *bnf-readtable*)
+
+ #+:aclpc (allegro::*read-case* :leave))
+
+ (loop with bnf-length = (length bnf-str)
+
+ with open-range
+
+ with tokens
+
+ with start = 0
+
+ if (< start bnf-length)
+
+ do
+
+ (multiple-value-bind (expr end)
+
+ (read-from-string bnf-str nil nil :start start)
+
+ ;; (print expr)
+
+ (cond ((null expr)
+
+ (return-from bnf-reader (nreverse tokens)))
+
+ ((eq expr :comment)
+
+ (setf start end))
+
+ (t
+
+ (cond ((member expr *metasymbols*)
+
+ (cond ((eq expr '\[) (setf open-range t))
+
+ ((eq expr '\]) (setf open-range nil)))
+
+ (push expr tokens))
+
+ ((stringp expr) ;; terminale
+
+ (cond ((and (> (length expr) 0) (char= (char expr 0) #\#) ;; leave non-hex as string
+
+ (not (find-if #'(lambda (c) (not (digit-char-p c 16))) expr)))
+
+ (cond (open-range
+
+ ;; Range ohne terminale delimiter
+
+ (push expr tokens))
+
+ (t (push '\' tokens)
+
+ ;; the originl pushed a number ?
+
+ ;; (push (hex-string-to-number expr) tokens)
+
+ (push (make-string 1 :initial-element (code-char (hex-string-to-number expr))) tokens)
+
+ (push '\' tokens))))
+
+ (t (push '\' tokens)
+
+ (push expr tokens)
+
+ (push '\' tokens))))
+
+ ((numberp expr)
+
+ (push (format nil "~A" expr) tokens))
+
+ (t (push (string expr) tokens)))
+
+ (setf start end))))
+
+ else return (nreverse tokens)))
+
+
+
+(defun hex-string-to-number (expr)
+
+ (let ((*readtable* *ansi-cl-readtable*))
+
+ (read-from-string expr)))
+
+
+
+(defun alternative-chars (str)
+
+ (format nil "~{'~A'~^ | ~}" (coerce str 'list)))
+
+
+
+(defun sequence-chars (str)
+
+ (format nil "~{'~A'~^ ~}" (coerce str 'list)))
+
+
+
+(defmethod hexstring ((object character))
+
+ (let ((*print-base* 16))
+
+ (format nil "#x~A" (char-code object))))
+
+
+
+#|
+
+(hexstring #\a)
+
+(alternative-chars "adfa")
+
+(sequence-chars "adf")
+
+(bnf-reader "[a b c]")
+
+(defun hex-string-to-char (expr)
+
+ (let ((*readtable* *ansi-cl-readtable*))
+
+ (code-char (read-from-string expr))))
+
+
+
+(defun read-number-string (stream char &aux (output (make-string-output-stream)))
+
+ (write-char char output)
+
+ (let ((*readtable* (copy-readtable nil)))
+
+ (set-syntax-from-char #\- #\a *readtable*)
+
+ (loop
+
+ for nc = (peek-char nil stream nil nil)
+
+ for i from 0
+
+ while (and nc (char/= nc #\] #\- #\# #\space))
+
+ do (write-char (read-char stream) output))
+
+ (get-output-stream-string output)))
+
+
+
+
+
+
+
+;; Beispiele
+
+
+
+(bnf-reader "// doc Dies
+
+s ::= /* comment */ 'a'")
+
+
+
+;; note the escaping form when evaluating tests strings ...
+
+
+
+(bnf-reader "SingleQuote ::= '\\'' ")
+
+(bnf-reader "DoubleQuote ::= '\"' ")
+
+
+
+(bnf-to-atn
+
+ (bnf-object-tree
+
+ (caar (callparser 'ebnf
+
+ (bnf-reader "root ::= cell+ cell ::= [2,3 -> 'foo']")))))
+
+
+
+(bnf-to-atn
+
+ (bnf-object-tree
+
+ (caar (callparser 'ebnf
+
+ (bnf-reader "s ::= #[print foo] [^#xd-#xh] | [^#x45#x45] | [#x45-#x65] #[print a]")))))
+
+
+
+(write-source
+
+ (bnf-to-atn
+
+ "test ::= 'a' range '.' range ::= [a-z] | [^U-Z]")
+
+ "TestParser")
+
+
+
+;;; #[print a]
+
+;;; terminal-delimiter ::= '''
+
+
+
+(bnf-object-tree
+
+ (callparser 'ebnf
+
+ (bnf-reader
+
+
+
+ "ebnf ::= definition+
+
+ definition ::= symbol defsymbol rhs
+
+
+
+ rhs ::= qexpr+ | alternative
+
+ qexpr ::= (symbol | group) occurrence?
+
+ group ::= leftpar (qexpr+ | alternative) rightpar
+
+ alternative ::= qexpr oneof (qexpr | alternative)
+
+
+
+ symbol ::= terminal | nonterminal
+
+ nonterminal ::= token
+
+ terminal ::= terminal-delimiter token terminal-delimiter
+
+
+
+ leftpar ::= '('
+
+ rightpar ::= ')'
+
+ oneof ::= '|'
+
+ defsymbol ::= '::='
+
+ occurrence ::= '+' | '*' | '?'") ) )
+
+
+
+|#
\ No newline at end of file
Modified: branches/sbcl-0.9.x-testing/code/xparser/xml-printer.lisp
==============================================================================
--- branches/sbcl-0.9.x-testing/code/xparser/xml-printer.lisp (original)
+++ branches/sbcl-0.9.x-testing/code/xparser/xml-printer.lisp Tue Feb 14 11:52:41 2006
@@ -1 +1,650 @@
-;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: xml-parser; -*-
#|
print methods for xml data models
separate WRITE-NODE
and ENCODE-NODE
functions.
the first acts as the interface and takes a stream arg. the second is
internal and expects bindings for the writer function.
corrected (encode-node symbol) to permit uninterned names -> no prefix;
bind *document* in (write-node doc-node) for consistency parse/serialize.
fixed spacing in attribute declarations
fixed encoding printing for doc-node
WITH-XML-WRITER macro
encode-node for doc-node takes a default doctype
name from the root element
adjustments to encode-node for *-model
for PCDATA
*node-cache* to support recursive DEF-NODE
printing, which
makes it possible to effect prefixes analogous to those used in the
document entity.
changed respective WRITE-NODE
and ENCODE-NODE
to specialize on ABSTRACT-ELEM-NODE
rather than on
ELEM-NODE
in order to support specialized instantiation.
ENCODE-NODE
now relies on the interface rather than the
presence of slots.
reified ENCODE-NEWLINE
introduced uniform -interface specializers document, element, and property
nodes
modified ENCODE-NODE
for name instances
fix to encode node for default namespace names
use ephemeral
property to control printing
*generated-ns-bindings*as a special binding with
a single global handler
writer-stream
(ecode-node symbol) delegates keywords to the
string method
some CormanLisp
with-output-encoding changed to accept keyword options;
correction for generated namespace declarations in element definitions
correct default serialization for attribute definitions
corrected encode-generated-ns-bindings for string prefixes
scl
enabled prefix hint in preference to namespace nickname
fixed 20031023 to use the node rather than the name and
to guard for unbound prefix
lw-4.3-pc required a definition for stream-read-char(writer-stream)
lw-4.3.6-pc required a direction slot declaration for xml-writer when
loading fasl files
|#
(in-package "XML-PARSER")
;;
;;
;; interface functions
#|
(defMacro with-xml-writer ((stream &optional (encoding :utf-8)) &rest body)
"execute the body in a context appropriate to encode xml to the
provided stream."
`(multiple-value-bind (*writer-function *writer-arg)
(encoding-stream-writer ,stream ,encoding)
(let ((*namespace-bindings* *default-namespaces*))
(handler-bind ((|NSC: Prefix Declared|
#'(lambda (condition &aux (prefix (next-prefix))
node)
(setf node (cons prefix (name condition)))
(push node *namespace-bindings*)
(push node *generated-ns-bindings*)
(use-value prefix))))
, at body))))
|#
(defun call-with-xml-writer (function *xml-output*
&key (encoding *output-encoding*)
((:pretty *print-pretty*) *print-pretty*)
; namespace-bindings
&allow-other-keys)
"execute the body in a context appropriate to encode xml to the provided stream.
this includes *default-namespaces* as the initial value for
*namespace-bindings* and a null *xml-writer-node-cache*."
(multiple-value-bind (*writer-function *writer-arg *output-encoding*)
(encoding-stream-writer *xml-output* encoding)
(let ((*namespace-bindings* *default-namespaces*))
(handler-bind ((|NSC: Namespace Declared|
;; this condition is signaled where a namespace is not bound, and thus
;; therefore no prefix is apparent for serialization.
;; if a preference is provided, this is tested to see if some other
;; namespace is already bound to it.
;; if the prefix is already in use, or if no prefix hint was provided,
;; then the 'next' one is generated. the "" prefix is handled by leaving it up to
;; prefix-namespace to observe whether default namespace bindings are visible
;; or not.
#'(lambda (condition)
(let ((namespace (condition-namespace condition))
(name (condition-name condition)))
;; if a suggestion for prefix
(when *xml-verbose*
(warn "~a with prefix hint ~a~%with ns bindings ~s" condition name
*namespace-bindings*))
(if (or name (let ((maybe-name (namespace-printname namespace)))
(when (or (equal name "")
(is-ncname maybe-name))
(setf name maybe-name))))
(handler-case (when (prefix-value name)
(setf name (next-prefix)))
(|NSC: Prefix Declared| (c)
;; if the prefix wasn't declared, then use it
(declare (ignore c))))
(setf name (next-prefix)))
(when *xml-verbose*
(warn "yielded prefix: ~s." name))
(setf (prefix-value (local-part name))
namespace
;(namespace-name namespace)
)
(push (first *namespace-bindings*) *generated-ns-bindings*)
(use-value name)))))
(funcall function)))))
(defMacro with-xml-writer ((stream &key (encoding nil)) &rest body
&aux (writer-body (gensym "WRITER-"))
(xml-stream (if (symbolp stream) stream (gensym "XML-STREAM-"))))
"ensure the the body is executed in a context appropriate for xml encoding."
`(let (,@(unless (eq xml-stream stream) `((,xml-stream ,stream))))
(flet ((,writer-body () , at body))
(declare (dynamic-extent (function ,writer-body)))
(if (eq ,xml-stream *xml-output*)
(funcall #',writer-body)
(call-with-xml-writer #',writer-body ,xml-stream
,@(when encoding `(:encoding ,encoding)))))))
(defun encode-format (&rest args)
(apply #'format *xml-writer-stream* args))
(defClass writer-stream (#+ALLEGRO excl::fundamental-binary-output-stream
#+LispWorks stream:fundamental-stream
#+digitool ccl::output-binary-stream
#+openmcl fundamental-binary-output-stream
#+CormanLisp stream)
(#+(or clisp CMU lispworks sbcl scl) (direction :initarg :direction))
(:default-initargs :direction :output
#+CormanLisp :element-type #+CormanLisp 'unsigned-byte))
#+allegro
(defMethod excl:stream-line-column ((stream writer-stream)) nil)
#+lispworks
(defmethod stream:stream-write-char ((stream writer-stream) (char character))
(funcall *writer-function *writer-arg char))
(defMethod stream-tyo ((stream writer-stream) char)
(funcall *writer-function *writer-arg char))
(defMethod stream-element-type ((stream writer-stream))
'character)
(setq *xml-writer-stream* (make-instance 'writer-stream))
(defGeneric write-node (datum stream &rest args)
(:documentation
"encode the node as xml to the provided stream.")
(:method ((node t) (destination pathname) &rest args)
(with-open-file (stream destination :direction :output :element-type 'unsigned-byte
:if-exists :supersede :if-does-not-exist :create)
(apply #'write-node node stream args)))
(:method ((node t) (*output-destination* t) &rest args)
(apply #'call-with-xml-writer
#'(lambda () (encode-node node))
*output-destination*
args)
node))
#+digitool
(progn
(pushnew '(with-xml-writer . 1) *FRED-SPECIAL-INDENT-ALIST* :key #'first)
nil)
;;
;;
;; primitives
(defun encode-char (char)
"encode the provided character to the current output destination."
(funcall *writer-function *writer-arg char))
(defun encode-string (string)
"encode the provided string to the output destination.
used when it is known that no escapes are necessary."
(dotimes (i (length string))
(funcall *writer-function *writer-arg (char string i))))
(defun encode-newline ()
"emit a newline to the output destination."
(encode-char #.(code-char #x0a)))
(defGeneric encode-node (node)
(:documentation
"encode the provided node to the current output destination.
perform a tree walk for linked nodes.
escape character data in content and attribute values as appropriate.
introduce namespace bindings as required."))
(defMethod encode-node
((string string) &aux char)
(dotimes (x (length string))
(setf char (char string x))
(case char
(#\< (encode-string "<"))
(#\> (encode-string ">"))
(#\&
; here an attempt to both escape and not
(if (position #\; string :start x)
(funcall *writer-function *writer-arg char)
(encode-string "&")))
(t (funcall *writer-function *writer-arg char)))))
(defMethod encode-node
((node list))
(mapc #'encode-node node))
(defmethod encode-node
((node number))
(encode-node (write-to-string node)))
;;
;;
;; node methods
(defMethod encode-node
((node symbol)
&aux (name (local-part node))
(namespace (namespace node))
prefix)
(if (keywordp node)
(encode-node (string node))
(cond ((string= (namespace-name namespace) *xmlns-prefix-namestring*)
(encode-string *xmlns-prefix-namestring*)
(unless (eq node *default-namespace-attribute-name*)
(encode-char #\:)
(encode-node name)))
(namespace
(setf prefix (local-part (namespace-prefix namespace (get node :prefix))))
(unless (string= prefix "")
(encode-node (local-part prefix))
(encode-char #\:))
(encode-node name))
(t ;; allow uninterned names
(encode-node name)))))
(defMethod encode-node
((node null))
)
(defMethod encode-node
((node abstract-name)
&aux (name (local-part node))
(namespace (namespace node))
prefix)
(cond ((string= (namespace-name namespace) *xmlns-prefix-namestring*)
(encode-string *xmlns-prefix-namestring*)
(unless (eq node *default-namespace-attribute-name*)
(encode-char #\:)
(encode-node name)))
(namespace
(setf prefix (local-part (namespace-prefix namespace
(with-slots (prefix) node
(and (slot-boundp node 'prefix) prefix)))))
(unless (string= prefix "")
(encode-node (local-part prefix))
(encode-char #\:))
(encode-node name))
(t ;; allow uninterned names
(encode-node name))))
(defMethod encode-node
((node doc-node-interface)
&aux
(*prefix-count* *prefix-count*)
(*namespace-bindings* *namespace-bindings*)
(*default-namespace* *default-namespace*)
(name nil)
(encoding (encoding node))
(standalone (standalone node))
(version (version node)))
(encode-string "")
(setf name (name (entity-info node)))
(when (or (eq name *null-name*) (null name))
(setf name (name (root node))))
(when (or (plusp (hash-table-count (notations node)))
(> (hash-table-count (general-entities node)) 5)
(plusp (hash-table-count (parameter-entities node)))
(plusp (hash-table-count (types node)))
(attributes node))
(encode-char #\newline)
(encode-string ""))
(maphash #'encode-def (types node))))
(encode-newline)
(encode-string " ]>"))
(dolist (child (children node))
(encode-newline)
(encode-node child)))
(defun encode-generated-ns-bindings (generated-ns-bindings)
(dolist (binding generated-ns-bindings)
(destructuring-bind (prefix . namespace) binding
(encode-char #\space)
(typecase prefix
(name (encode-node prefix))
(string
(encode-string "xmlns")
(unless (equal prefix "")
(encode-char #\:)
(encode-string prefix))))
(encode-char #\=)
(encode-char #\')
(encode-node (namespace-name namespace))
(encode-char #\'))))
(defMethod encode-node
((node elem-node-interface))
(let ((*namespace-bindings* *namespace-bindings*)
(*default-namespace* *default-namespace*)
(*node-level* (1+ *node-level*))
(*prefix-count* *prefix-count*)
(*generated-ns-bindings* nil))
(declare (dynamic-extent *namespace-bindings*))
(with-accessors ((name name)
(children children)
(attributes attributes)
(namespaces namespaces)) node
(dolist (ns-node namespaces)
(push ns-node *namespace-bindings*))
; (break "namespaces: ~s/~s." *namespace-bindings* namespaces)
(encode-char #\<)
(encode-node name)
(dolist (node namespaces)
(encode-char #\space)
(encode-node node))
(dolist (node attributes)
(encode-char #\space)
(encode-node node))
(when *generated-ns-bindings*
(encode-generated-ns-bindings *generated-ns-bindings*))
(cond (children
(encode-char #\>)
(dolist (node children)
(when *print-pretty*
(encode-newline)
(dotimes (x *node-level*) (encode-char #\space)))
(encode-node node))
(encode-string "")
(encode-node name)
(encode-char #\>))
(t
(encode-string " />"))))))
(defMethod encode-node
((node elem-property-node-interface))
(with-slots (name children) node
(encode-node name)
(encode-char #\=)
(encode-char #\')
(dolist (node children)
(encode-node node))
(encode-char #\')))
(defmethod encode-node
((node pi-node))
(encode-string "")
(encode-node (name node))
(encode-char #\space)
(dolist (node (children node))
(encode-node node))
(encode-string "?>"))
(defMethod encode-node
((node comment-node))
(encode-string ""))
;;
;;
;; declarations
(defMethod encode-node ((node def-elem-type)
&aux
(*namespace-bindings* *namespace-bindings*)
(*generated-ns-bindings* nil)
c-def)
(with-slots (name children properties) node
;; first do the definition itself, that is, the content model and the
;; attribute declarations. these all in the same namespace context
(dolist (node properties)
(when (is-ns-node (prototype node))
(push (prototype node) *namespace-bindings*)))
;; write the element declaration
(encode-string " ")
;; write the attribute declarations
(when properties
(encode-newline)
(encode-string " "))
(when *generated-ns-bindings*
(encode-newline)
(encode-string " "))
;; then do type definitions referenced by virtue of their presence in the
;; content model
(dolist (c-name (collect-model-names (first (bnfp::bnf-rhs (model node)))))
(cond ((eq c-name *empty-name*) nil)
((eq c-name *wild-name*) nil)
((setf c-def (find-def-elem-type c-name (document node)))
(unless (find c-def *node-cache*)
(push c-def *node-cache*)
(encode-newline)
(encode-node c-def)))
(t
(encode-string
(format nil " "))
+ (maphash #'encode-def (types node))))
+ (encode-newline)
+ (encode-string " ]>"))
+ (dolist (child (children node))
+ (encode-newline)
+ (encode-node child)))
+
+(defun encode-generated-ns-bindings (generated-ns-bindings)
+ (dolist (binding generated-ns-bindings)
+ (encode-char #\space)
+ (encode-node (first binding))
+ (encode-char #\=)
+ (encode-char #\')
+ (encode-node (namespace-name (rest binding)))
+ (encode-char #\')))
+
+(defMethod encode-node
+ ((node elem-node-interface))
+ (let ((*namespace-bindings* *namespace-bindings*)
+ (*default-namespace* *default-namespace*)
+ (*node-level* (1+ *node-level*))
+ (*prefix-count* *prefix-count*)
+ (*generated-ns-bindings* nil))
+ (declare (dynamic-extent *namespace-bindings*))
+ (with-accessors ((name name)
+ (children children)
+ (attributes attributes)
+ (namespaces namespaces)) node
+ (dolist (ns-node namespaces)
+ (push ns-node *namespace-bindings*))
+ ; (break "namespaces: ~s/~s." *namespace-bindings* namespaces)
+ (encode-char #\<)
+ (encode-node name)
+ (dolist (node namespaces)
+ (encode-char #\space)
+ (encode-node node))
+ (dolist (node attributes)
+ (encode-char #\space)
+ (encode-node node))
+ (when *generated-ns-bindings*
+ (encode-generated-ns-bindings *generated-ns-bindings*))
+ (cond (children
+ (encode-char #\>)
+ (dolist (node children)
+ (when *print-pretty*
+ (encode-newline)
+ (dotimes (x *node-level*) (encode-char #\space)))
+ (encode-node node))
+ (encode-string "")
+ (encode-node name)
+ (encode-char #\>))
+ (t
+ (encode-string " />"))))))
+
+(defMethod encode-node
+ ((node elem-property-node-interface))
+ (with-slots (name children) node
+ (encode-node name)
+ (encode-char #\=)
+ (encode-char #\')
+ (dolist (node children)
+ (encode-node node))
+ (encode-char #\')))
+
+(defmethod encode-node
+ ((node pi-node))
+ (encode-string "")
+ (encode-node (name node))
+ (encode-char #\space)
+ (dolist (node (children node))
+ (encode-node node))
+ (encode-string "?>"))
+
+(defMethod encode-node
+ ((node comment-node))
+ (encode-string ""))
+
+;;
+;;
+;; declarations
+
+(defMethod encode-node ((node def-elem-type)
+ &aux
+ (*namespace-bindings* *namespace-bindings*)
+ (*generated-ns-bindings* nil)
+ c-def)
+ (with-slots (name children properties) node
+ ;; first do the definition itself, that is, the content model and the
+ ;; attribute declarations. these all in the same namespace context
+ (dolist (node properties)
+ (when (is-ns-node (prototype node))
+ (push (prototype node) *namespace-bindings*)))
+ ;; write the element declaration
+ (encode-string " ")
+ ;; write the attribute declarations
+ (when properties
+ (encode-newline)
+ (encode-string " "))
+ (when *generated-ns-bindings*
+ (encode-newline)
+ (encode-string " "))
+ ;; then do type definitions referenced by virtue of their presence in the
+ ;; content model
+ (dolist (c-name (collect-model-names (first (bnfp::bnf-rhs (model node)))))
+ (cond ((eq c-name *empty-name*) nil)
+ ((eq c-name *wild-name*) nil)
+ ((setf c-def (find-def-elem-type c-name (document node)))
+ (unless (find c-def *node-cache*)
+ (push c-def *node-cache*)
+ (encode-newline)
+ (encode-node c-def)))
+ (t
+ (encode-string
+ (format nil " " "->" "." ".." "/" "//" "/>" ":" ":=" "::" ":*" ";" "<" "" ">=" "?" "?>"
"@" "AFTER" "ANY" "ASCENDING" "BEFORE" "CDATA" "DESCENDING" "EMPTY"
"ENTITIES" "ENTITY" "ID" "IDREF" "IDREFS" "IGNORE" "INCLUDE"
"NDATA" "NMTOKEN" "NMTOKENS" "NOT" "NOTATION" "PUBLIC" "SYSTEM"
"[" "]" "]]>" "^"
"ancestor" "ancestor-or-self" "and" "attribute"
"child" "comment"
"descendant" "descendant-or-self" "div" "document"
"encoding" "following" "following-sibling"
"id" "key" "lang"
"mixed" "mod" "namespace" "no" "node" "not" "or"
"parent" "preceding" "preceding-sibling" "processing-instruction"
"root" "self" "standalone" "text" "union" "version" "xml" "yes"
"{" "|" "}" "?"))
;;
;;
;; packages for implementing xml data modeling.
;; types from the datatype package appear in expression in the two algrbras. they are
;; exported, but not used/imported, as the customary expression uses the prefix.
;; the case distinctions distinguish grammatic meta-symbols which participate in special
;; forms from the names for functions and types, which conserve case.
;; package for xml query types
(defPackage "XML-SCHEMA-DATATYPES" (:use) (:nicknames "XSD")
(:export "TYPEP" "TYPEP-SPECIALIZED"
"IS-anyComplexType" "IS-anySimpleType" "IS-anyTreeType" "IS-anyType" "IS-anyURI"
"IS-attribute" "IS-base64Binary" "IS-boolean" "IS-byte" "IS-comment" "IS-complex"
"IS-date" "IS-dateTime"
"IS-decimal" "IS-double" "IS-duration"
"IS-element" "IS-ENTITY" "IS-ENTITIES" "IS-float"
"IS-gDay" "IS-gMonth" "IS-gMonthDay" "IS-gYear"
"IS-hexBinary" "IS-ID" "IS-IDREF" "IS-IDREFS"
"IS-int" "IS-integer" "IS-language" "IS-long"
"IS-Name" "IS-NCName" "IS-NMTOKEN" "IS-NMTOKENS"
"IS-negativeInteger" "IS-nonNegativeInteger" "IS-nonPositiveInteger" "IS-normalizedString"
"IS-NOTATION" "IS-pi" "IS-positiveInteger" "IS-scalar" "IS-short" "IS-simple"
"IS-string" "IS-time" "IS-token" "IS-UName"
"IS-unsignedByte" "IS-unsignedInt" "IS-unsignedLong" "IS-unsignedShort"
"VALIDATE-STRING" "VALIDATE-ATTRIBUTE" "VALIDATE-NAME"))
;; package for xml path "algebra" operators
(defPackage "XML-PATH-ALGEBRA" (:use) (:nicknames "XPA")
(:import-from "xml" "document")
(:intern "APPLY-DESCENDANTS-PATH" "APPLY-CHILD-PATH" "APPLY-PATH"
"APPLY-PREDICATE-PATH" "APPLY-STEP"
"EVAL" "FUNCALL" "LANGUAGE-EQUAL" "NODES" "VARIABLE"
"SYMBOL-FUNCTION" "GENSYM")
(:export
;; path components
"PATH" "STEP" "UNAME"
"ID-STEP" "KEY-STEP" "PARENT-STEP" "ROOT-STEP" "SELF-STEP" "WILD-INFERIOR-STEP"
"AXIS-GENERATOR" "LIST-GENERATOR"
"ANCESTOR" "ANCESTOR-OR-SELF" "ATTRIBUTE" "CHILD" "DESCENDANT"
"DESCENDANT-OR-SELF" "FOLLOWING" "FOLLOWING-OR-SELF" "FOLLOWING-SIBLING"
"ID" "KEY"
"NAMESPACE" "PARENT" "PRECEDING" "PRECEDING-SIBLING" "ROOT" "SELF"
"NAME-TEST" "@NAME-TEST" "TYPE-TEST" "TYPE-NAME-TEST"
"PI-TEST" "COMMENT-TEST" "TEXT-TEST"
"PREDICATE"
;; state variables
"*CONTEXT-NODE*" "*POSITION*" "*COUNT*"
;; library functions
"and"
"boolean"
"ceiling" "contains" "count"
"document"
"false" "floor"
"id"
"last" "local-name" "lang"
"mod"
"name" "namespace-uri" "normalize-space" "not" "number"
"or"
"position"
"round"
"starts-with" "string" "substring"
"substring-after" "substring-before"
"string-length" "sum"
"translate" "true"
"union"
"+" "-" "*" "/" "<" "<=" ">" ">=" "=" "!="
"NaN" "0+" "0-" "infinity+" "infinity-"
))
;; package for xml query algebra operators
(defPackage "XML-QUERY-ALGEBRA" (:use) (:nicknames "XQA")
(:import-from "XPA"
"and"
"boolean"
"ceiling" "contains" "count"
"document"
"false" "floor"
"id"
"last" "local-name" "lang"
"mod"
"name" "namespace-uri" "normalize-space" "not" "number"
"or"
"position"
"round"
"starts-with" "string" "substring"
"substring-after" "substring-before"
"string-length" "sum"
"translate" "true"
"union"
;; these are not imported "<" "<=" ">" ">=" "="
;; as the comparison differs
"+" "-" "*" "/" "!="
"NaN" "0+" "0-" "infinity+" "infinity-"
"GENSYM")
(:EXPORT "IF" "LET" "ELSE" "FOR" "MATCH" "CASE" "WHERE"
"TYPE" "FUN" "QUERY"
"AND" "OR" "NOT" "DIV" "MOD" "SCHEMA"
"+" "-" "*" "<" "<=" ">" ">=" "=" "==" "!=" "!=="
"//" "/" "." "|"
"DEFUN"
"ATTRIBUTE" "ELEMENT"
"MAKE-NCNAME" "MAKE-TNAME" "MAKE-UNAME"
"sequence" "UNION" "DIFFERENCE" "INTERSECTION" "SORT"
"ERROR" "INSTANCEOF" "BEFORE" "AFTER"
"TYPEP" "TYPE" "SORT"
"TYPE-REF" "ID-TEST" "TYPEP" "RANGE-TEST"
;; xpath algebra symbols
"and"
"boolean"
"cdata" "ceiling" "contains" "count"
"document"
"false" "floor"
"id"
"last" "local-name" "lang"
"mod"
"name" "namespace-uri" "normalize-space" "not" "number"
"or"
"position"
"round"
"starts-with" "string" "substring"
"substring-after" "substring-before"
"string-length" "sum"
"translate" "true"
"union"
"NaN" "0+" "0-" "infinity+" "infinity-"
;; xml query algebra specific
"avg"
"bagtolist"
"data" "difference" "distinct_nodes" "distinct_value"
"comment" "Comment" "deref"
"except"
"index" "intersection"
"listtobag" "localname"
"max" "min"
"namespace" "nodes"
"parent" "processing_instruction"
"ref"
"sequence" "sort"
"target"
"value"
"empty"
"==" ))
(defPackage "$" (:use))
(defpackage "XML-QUERY-LANGUAGE" (:use) (:nicknames "XQL")
(:import-from "XPA"
"and"
"boolean"
"ceiling" "contains" "count"
"document"
"false" "floor"
"id"
"last" "local-name" "lang"
"mod"
"name" "namespace-uri" "normalize-space" "not" "number"
"or"
"position"
"round"
"starts-with" "string" "substring"
"substring-after" "substring-before"
"string-length" "sum"
"translate" "true"
"union"
"+" "-" "*" "/" "!="
"NaN" "0+" "0-" "infinity+" "infinity-")
(:import-from "XQA"
"<" "<=" ">" ">=" "=")
(:export "ELEMENT" "ATTRIBUTE" "CAST" "TREAT" "INTERSECT" "EXCEPT"
"INSTANCEOF" "SOME" "EVERY" "FUNCTION"
"FUNCALL" "NAMESPACE-DECL" "QNAME" "SCHEMA-DECL"
"ID-PATH" "ATTRIBUTE-PATH" "TYPE-PATH" "ELEMENT-PATH"
"RANGE" "/" "//" "*" "STEP" "TYPE"
;; xpath algebra symbols
"and"
"boolean"
"ceiling" "contains" "count"
"document"
"false" "floor"
"id"
"last" "local-name" "lang"
"mod"
"name" "namespace-uri" "normalize-space" "not" "number"
"or"
"position"
"round"
"starts-with" "string" "substring"
"substring-after" "substring-before"
"string-length" "sum"
"translate" "true"
"union"
"+" "-" "*" "/" "<" "<=" ">" ">=" "=" "!="
"NaN" "0+" "0-" "infinity+" "infinity-"
;; xquery language library
"comment" "date" "distinct"
"empty" "equal" "filter" "last"
"name" "number" "pi" "union"))
;; additions for cl-http tokenizer
#-CL-HTTP
(defpackage "WWW-UTILS"
(:use common-lisp)
(:intern "WITH-FAST-ARRAY-REFERENCES" "MAKE-LOCK" "WITH-LOCK-HELD"))
#-CL-HTTP
(defpackage tk1
(:use common-lisp)
(:import-from "WWW-UTILS" "WITH-FAST-ARRAY-REFERENCES" "MAKE-LOCK" "WITH-LOCK-HELD")
(:export
"*DEFAULT-TOKENIZER-SIZE*"
"CLEAR-TOKENIZER"
"CREATE-TOKENIZER"
"DEFINE-TOKENIZER"
"DESCRIBE-TOKENIZER"
"FIND-TOKENIZER-NAMED"
"GET-TOKEN"
"INSERT-TOKEN"
"MAP-TOKENS"
"REHASH-TOKENIZER"
"REMOVE-TOKEN"
"TOKENIZE"
"UNDEFINE-TOKENIZER"))
#-CL-HTTP
(defPackage "HTTP"
(:export "*STANDARD-CHARACTER-TYPE*"))
:EOF
\ No newline at end of file
+;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: cl-user; -*-
+
+#|
+
+ nb. see XQueryDataModel:XQDM-classes for exports for class predicate and constructors
+
+ incorporated character class exports
+ moved parsetable to XML-UTILS
+ exported xml serialization iterface
+ parameters for reader adjustments for null symbol names
+ node graph interface
+ DATA-URL
; differentiated qname contexts
+ factored namespaces out
+ xmlparser package renamed to XMLP
+ added '$' package for XQL variables
+ additions for schema types
+ www-utils and tk1 package for cl-http tokenizer
+ added 0.950 package nicknmes inorder to use its condition implementation
+
+
+|#
+
+(in-package "CL-USER")
+
+(defPackage "BNF-PARSER"
+ (:nicknames "BNFP")
+ (:use :common-lisp #+:ccl :ccl #+lispworks :harlequin-common-lisp :de.setf.utility.conditions )
+ (:shadow "SYMBOL")
+ #+Allegro (:import-from "EXCL" "WITHOUT-INTERRUPTS")
+ #+(and Allegro (version>= 6 0)) (:import-from "MOP" "CLASS-PRECEDENCE-LIST")
+ #+(and Allegro (version< 6 0)) (:import-from "CLOS" "CLASS-PRECEDENCE-LIST")
+ #+Genera (:import-from "CLOS-INTERNALS" "CLASS-PRECEDENCE-LIST" "FUNCALLABLE-STANDARD-CLASS" "VALIDATE-SUPERCLASS")
+ #+Genera(:import-from "SCL" "WITHOUT-INTERRUPTS")
+ #+Genera(:shadowing-import-from "SI" "STREAM")
+ #+lispworks (:import-from :lispworks :without-interrupts)
+ #+CMU (:import-from "SYSTEM" "WITHOUT-INTERRUPTS")
+ #+PCL (:shadowing-import-from "PCL" "CLASS-PRECEDENCE-LIST"
+ "FUNCALLABLE-STANDARD-CLASS"
+ "VALIDATE-SUPERCLASS"
+ "STANDARD-CLASS" "BUILT-IN-CLASS"
+ "FIND-CLASS" "CLASS-NAME" "CLASS-OF")
+ #+SBCL (:import-from "SB-SYS" "WITHOUT-INTERRUPTS")
+ #+sbcl (:shadowing-import-from "SB-PCL" "CLASS-PRECEDENCE-LIST"
+ "FUNCALLABLE-STANDARD-CLASS"
+ "VALIDATE-SUPERCLASS"
+ "STANDARD-CLASS" "BUILT-IN-CLASS"
+ "FIND-CLASS" "CLASS-NAME" "CLASS-OF")
+ (:export
+ "*ATN-CLASS"
+ "*ATN-LEVEL"
+ "*ATN-NET"
+ "*ATN-NODE"
+ "*ATN-PROPERTIES"
+ "*ATN-REGISTER-WORDS"
+ "*ATN-SAVE-DEFINITIONS*"
+ "*ATN-STACK"
+ "*ATN-STRUCTURE*"
+ "*ATN-TERM*"
+ "*ATN-TERM?*"
+ "*ATN-TOKEN-PACKAGE*"
+ "*ATN-TRACE*"
+ "*ATN-TRACE-NETS*"
+ "*ATN-WFST"
+ "*CLASS.ATN*"
+ "*CLASS.ATN-ALTERNATIVE-CATEGORY*"
+ "*CLASS.ATN-BUILTIN-PREDICATE-CATEGORY*"
+ "*CLASS.ATN-CELL-CATEGORY*"
+ "*CLASS.ATN-COMPLEMENT-CATEGORY*"
+ "*CLASS.ATN-CONJUNCTION*"
+ "*CLASS.ATN-DERIVED-CATEGORY*"
+ "*CLASS.ATN-LEXEM*"
+ "*CLASS.ATN-LEXICON*"
+ "*CLASS.ATN-NEGATED-ALTERNATIVES*"
+ "*CLASS.ATN-NODE*"
+ "*CLASS.ATN-PRIMITIVE-CATEGORY*"
+ "*CLASS.ATN-UNDECLARED-CATEGORY*"
+ "*CLASS.CAT-ATN-EDGE*"
+ "*CLASS.CELL-ATN-EDGE*"
+ "*CLASS.JUMP-ATN-EDGE*"
+ "*CLASS.OR-ATN-EDGE*"
+ "*CLASS.POP-ATN-EDGE*"
+ "*CLASS.PUSH-ATN-EDGE*"
+ "*CLASS.TEST-ATN-EDGE*"
+ "*CLASS.WORD-ATN-EDGE*"
+ "*SOURCE-RECORDING*"
+ :*terminal-parser-error-action*
+ "ATN"
+ "ATN-ALTERNATIVE-CATEGORY"
+ "ATN-BINDINGS"
+ "ATN-BUILTIN-PREDICATE-CATEGORY"
+ "ATN-CELL-CATEGORY"
+ "ATN-COMPLEMENT-CATEGORY"
+ "ATN-CONJUNCTION"
+ "ATN-CONSTRUCTOR-SPECIALIZER"
+ "ATN-CONTINUE-ACTIONS"
+ "ATN-DERIVED-CATEGORY"
+ "ATN-FAIL-ACTIONS"
+ "ATN-FINALLY"
+ "ATN-INITIAL-ACTIONS"
+ "ATN-INPUT"
+ "ATN-LEXEM"
+ "ATN-LEXICON"
+ "ATN-NAME"
+ "ATN-NEGATED-ALTERNATIVES"
+ "ATN-NODE"
+ "ATN-PRIMITIVE-CATEGORY"
+ "ATN-PROCEDURE-CALL"
+ "ATN-RECURSION"
+ "ATN-REDUCE-ITEM"
+ "ATN-REDUCE-STRUCTURE"
+ "ATN-SEQUENCE-INPUT"
+ "ATN-STACK"
+ "ATN-SUCCEED-ACTIONS"
+ "ATN-TERM-CARDINALITY"
+ "ATN-TERM-NAMES"
+ "ATN-UNDECLARED-CATEGORY"
+ "BNF-TO-REGEX-ATN"
+ "CALL-WITH-PARSED-ALIST"
+ "CALL-WITH-PARSED-TERMS"
+ "CAT-ATN-EDGE"
+ "CELL-ATN-EDGE"
+ "COMPILE-ATN-SYSTEM"
+ "CONSTRUCTOR-SPECIALIZERS"
+ "CONTINUABLE-PARSER-ERROR"
+ "FIND-PARSED-TERM"
+ "INFERENCE-SYSTEM"
+ "INFERENCE-UNIT"
+ "INPUT.IS-AT-END"
+ "INPUT.ITEM"
+ "INPUT.LAST-ITEM"
+ "INPUT.LENGTH"
+ "INPUT.PEEK-ITEM"
+ "INPUT.REPLACE-ITEM"
+ "IS-ATN-TRACE"
+ "IS-REDUCTION-ENABLED"
+ "JUMP-ATN-EDGE"
+ "MAKE-LISP-FORM"
+ "MAKE-LISP-SUBFORM"
+ "MAKE-LISP-TEST-FORM"
+ "MATCH-REGEX"
+ "NTH-PARSE-RESULT"
+ "OR-ATN-EDGE"
+ "PARSER-EOF-ERROR"
+ "PARSER-ERROR"
+ "PARSE-RESULT"
+ "POP-ATN-EDGE"
+ "PPRINT-ATN"
+ "PUSH-ATN-EDGE"
+ "REGULAR-EXPRESSION-TO-REGEX-ATN"
+ "RULE"
+ "RULE-DOCUMENTATION"
+ "RULE-NAME"
+ "RULE-SOURCES"
+ "SORT-PARSE-RESULTS"
+ "SYSTEM"
+ "SYSTEM-DOCUMENTATION"
+ "SYSTEM-NAME"
+ "SYSTEM-PLIST"
+ "TERMINAL-PARSER-ERROR"
+ "TEST-ATN-EDGE"
+ "WITH-PARSED-ALIST"
+ "WITH-PARSED-PLIST"
+ "WITH-PARSED-TERM"
+ "WORD-ATN-EDGE"
+
+ ;; for parse states
+ :condition-parse-state
+ :condition-action
+ :parse-state
+ :parse-state-condition
+ :parse-state-source
+ :parse-state-term
+ :parse-state-non-terminal
+ :parse-state-stack
+ :parse-state-active-p
+ :print-parse-state
+ :make-parse-state
+ ))
+
+(defPackage "XML-UTILS"
+ (:nicknames "XUTILS" :de.setf.xml.base.implementation
+ :de.setf.xml.conditions)
+ (:use :common-lisp #+ccl :ccl
+ :de.setf.utility.conditions)
+ #+CCL (:import-from "CCL" "STREAM-POSITION")
+ #+CL-HTTP (:import-from "URL" "URI" "URL" "PARSE-URL" "INTERN-URL"
+ "HTTP-URL" "FILE-URL" "NAME-STRING"
+ "PATH" "HOST" "HOST-STRING" "PORT" "OBJECT" "EXTENSION"
+ "TRANSLATED-PATHNAME"
+ ;; for the file-url function
+ "DIRECTORY-NAME-STRING" "WITH-VALUE-CACHED"
+ "WRITE-SCHEME-PREFIX" "WRITE-HOST-PORT-STRING" "WRITE-PATH")
+ #+CL-HTTP (:import-from "HTTP" "MERGE-URL")
+ #+ALLEGRO (:import-from "EXCL" "WITHOUT-INTERRUPTS")
+ #+lispworks (:import-from :lispworks :without-interrupts)
+ #+CMU (:import-from "SYSTEM" "WITHOUT-INTERRUPTS")
+ #+PCL (:shadowing-import-from "PCL" "CLASS-PRECEDENCE-LIST"
+ "FUNCALLABLE-STANDARD-CLASS"
+ "VALIDATE-SUPERCLASS" "STANDARD-CLASS"
+ "BUILT-IN-CLASS" "FIND-CLASS"
+ "CLASS-NAME" "CLASS-OF")
+ #+SBCL (:import-from "SB-SYS" "WITHOUT-INTERRUPTS")
+ #+sbcl (:shadowing-import-from "SB-PCL" "CLASS-PRECEDENCE-LIST"
+ "FUNCALLABLE-STANDARD-CLASS"
+ "VALIDATE-SUPERCLASS" "STANDARD-CLASS"
+ "BUILT-IN-CLASS" "FIND-CLASS"
+ "CLASS-NAME" "CLASS-OF")
+ #+digitool
+ (:import-from :ccl
+ :stream-reader
+ :stream-writer
+ :stream-column)
+ (:import-from :de.setf.utility.test
+ :deftest
+ :deftests
+ :execute-tests)
+ (:EXPORT
+ :deftest
+ :deftests
+ :execute-tests
+ "*ENCODING-MAP*"
+ "*PARSETABLE*"
+ "*TOKEN-PACKAGE*"
+ "*XML-BASE*"
+ "*XML-VERBOSE*"
+ "<-CHAR-CODE-LIMIT"
+ "CANONICAL-ENCODING"
+ "CHECKED-CODE-CHAR"
+ "CLEAR-PARSETABLE"
+ "CLEAR-PARSETABLES"
+ "COMPUTE-PARSER-MACROS"
+ "COMPUTE-TOKEN-READER"
+ "COPY-PARSETABLE"
+ "DATA-URL"
+ "DEFALTERNATIVECONSTRUCTOR"
+ "DEFCONSTANTCONSTRUCTOR"
+ "DEFCONSTRUCTOR"
+ "DEFCONSTRUCTORMETHOD"
+ "DEFIDENTITYCONSTRUCTOR"
+ "DEFLITERALCONSTRUCTOR"
+ "DEFNULLCONSTRUCTOR"
+ "DEFPARSETABLE"
+ "DEFTOKEN"
+ "DEFTOKENCONSTRUCTOR"
+ "DEFTOKENCONSTRUCTORS"
+ "DEFTOKENS"
+ "EXPORT-NAME"
+ "FILE-URL"
+ "FILE-URL-PATHNAME"
+ "HTTP-URL"
+ "MAKE-DATA-URL"
+ "MAKE-URI"
+ "MERGE-URIS"
+ "NOTE-newline-200101314"
+ :object
+ "PARSER-MACRO"
+ "PARSETABLE"
+ "PATHNAME-FILE-URL"
+ "REC-xml-19980210.End-of-Line Handling"
+ "REC-xml-19980210.PEs in Internal Subset"
+ "REC-xml-19980210.Validate Attribute Defaults"
+ "REC-xml-names-19990114"
+ "REC-xml-names-19990114.NSC: Prefix Immutable"
+ "REC-xml-names-19990114.VC: Attribute Declared"
+ "RESOLVE-ENTITY-IDENTIFIERS"
+ "SPLIT-SEQ"
+ "SPLIT-STRING"
+ "STREAM-POSITION"
+ "STREAM-STATE"
+ "TABLE.MACROS"
+ "TABLE.NAME"
+ "TABLE.PROPERTIES"
+ "URI"
+ "URI-NAMESTRING"
+ "URL"
+ "URL-DATA"
+ "URN"
+ "VECTOR-INPUT-STREAM"
+ "WITH-DATA-STREAM"
+ "WITH-FILE-STREAM"
+ "WITH-HTTP-STREAM"
+ "WITH-PARSETABLE"
+ "WITHOUT-INTERRUPTS"
+ "STREAM-COLUMN"
+ "STREAM-READER"
+ "STREAM-WRITER"
+ :check-constraint
+ :coerce-to-generic-function
+ :condition-continue-format-arguments
+ :condition-continue-format-control
+ :continuable-error
+ :continue-format-arguments
+ :continue-format-control
+ :defexception
+ :initialize-condition
+ :internal-xml-error
+ :make-initialized-condition
+ :report-condition
+ :report-condition
+ :simple-continuable-condition
+ :xml-condition
+ :xml-error
+ :xml-warn
+ :xml-warning
+ :|VC: ID|
+ :|VC: Name Token|
+ :|VC: Entity Name|
+ :|VC: Notation Attributes|
+ :|VC: Enumeration|
+ :|VC: Element Content|
+ :|VC: No Duplicate Tokens|
+ :|VC: No Duplicate Types|
+ :|NSC: Prefix Immutable|
+ :|WFC: Legal Character|
+ ))
+
+
+(defPackage "XML-QUERY-DATA-MODEL"
+ (:nicknames "XQDM"
+ :DE.SETF.XML.NAMES.IMPLEMENTATION
+ :DE.SETF.XML.NODE.IMPLEMENTATION
+ :DE.SETF.XML.MODEL
+ :DE.SETF.XML.MODEL.IMPLEMENTATION)
+ (:shadowing-import-from "BNFP" "PARSE-ERROR")
+ #+LISPWORKS
+ (:import-from "HCL" "VALIDATE-SUPERCLASS")
+ (:use "BNFP" #+CCL "CCL" "COMMON-LISP" "XUTILS")
+ #+CCL (:shadow "TARGET")
+ #+PCL (:shadowing-import-from "PCL" "CLASS-PRECEDENCE-LIST"
+ "FUNCALLABLE-STANDARD-CLASS"
+ "VALIDATE-SUPERCLASS" "STANDARD-CLASS"
+ "BUILT-IN-CLASS" "FIND-CLASS"
+ "CLASS-NAME" "CLASS-OF"
+ "STRUCTURE-CLASS")
+ #+sbcl (:shadowing-import-from "SB-PCL" "CLASS-PRECEDENCE-LIST"
+ "FUNCALLABLE-STANDARD-CLASS"
+ "VALIDATE-SUPERCLASS" "STANDARD-CLASS"
+ "BUILT-IN-CLASS" "FIND-CLASS"
+ "CLASS-NAME" "CLASS-OF")
+ (:export
+ ;; the defTypePredicate macro exports for classes and predicate names
+ ;; the defException macro exports exception class names
+
+ "ABSTRACT-CLASS"
+ "ABSTRACT-NODE"
+ "NAMED-NODE"
+ "UNAMED-NODE"
+ "NCNAMED-NODE"
+ "TYPED-NODE"
+ "DOCUMENT-SCOPED-NODE"
+ "ORDINAL-NODE"
+ "ENTITY-DELEGATE"
+ "DOC-NODE-INTERFACE"
+ "ELEM-NODE-INTERFACE"
+ "ELEM-PROPERTY-NODE-INTERFACE"
+
+ ;; model classes: all classes export the symbol and a predicate
+ ;; concrete classes have an instantiation function and parameter
+ ;; see defTypePredicate for generation
+ "ABSTRACT-ATTR-NODE" "IS-ABSTRACT-ATTR-NODE"
+ "ABSTRACT-DEF-NODE" "IS-ABSTRACT-DEF-NODE"
+ "ABSTRACT-DEF-TYPE" "IS-ABSTRACT-DEF-TYPE"
+ "ABSTRACT-ELEM-NODE" "IS-ABSTRACT-ELEM-NODE"
+ "ABSTRACT-ELEM-PROPERTY-NODE" "IS-ABSTRACT-ELEM-PROPERTY-NODE"
+ "ABSTRACT-NS-NODE" "IS-ABSTRACT-NS-NODE"
+ "ABSTRACT-TOP-LEVEL-DEF-NODE" "IS-ABSTRACT-TOP-LEVEL-DEF-NODE"
+ "ATTR-CHILD-NODE" "IS-ATTR-CHILD-NODE" "*CLASS.ATTR-CHILD-NODE*" "MAKE-ATTR-CHILD-NODE"
+ "ATTR-NODE" "IS-ATTR-NODE" "*CLASS.ATTR-NODE*" "MAKE-ATTR-NODE"
+ "BINARY-VALUE" "IS-BINARY-VALUE" "*CLASS.BINARY-VALUE*" "MAKE-BINARY-VALUE"
+ "BOOL-VALUE" "IS-BOOL-VALUE" "*CLASS.BOOL-VALUE*" "MAKE-BOOL-VALUE"
+ "CHARACTER-DATA-NODE" "IS-CHARACTER-DATA-NODE" "*CLASS.CHARACTER-DATA-NODE*" "MAKE-CHARACTER-DATA-NODE"
+ "COMMENT-NODE" "IS-COMMENT-NODE" "*CLASS.COMMENT-NODE*" "MAKE-COMMENT-NODE"
+ "CONDITIONAL-SECTION" "IS-CONDITIONAL-SECTION" "*CLASS.CONDITIONAL-SECTION*" "MAKE-CONDITIONAL-SECTION"
+ "DECIMAL-ATTR-NODE" "IS-DECIMAL-ATTR-NODE" "*CLASS.DECIMAL-ATTR-NODE*" "MAKE-DECIMAL-ATTR-NODE"
+ "DECIMAL-VALUE" "IS-DECIMAL-VALUE" "*CLASS.DECIMAL-VALUE*" "MAKE-DECIMAL-VALUE"
+ "DEF-ATTR" "IS-DEF-ATTR" "*CLASS.DEF-ATTR*" "MAKE-DEF-ATTR"
+ "DEF-ELEM-PROPERTY-TYPE" "IS-DEF-ELEM-PROPERTY-TYPE" "*CLASS.DEF-ELEM-PROPERTY-TYPE*" "MAKE-DEF-ELEM-PROPERTY-TYPE"
+ "DEF-ELEM-TYPE" "IS-DEF-ELEM-TYPE" "*CLASS.DEF-ELEM-TYPE*" "MAKE-DEF-ELEM-TYPE"
+ "DEF-ENTITY" "IS-DEF-ENTITY" "*CLASS.DEF-ENTITY*" "MAKE-DEF-ENTITY"
+ "DEF-EXTERNAL-ENTITY" "IS-DEF-EXTERNAL-ENTITY" "*CLASS.DEF-EXTERNAL-ENTITY*" "MAKE-DEF-EXTERNAL-ENTITY"
+ "DEF-EXTERNAL-GENERAL-ENTITY" "IS-DEF-EXTERNAL-GENERAL-ENTITY" "*CLASS.DEF-EXTERNAL-GENERAL-ENTITY*" "MAKE-DEF-EXTERNAL-GENERAL-ENTITY"
+ "DEF-EXTERNAL-PARAMETER-ENTITY" "IS-DEF-EXTERNAL-PARAMETER-ENTITY" "*CLASS.DEF-EXTERNAL-PARAMETER-ENTITY*" "MAKE-DEF-EXTERNAL-PARAMETER-ENTITY"
+ "DEF-GENERAL-ENTITY" "IS-DEF-GENERAL-ENTITY" "*CLASS.DEF-GENERAL-ENTITY*" "MAKE-DEF-GENERAL-ENTITY"
+ "DEF-INTERNAL-ENTITY" "IS-DEF-INTERNAL-ENTITY" "*CLASS.DEF-INTERNAL-ENTITY*" "MAKE-DEF-INTERNAL-ENTITY"
+ "DEF-INTERNAL-GENERAL-ENTITY" "IS-DEF-INTERNAL-GENERAL-ENTITY" "*CLASS.DEF-INTERNAL-GENERAL-ENTITY*" "MAKE-DEF-INTERNAL-GENERAL-ENTITY"
+ "DEF-INTERNAL-PARAMETER-ENTITY" "IS-DEF-INTERNAL-PARAMETER-ENTITY" "*CLASS.DEF-INTERNAL-PARAMETER-ENTITY*" "MAKE-DEF-INTERNAL-PARAMETER-ENTITY"
+ "DEF-NOTATION" "IS-DEF-NOTATION" "*CLASS.DEF-NOTATION*" "MAKE-DEF-NOTATION"
+ "DEF-PARAMETER-ENTITY" "IS-DEF-PARAMETER-ENTITY" "*CLASS.DEF-PARAMETER-ENTITY*" "MAKE-DEF-PARAMETER-ENTITY"
+ "DEFNAMESPACE"
+ "DOC-CHILD-NODE" "IS-DOC-CHILD-NODE" "*CLASS.DOC-CHILD-NODE*" "MAKE-DOC-CHILD-NODE"
+ "DOC-NODE" "IS-DOC-NODE" "*CLASS.DOC-NODE*" "MAKE-DOC-NODE"
+ "DOCTYPE-CHILD-NODE" "IS-DOCTYPE-CHILD-NODE" "*CLASS.DOCTYPE-CHILD-NODE*" "MAKE-DOCTYPE-CHILD-NODE"
+ "DOCUMENT-TYPE-DECLARATION-INFORMATION-NODE" "IS-DOCUMENT-TYPE-DECLARATION-INFORMATION-NODE" "*CLASS.DOCUMENT-TYPE-DECLARATION-INFORMATION-NODE*" "MAKE-DOCUMENT-TYPE-DECLARATION-INFORMATION-NODE"
+ "DOUBLE-ATTR-NODE" "IS-DOUBLE-ATTR-NODE" "*CLASS.DOUBLE-ATTR-NODE*" "MAKE-DOUBLE-ATTR-NODE"
+ "DOUBLE-VALUE" "IS-DOUBLE-VALUE" "*CLASS.DOUBLE-VALUE*" "MAKE-DOUBLE-VALUE"
+ "ELEM-CHILD-NODE" "IS-ELEM-CHILD-NODE" "*CLASS.ELEM-CHILD-NODE*" "MAKE-ELEM-CHILD-NODE"
+ "ELEM-NODE" "IS-ELEM-NODE" "*CLASS.ELEM-NODE*" "MAKE-ELEM-NODE"
+ "ELEM-PROPERTY-NODE" "IS-ELEM-PROPERTY-NODE" "*CLASS.ELEM-PROPERTY-NODE*" "MAKE-ELEM-PROPERTY-NODE"
+ "ENTITIES-ATTR-NODE" "IS-ENTITIES-ATTR-NODE" "*CLASS.ENTITIES-ATTR-NODE*" "MAKE-ENTITIES-ATTR-NODE"
+ "ENTITY-ATTR-NODE" "IS-ENTITY-ATTR-NODE" "*CLASS.ENTITY-ATTR-NODE*" "MAKE-ENTITY-ATTR-NODE"
+ "ENTITY-INFORMATION-NODE" "IS-ENTITY-INFORMATION-NODE" "*CLASS.ENTITY-INFORMATION-NODE*" "MAKE-ENTITY-INFORMATION-NODE"
+ "ENTITY-VALUE" "IS-ENTITY-VALUE" "*CLASS.ENTITY-VALUE*" "MAKE-ENTITY-VALUE"
+ "ENUMERATION-ATTR-NODE" "IS-ENUMERATION-ATTR-NODE" "*CLASS.ENUMERATION-ATTR-NODE*" "MAKE-ENUMERATION-ATTR-NODE"
+ "EXT-SUBSET-NODE" "IS-EXT-SUBSET-NODE" "*CLASS.EXT-SUBSET-NODE*" "MAKE-EXT-SUBSET-NODE"
+ "EXTERNAL-PARSED-ENTITY" "IS-EXTERNAL-PARSED-ENTITY" "*CLASS.EXTERNAL-PARSED-ENTITY*" "MAKE-EXTERNAL-PARSED-ENTITY"
+ "FLOAT-VALUE" "IS-FLOAT-VALUE" "*CLASS.FLOAT-VALUE*" "MAKE-FLOAT-VALUE"
+ "FUNCTION-VALUE" "IS-FUNCTION-VALUE" "*CLASS.FUNCTION-VALUE*" "MAKE-FUNCTION-VALUE"
+ "ID-ATTR-NODE" "IS-ID-ATTR-NODE" "*CLASS.ID-ATTR-NODE*" "MAKE-ID-ATTR-NODE"
+ "ID-REF-ATTR-NODE" "IS-ID-REF-ATTR-NODE" "*CLASS.ID-REF-ATTR-NODE*" "MAKE-ID-REF-ATTR-NODE"
+ "ID-REF-VALUE" "IS-ID-REF-VALUE" "*CLASS.ID-REF-VALUE*" "MAKE-ID-REF-VALUE"
+ "ID-REFS-ATTR-NODE" "IS-ID-REFS-ATTR-NODE" "*CLASS.ID-REFS-ATTR-NODE*" "MAKE-ID-REFS-ATTR-NODE"
+ "ID-VALUE" "IS-ID-VALUE" "*CLASS.ID-VALUE*" "MAKE-ID-VALUE"
+ "INFO-ITEM-NODE" "IS-INFO-ITEM-NODE" "*CLASS.INFO-ITEM-NODE*" "MAKE-INFO-ITEM-NODE"
+ "NMTOKEN-ATTR-NODE" "IS-NMTOKEN-ATTR-NODE" "*CLASS.NMTOKEN-ATTR-NODE*" "MAKE-NMTOKEN-ATTR-NODE"
+ "NMTOKENS-ATTR-NODE" "IS-NMTOKENS-ATTR-NODE" "*CLASS.NMTOKENS-ATTR-NODE*" "MAKE-NMTOKENS-ATTR-NODE"
+ "NOTATION-ATTR-NODE" "IS-NOTATION-ATTR-NODE" "*CLASS.NOTATION-ATTR-NODE*" "MAKE-NOTATION-ATTR-NODE"
+ "NOTATION-VALUE" "IS-NOTATION-VALUE" "*CLASS.NOTATION-VALUE*" "MAKE-NOTATION-VALUE"
+ "NS-NODE" "IS-NS-NODE" "*CLASS.NS-NODE*" "MAKE-NS-NODE"
+ "NUMBER-VALUE" "IS-NUMBER-VALUE" "*CLASS.NUMBER-VALUE*" "MAKE-NUMBER-VALUE"
+ "ORDINAL-NODE" "IS-ORDINAL-NODE" "*CLASS.ORDINAL-NODE*" "MAKE-ORDINAL-NODE"
+ "PI-NODE" "IS-PI-NODE" "*CLASS.PI-NODE*" "MAKE-PI-NODE"
+ "QNAME-ATTR-NODE" "IS-QNAME-ATTR-NODE" "*CLASS.QNAME-ATTR-NODE*" "MAKE-QNAME-ATTR-NODE"
+ "QNAME-CONTEXT" "IS-QNAME-CONTEXT" "*CLASS.QNAME-CONTEXT*" "MAKE-QNAME-CONTEXT"
+ "QNAME-VALUE" "IS-QNAME-VALUE" "*CLASS.QNAME-VALUE*" "MAKE-QNAME-VALUE"
+ "RECUR-DUR-ATTR-NODE" "IS-RECUR-DUR-ATTR-NODE" "*CLASS.RECUR-DUR-ATTR-NODE*" "MAKE-RECUR-DUR-ATTR-NODE"
+ "RECUR-DUR-VALUE" "IS-RECUR-DUR-VALUE" "*CLASS.RECUR-DUR-VALUE*" "MAKE-RECUR-DUR-VALUE"
+ "REF-CHARACTER-ENTITY" "IS-REF-CHARACTER-ENTITY" "*CLASS.REF-CHARACTER-ENTITY*" "MAKE-REF-CHARACTER-ENTITY"
+ "REF-ENTITY" "IS-REF-ENTITY" "*CLASS.REF-ENTITY*" "MAKE-REF-ENTITY"
+ "REF-GENERAL-ENTITY" "IS-REF-GENERAL-ENTITY" "*CLASS.REF-GENERAL-ENTITY*" "MAKE-REF-GENERAL-ENTITY"
+ "REF-NODE" "IS-REF-NODE" "*CLASS.REF-NODE*" "MAKE-REF-NODE"
+ "REF-PARAMETER-ENTITY" "IS-REF-PARAMETER-ENTITY" "*CLASS.REF-PARAMETER-ENTITY*" "MAKE-REF-PARAMETER-ENTITY"
+ "STRING-ATTR-NODE" "IS-STRING-ATTR-NODE" "*CLASS.STRING-ATTR-NODE*" "MAKE-STRING-ATTR-NODE"
+ "STRING-VALUE" "IS-STRING-VALUE" "*CLASS.STRING-VALUE*" "MAKE-STRING-VALUE"
+ "TIME-ATTR-NODE" "IS-TIME-ATTR-NODE" "*CLASS.TIME-ATTR-NODE*" "MAKE-TIME-ATTR-NODE"
+ "TIME-DUR-VALUE" "IS-TIME-DUR-VALUE" "*CLASS.TIME-DUR-VALUE*" "MAKE-TIME-DUR-VALUE"
+ "URI-REF-ATTR-NODE" "IS-URI-REF-ATTR-NODE" "*CLASS.URI-REF-ATTR-NODE*" "MAKE-URI-REF-ATTR-NODE"
+ "URI-REF-VALUE" "IS-URI-REF-VALUE" "*CLASS.URI-REF-VALUE*" "MAKE-URI-REF-VALUE"
+ "VALUE-NODE" "IS-VALUE-NODE" "*CLASS.VALUE-NODE*" "MAKE-VALUE-NODE"
+ ;; accessors
+ "URI"
+ "CHILDREN"
+ "ROOT"
+ "VALIDATE?"
+ "PARENT"
+ "DEF"
+ "DOCUMENT"
+ "EXPAND"
+ "NAMESPACES"
+ "ATTRIBUTES"
+ "PROPERTIES"
+ "NOTATION"
+ "ORDINALITY"
+ "MODEL"
+ "NODE-CLASS"
+ "NODE-VALIDATOR"
+ "VALUE"
+ "ENCODING"
+ "NODES"
+ "PREFIX"
+ "TARGET"
+ "DEREF"
+ "IS-FIXED"
+ "IS-REQUIRED"
+ "IS-IMPLIED"
+ "IS-EPHEMERAL"
+ "PROTOTYPE"
+ "STIPULATION"
+ "PROPS-DEFAULTED"
+ "PROPS-REQUIRED"
+
+ "VERSION"
+ "STANDALONE"
+ "SYSTEM-ID"
+ "PUBLIC-ID"
+ "NAMESPACE-NAME"
+ "LOCAL-NAME"
+
+ ;; additional accessors and abstract nodes which are not in the model
+ "ENTITIES"
+ "NOTATIONS"
+ "TYPES"
+ "ATTRIBUTES"
+ "PRECEDING-SIBLINGS"
+ "FOLLOWING-SIBLINGS"
+ "GENERAL-ENTITIES"
+ "PARAMETER-ENTITIES"
+ "NAMED-VALUE-NODE"
+ "ELEM-PROPERTY-NODE"
+ "ELEM-CHILD-NODE"
+ "DOC-CHILD-NODE"
+ "FUNCTION-VALUE"
+ "IS-FUNCTION-VALUE"
+ "EXPRESSION"
+ "CHARACTER-DATA-NODE"
+ "PI-NODES"
+ "COMMENT-NODES"
+ "CONTENT"
+ "ENTITY-INFO"
+ "REF-ELEM-NODE"
+ "REF-ELEM-PROPERTY-NODE"
+
+ "CLONE-NODE"
+ "LOCAL-PART"
+ "CHECK-CONSTRAINT"
+ "BIND-DEFINITION"
+ "COLLECT-MODEL-NAMES"
+ "FIRST-MODEL-NAME"
+ "ASSIGN-UNIVERSAL-NAMES"
+ "VALIDATE-CONTENT"
+
+ ;; serialization interface
+ "WRITE-NODE"
+ "*NODE-LEVEL*"
+ "*VERBOSE-QNAMES*"
+
+ "ELEMENT-APPEND"
+ "ELEMENT-GET"
+ "ELEMENT-SET"
+ "EXPORT-NAMES"
+ "FIND-ATTRIBUTE"
+ "FIND-ELEMENT"
+ "FIND-ELEMENT-BY-ID"
+ "FIND-NAME"
+ "FIND-NAMESPACE"
+ "FIND-PREFIX"
+ "INTERN-NAME"
+ "INTERN-PREFIX"
+ "INTERN-TYPE"
+ "MAKE-NAME"
+ "MAKE-QNAME"
+ "NAME"
+ "NAMESPACE"
+ "CONTENT-NAME-TYPE-NAME"
+
+ "*CONSTANT-PREFIX-STRINGS*"
+ "*DEF-NULL-NAMESPACE-NODE*"
+ "*DEFAULT-NAMESPACE-ATTRIBUTE-NAME*"
+ "*DEFAULT-PREFIX-NAME*"
+ "*DEFAULT-NAMESPACES*"
+ "*DEFAULT-NAMESPACE*"
+ "*DOCUMENT*"
+ "*ELEMENT-COUNT*"
+ "*EMPTY-NAME*"
+ "*GENERATED-NS-BINDINGS*"
+ "*INPUT-SOURCE*"
+ "*MIXED-NAME*"
+ "*NAMESPACE-BINDINGS*"
+ "*NAMESPACE-DICTIONARY*"
+ "*NAMESPACE-MODE*"
+ "*NAMESPACE*"
+ "*NULL-NAME*"
+ "*NULL-NAMESPACE*"
+ "*NULL-NAMESPACE-NODE*"
+ "*OUTPUT-DESTINATION*"
+ "*UNBINDABLE-PREFIX-STRINGS*"
+ "*XHTML-NAMESPACE*"
+ "*XMLNS-NAMESPACE*"
+ "*XML-NAMESPACE*"
+ "*XML-PREFIX-NAMESTRING*"
+ "*XMLNS-PREFIX-NAMESTRING*"
+ "*WILD-NAMESPACE*"
+ "*WILD-NAMESTRING*"
+ "*WILD-PREFIX*"
+ "*XML-NAMESPACE-ATTRIBUTE-NAME*"
+ "*XML-NAMESPACE-NODE*"
+ "*XMLNS-NAMESPACE-ATTRIBUTE-NAME*"
+ "*XMLNS-NAMESPACE-NODE*"
+ "*XSD-NAMESPACE*"
+ "PREFIX-VALUE"
+ "NAMESPACE-PREFIX"
+
+ ;; qualified name resolution
+ "*QNAME-EXTENT*"
+ "*DEF-TYPE-ID-QNAME-CONTEXTS*"
+ "*DEF-TYPE-MODEL-QNAME-CONTEXTS*"
+ "*DEF-ATTR-QNAME-CONTEXTS*"
+ "NEW-QNAME-EXTENT"
+ "QNAME-EXTENT"
+ "QNAME-EXTENT-EQUAL"
+ "*DISTINGUISH-QNAME-HOMOGRAPHS*"
+ "*CONFLATE-QNAME-SYNONYMS*"
+ "ACCUMULATE-QNAMES"
+ "ABSTRACT-NAME"
+ "UNAME"
+ "QNAME"
+
+ "VALUE-STRING"
+ "VALUE-NUMBER"
+ "VALUE-BOOLEAN"
+ "FIND-DEF-PARAMETER-ENTITY"
+ "FIND-DEF-GENERAL-ENTITY"
+ "FIND-DEF-ELEM-TYPE"
+ "FIND-DEF-NOTATION"
+
+ "IS-NAMECHARDATA"
+ "IS-NCNAME"
+
+ ;; utility functions
+ *SPECIALIZE-ELEM-NODE*
+ *SPECIALIZE-ATTR-NODE*
+ "*TOKEN-PACKAGE*"
+ "*WILD-NAME*"
+ "*WILD-UNAME*"
+ "*LANG-NAME*"
+ "!-reader"
+ "WALK-NODE"
+ "XML-ERROR"
+ "XML-EOF-ERROR"
+ "DOCUMENT-MODEL-ERROR"
+ "INTERNAL-XML-ERROR"
+ "VALIDITY-CERROR"
+ "VALIDITY-CONDITION"
+ "NAMESPACE-ERROR"
+ "WELLFORMEDNESS-ERROR"
+ "WELLFORMEDNESS-CERROR"
+ "SIMPLE-XML-ERROR"
+ "INCOMPLETE-PARSE"
+ "PRINT-QNAME"
+ "PRINT-NS-NODE"
+
+ "COLLECT-NODE-BY-TYPE"
+ "MAP-NODE-BY-TYPE"
+
+ "COLLECT-ATTRIBUTE-DECLARATIONS"
+ "COLLECT-ATTRIBUTES"
+ "COLLECT-COMMENTS"
+ "COLLECT-COMMENTS-AND-PIS"
+ "COLLECT-DECLARATIONS"
+ "COLLECT-ELEMENT-DECLARATIONS"
+ "COLLECT-ELEMENT-PROPERTIES"
+ "COLLECT-ELEMENTS"
+ "COLLECT-GENERAL-ENTITIES"
+ "COLLECT-NAMESPACES"
+ "COLLECT-NOTATIONS"
+ "COLLECT-PARAMETER-ENTITIES"
+ "COLLECT-PIS"
+
+ "UNAME-EQUAL"
+ "QNAME-EQUAL"
+ "NODE-EQUAL"
+ "MAKE-DOCUMENT-NAMESPACE-BINDINGS"
+ "content-model"
+ "|-content"
+ "?-content"
+ "*-content"
+ "bounded-content"
+ "MIXED-content"
+ "+-content"
+ "content"
+ ",-content"
+ "content-name"
+ "type-name"
+ "mixed-atn"
+ "element-atn"
+
+ ;; character classes
+ "XML-CHAR?"
+ "XML-SPACE?"
+ "XML-IDEOGRAPHIC?"
+ "XML-BASECHAR?"
+ "XML-LETTER?"
+ "XML-DIGIT?"
+ "XML-COMBININGCHAR?"
+ "XML-EXTENDER?"
+ "XML-NAMECHAR?"
+ "XML-INITIAL-NAMECHAR?"
+ "XML-PUBIDCHAR?"
+ "XML-MARKUPCHAR?"
+ "XML-LATINALPHACHAR?"
+ "XML-LATINCHAR?"
+ "XML-LANGUAGEIDCHAR?"
+ "XML-VERSIONNUMCHAR?"
+ "XML-MODEL-OP-CHAR?"
+ "XML-SUCCESSOR-EOLCHAR?"
+ "XML-INITIAL-EOLCHAR?"
+
+ ;; graphs
+ "WRITE-NODE-GRAPH"
+ "ENCODE-NODE-GRAPH"
+ "NODE-GRAPH-PROPERTIES"
+ "NODE-LINK-PROPERTIES"
+
+ ;; 0.950 compatibility
+ :annotation-model
+ :constant-prefix-p
+ :direct-annotation-model
+ :condition-name
+ :condition-namespace
+ :document
+ :document-element
+ :element-definition
+ :element-p
+ :general-entity-definition
+ :id-attr-node-p
+ :namespace-declaration
+ :namespace-equal
+ :parameter-entity-definition
+ :type-definition
+ :unbindable-prefix-p
+ :with-namespaces
+ :default-namespace
+ :*default-prefix-string*
+ :local-part-equal
+ :valid
+ :namespace-printname
+
+ ".//*"
+ ".//"
+ "./@"
+ "./@-STRING"
+ "./@-VALUE"
+ "./"
+ "./-STRING"
+ "./-VALUE"
+
+ ))
+
+(defPackage "XML-PARSER"
+ (:nicknames "XMLP"
+ :de.setf.xml
+ :de.setf.xml.interface
+ :de.setf.xml.codec.implementation
+ :de.setf.xml.process.implementation)
+ (:use "BNFP" #+CCL "CCL" "COMMON-LISP" "XQDM" "XUTILS")
+ #+CCL (:shadowing-import-from "XQDM" "TARGET")
+ (:export
+ "*CONSTRUCTION-CONTEXT*"
+ "*SPECIALIZE-ELEM-NODE*"
+ "*SPECIALIZE-ATTR-NODE*"
+ "AttCharData-Constructor"
+ "Attribute-Constructor"
+ "CALL-WITH-NAME-PROPERTIES"
+ "CharData-Constructor"
+ "CDataCharData-Constructor"
+ "Comment-Constructor"
+ "CONSTRUCT-ATTRIBUTE-NAME"
+ "CONSTRUCT-ATTRIBUTE-PLIST"
+ "CONSTRUCT-CONSTRUCTION-CONTEXT"
+ "CONSTRUCT-CONTENT-SEQUENCE"
+ "CONSTRUCT-ELEM-PROPERTY-NODE"
+ "CONSTRUCT-ELEMENT-NAME"
+ "CONSTRUCT-ELEMENT-NODE"
+ "CONSTRUCT-NS-NODE"
+ "CONSTRUCT-STRING-ATTR-NODE"
+ "Content-Constructor"
+ "ContentSequence-Constructor"
+ ;; the constructor method for attribute default values remains unexported
+ ;; until specialization is implemented for the DTD as a whole...
+ ;; "DefaultAttCharData-Constructor"
+ "DEFPIFUNCTION"
+ "Document-Constructor"
+ "DOCUMENT-PARSER"
+ "Element-Constructor"
+ "ENCODE-CHAR"
+ "ENCODE-FORMAT"
+ "ENCODE-NODE"
+ "ENCODE-STRING"
+ "ENCODE-NEWLINE"
+ "ExtParsedEnt-Constructor"
+ "Pi-Constructor"
+ "PI-FUNCTION"
+ "PiCharData-Constructor"
+ ;; "MAKE-NCNAME"
+ ;; "MAKE-UNAME"
+ "PARSE-EXTERNAL-ENTITY-DATA"
+ "PARSE-EXTERNAL-SOURCE"
+ "PARSE-EXTERNAL-SUBSET"
+ "PARSE-EXTERNAL-GENERAL-ENTITY"
+ "READ-EXTERNAL-ENTITY-DATA"
+ "STag-Constructor"
+ "WRITE-NODE"
+ "WRITER-STREAM"
+ "XML"
+ "*XML-WRITER-STREAM*"
+ "WITH-XML-WRITER"
+
+ ;; 0.950 compatibility
+ :prefix-namespace
+ )
+ )
+
+(defPackage "XML-PATH"
+ (:nicknames "XP")
+ (:use "BNFP" #+CCL "CCL" "COMMON-LISP" "XQDM" "XUTILS")
+ ;; the term 'step' is central to the standard so it is shadowed rather
+ ;; than using an alternative.
+ (:shadow "STEP")
+ #+CCL (:shadowing-import-from "XQDM" "TARGET")
+ (:EXPORT
+ "PATH" "STEP" "CONTEXT"
+ "PATH-ELEMENT" "STEP-ELEMENT" "STEP-GENERATOR" "STEP-FILTER"
+ "ENUMERATING-STEP-GENERATOR" "LIST-GENERATOR" "AXIS-GENERATOR"
+ "MAP-NODES" "NAME-TEST" "NODE-SET" "NODE-TEST" "TYPE-TEST"
+ "TERM" "IS-ABSOLUTE" "STEPS" "GENERATOR"
+ "TEST" "PREDICATES" "SOURCE" "PREFIX" "LOCAL-PART"
+ "STEP-GENERATOR-FUNCTION" "STEP-PREDICATE-FUNCTION"
+ "LITERAL"
+ "NODE" "LOCATION" "SIZE" "BINDINGS" "VARIABLES" "FUNCTIONS" "NAMESPACES"
+ "EXPRESSION"
+
+ "*CLASS.PATH*"
+ "*CLASS.STEP*"
+ "*CLASS.CONTEXT*"
+ "*CLASS.CHILD*"
+ "*DOCUMENTS*"
+ )
+ )
+
+(defPackage "XML-QUERY"
+ (:nicknames "XQ")
+ (:use "BNFP" #+CCL "CCL" "COMMON-LISP" "XQDM" "XUTILS")
+ #+CCL (:shadowing-import-from "XQDM" "TARGET")
+ )
+
+
+(defPackage "xml" (:use)
+ (:nicknames "http://www.w3.org/XML/1998/namespace")
+ (:export " " "!=" "!=" "!==" "\"" "#FIXED" "#IMPLIED" "#PCDATA" "#REQUIRED"
+ "$" "%" "&" "" "" "'" "(" "()" ")" ")*" "*" "*:" "+" ","
+ "-" "-->" "->" "." ".." "/" "//" "/>" ":" ":=" "::" ":*" ";" "<" "" ">=" "?" "?>"
+ "@" "AFTER" "ANY" "ASCENDING" "BEFORE" "CDATA" "DESCENDING" "EMPTY"
+ "ENTITIES" "ENTITY" "ID" "IDREF" "IDREFS" "IGNORE" "INCLUDE"
+ "NDATA" "NMTOKEN" "NMTOKENS" "NOT" "NOTATION" "PUBLIC" "SYSTEM"
+ "[" "]" "]]>" "^"
+ "ancestor" "ancestor-or-self" "and" "attribute"
+ "child" "comment"
+ "descendant" "descendant-or-self" "div" "document"
+ "encoding" "following" "following-sibling"
+ "id" "key" "lang"
+ "mixed" "mod" "namespace" "no" "node" "not" "or"
+ "parent" "preceding" "preceding-sibling" "processing-instruction"
+ "root" "self" "standalone" "text" "union" "version" "xml" "yes"
+ "{" "|" "}" "?"))
+;;
+;;
+;; packages for implementing xml data modeling.
+;; types from the datatype package appear in expression in the two algrbras. they are
+;; exported, but not used/imported, as the customary expression uses the prefix.
+;; the case distinctions distinguish grammatic meta-symbols which participate in special
+;; forms from the names for functions and types, which conserve case.
+
+;; package for xml query types
+(defPackage "XML-SCHEMA-DATATYPES" (:use) (:nicknames "XSD")
+ (:export "TYPEP" "TYPEP-SPECIALIZED"
+ "IS-anyComplexType" "IS-anySimpleType" "IS-anyTreeType" "IS-anyType" "IS-anyURI"
+ "IS-attribute" "IS-base64Binary" "IS-boolean" "IS-byte" "IS-comment" "IS-complex"
+ "IS-date" "IS-dateTime"
+ "IS-decimal" "IS-double" "IS-duration"
+ "IS-element" "IS-ENTITY" "IS-ENTITIES" "IS-float"
+ "IS-gDay" "IS-gMonth" "IS-gMonthDay" "IS-gYear"
+ "IS-hexBinary" "IS-ID" "IS-IDREF" "IS-IDREFS"
+ "IS-int" "IS-integer" "IS-language" "IS-long"
+ "IS-Name" "IS-NCName" "IS-NMTOKEN" "IS-NMTOKENS"
+ "IS-negativeInteger" "IS-nonNegativeInteger" "IS-nonPositiveInteger" "IS-normalizedString"
+ "IS-NOTATION" "IS-pi" "IS-positiveInteger" "IS-scalar" "IS-short" "IS-simple"
+ "IS-string" "IS-time" "IS-token" "IS-UName"
+ "IS-unsignedByte" "IS-unsignedInt" "IS-unsignedLong" "IS-unsignedShort"
+
+ "VALIDATE-STRING" "VALIDATE-ATTRIBUTE" "VALIDATE-NAME"))
+
+;; package for xml path "algebra" operators
+(defPackage "XML-PATH-ALGEBRA" (:use) (:nicknames "XPA")
+ (:import-from "xml" "document")
+ (:intern "APPLY-DESCENDANTS-PATH" "APPLY-CHILD-PATH" "APPLY-PATH"
+ "APPLY-PREDICATE-PATH" "APPLY-STEP"
+ "EVAL" "FUNCALL" "LANGUAGE-EQUAL" "NODES" "VARIABLE"
+ "SYMBOL-FUNCTION" "GENSYM")
+ (:export
+ ;; path components
+ "PATH" "STEP" "UNAME"
+ "ID-STEP" "KEY-STEP" "PARENT-STEP" "ROOT-STEP" "SELF-STEP" "WILD-INFERIOR-STEP"
+ "AXIS-GENERATOR" "LIST-GENERATOR"
+ "ANCESTOR" "ANCESTOR-OR-SELF" "ATTRIBUTE" "CHILD" "DESCENDANT"
+ "DESCENDANT-OR-SELF" "FOLLOWING" "FOLLOWING-OR-SELF" "FOLLOWING-SIBLING"
+ "ID" "KEY"
+ "NAMESPACE" "PARENT" "PRECEDING" "PRECEDING-SIBLING" "ROOT" "SELF"
+ "NAME-TEST" "@NAME-TEST" "TYPE-TEST" "TYPE-NAME-TEST"
+ "PI-TEST" "COMMENT-TEST" "TEXT-TEST"
+ "PREDICATE"
+ ;; state variables
+ "*CONTEXT-NODE*" "*POSITION*" "*COUNT*"
+ ;; library functions
+ "and"
+ "boolean"
+ "ceiling" "contains" "count"
+ "document"
+ "false" "floor"
+ "id"
+ "last" "local-name" "lang"
+ "mod"
+ "name" "namespace-uri" "normalize-space" "not" "number"
+ "or"
+ "position"
+ "round"
+ "starts-with" "string" "substring"
+ "substring-after" "substring-before"
+ "string-length" "sum"
+ "translate" "true"
+ "union"
+ "+" "-" "*" "/" "<" "<=" ">" ">=" "=" "!="
+ "NaN" "0+" "0-" "infinity+" "infinity-"
+ ))
+
+;; package for xml query algebra operators
+(defPackage "XML-QUERY-ALGEBRA" (:use) (:nicknames "XQA")
+ (:import-from "XPA"
+ "and"
+ "boolean"
+ "ceiling" "contains" "count"
+ "document"
+ "false" "floor"
+ "id"
+ "last" "local-name" "lang"
+ "mod"
+ "name" "namespace-uri" "normalize-space" "not" "number"
+ "or"
+ "position"
+ "round"
+ "starts-with" "string" "substring"
+ "substring-after" "substring-before"
+ "string-length" "sum"
+ "translate" "true"
+ "union"
+ ;; these are not imported "<" "<=" ">" ">=" "="
+ ;; as the comparison differs
+ "+" "-" "*" "/" "!="
+ "NaN" "0+" "0-" "infinity+" "infinity-"
+ "GENSYM")
+ (:EXPORT "IF" "LET" "ELSE" "FOR" "MATCH" "CASE" "WHERE"
+ "TYPE" "FUN" "QUERY"
+ "AND" "OR" "NOT" "DIV" "MOD" "SCHEMA"
+ "+" "-" "*" "<" "<=" ">" ">=" "=" "==" "!=" "!=="
+ "//" "/" "." "|"
+ "DEFUN"
+ "ATTRIBUTE" "ELEMENT"
+ "MAKE-NCNAME" "MAKE-TNAME" "MAKE-UNAME"
+ "sequence" "UNION" "DIFFERENCE" "INTERSECTION" "SORT"
+ "ERROR" "INSTANCEOF" "BEFORE" "AFTER"
+ "TYPEP" "TYPE" "SORT"
+ "TYPE-REF" "ID-TEST" "TYPEP" "RANGE-TEST"
+ ;; xpath algebra symbols
+ "and"
+ "boolean"
+ "cdata" "ceiling" "contains" "count"
+ "document"
+ "false" "floor"
+ "id"
+ "last" "local-name" "lang"
+ "mod"
+ "name" "namespace-uri" "normalize-space" "not" "number"
+ "or"
+ "position"
+ "round"
+ "starts-with" "string" "substring"
+ "substring-after" "substring-before"
+ "string-length" "sum"
+ "translate" "true"
+ "union"
+ "NaN" "0+" "0-" "infinity+" "infinity-"
+ ;; xml query algebra specific
+ "avg"
+ "bagtolist"
+ "data" "difference" "distinct_nodes" "distinct_value"
+ "comment" "Comment" "deref"
+ "except"
+ "index" "intersection"
+ "listtobag" "localname"
+ "max" "min"
+ "namespace" "nodes"
+ "parent" "processing_instruction"
+ "ref"
+ "sequence" "sort"
+ "target"
+ "value"
+
+
+ "empty"
+ "==" ))
+
+(defPackage "$" (:use))
+
+(defpackage "XML-QUERY-LANGUAGE" (:use) (:nicknames "XQL")
+ (:import-from "XPA"
+ "and"
+ "boolean"
+ "ceiling" "contains" "count"
+ "document"
+ "false" "floor"
+ "id"
+ "last" "local-name" "lang"
+ "mod"
+ "name" "namespace-uri" "normalize-space" "not" "number"
+ "or"
+ "position"
+ "round"
+ "starts-with" "string" "substring"
+ "substring-after" "substring-before"
+ "string-length" "sum"
+ "translate" "true"
+ "union"
+ "+" "-" "*" "/" "!="
+ "NaN" "0+" "0-" "infinity+" "infinity-")
+ (:import-from "XQA"
+ "<" "<=" ">" ">=" "=")
+ (:export "ELEMENT" "ATTRIBUTE" "CAST" "TREAT" "INTERSECT" "EXCEPT"
+ "INSTANCEOF" "SOME" "EVERY" "FUNCTION"
+ "FUNCALL" "NAMESPACE-DECL" "QNAME" "SCHEMA-DECL"
+ "ID-PATH" "ATTRIBUTE-PATH" "TYPE-PATH" "ELEMENT-PATH"
+ "RANGE" "/" "//" "*" "STEP" "TYPE"
+ ;; xpath algebra symbols
+ "and"
+ "boolean"
+ "ceiling" "contains" "count"
+ "document"
+ "false" "floor"
+ "id"
+ "last" "local-name" "lang"
+ "mod"
+ "name" "namespace-uri" "normalize-space" "not" "number"
+ "or"
+ "position"
+ "round"
+ "starts-with" "string" "substring"
+ "substring-after" "substring-before"
+ "string-length" "sum"
+ "translate" "true"
+ "union"
+ "+" "-" "*" "/" "<" "<=" ">" ">=" "=" "!="
+ "NaN" "0+" "0-" "infinity+" "infinity-"
+ ;; xquery language library
+ "comment" "date" "distinct"
+ "empty" "equal" "filter" "last"
+ "name" "number" "pi" "union"))
+
+
+;; additions for cl-http tokenizer
+#-CL-HTTP
+(defpackage "WWW-UTILS"
+ (:use common-lisp)
+ (:intern "WITH-FAST-ARRAY-REFERENCES" "MAKE-LOCK" "WITH-LOCK-HELD"))
+
+#-CL-HTTP
+(defpackage tk1
+ (:use common-lisp)
+ (:import-from "WWW-UTILS" "WITH-FAST-ARRAY-REFERENCES" "MAKE-LOCK" "WITH-LOCK-HELD")
+ (:export
+ "*DEFAULT-TOKENIZER-SIZE*"
+ "CLEAR-TOKENIZER"
+ "CREATE-TOKENIZER"
+ "DEFINE-TOKENIZER"
+ "DESCRIBE-TOKENIZER"
+ "FIND-TOKENIZER-NAMED"
+ "GET-TOKEN"
+ "INSERT-TOKEN"
+ "MAP-TOKENS"
+ "REHASH-TOKENIZER"
+ "REMOVE-TOKEN"
+ "TOKENIZE"
+ "UNDEFINE-TOKENIZER"))
+
+#-CL-HTTP
+(defPackage "HTTP"
+ (:export "*STANDARD-CHARACTER-TYPE*"))
+
+:EOF
+
+
From banderson at common-lisp.net Tue Feb 14 17:56:22 2006
From: banderson at common-lisp.net (banderson at common-lisp.net)
Date: Tue, 14 Feb 2006 11:56:22 -0600 (CST)
Subject: [cl-xml-cvs] r11 - branches/sbcl-0.9.x-testing/code/base
Message-ID: <20060214175622.02A4E6F00B@common-lisp.net>
Author: banderson
Date: Tue Feb 14 11:56:21 2006
New Revision: 11
Modified:
branches/sbcl-0.9.x-testing/code/base/utils.lisp
Log:
bad hack to get around endless loop - this is *not* the permanent solution, because James Anderson already reported it doesn't work for his Lisp (some *MCL). However, this works for SBCL.
Modified: branches/sbcl-0.9.x-testing/code/base/utils.lisp
==============================================================================
--- branches/sbcl-0.9.x-testing/code/base/utils.lisp (original)
+++ branches/sbcl-0.9.x-testing/code/base/utils.lisp Tue Feb 14 11:56:21 2006
@@ -393,7 +393,7 @@
(setf default-host (host-string defaults)
default-path (path defaults))
(return))
- (string (setf defaults (make-uri defaults nil)))
+ (string (return)) ;;(setf defaults (make-uri defaults nil)))
(pathname (setf defaults (pathname-file-url defaults)))
(urn (return))
(null (return))))
@@ -590,6 +590,11 @@
"allow host, ignore device, which should be :unspecific"
(let ((host (pathname-host pathname)))
(when (eq host :unspecific) (setf host nil))
+ #+sbcl
+ (progn
+ (setf host nil)
+ (setf pathname (translate-logical-pathname pathname)))
+
(pathname-file-url (format nil "file://~@[~a~]/~{~a/~}~a~@[.~a~]"
host
(rest (pathname-directory pathname))
From banderson at common-lisp.net Tue Feb 14 17:57:14 2006
From: banderson at common-lisp.net (banderson at common-lisp.net)
Date: Tue, 14 Feb 2006 11:57:14 -0600 (CST)
Subject: [cl-xml-cvs] r12 - in branches/sbcl-0.9.x-testing: . code/base
library library/de/setf/utility
Message-ID: <20060214175714.CC82E6F00B@common-lisp.net>
Author: banderson
Date: Tue Feb 14 11:57:14 2006
New Revision: 12
Added:
branches/sbcl-0.9.x-testing/cl-xml.asd
Modified:
branches/sbcl-0.9.x-testing/code/base/parameters.lisp
branches/sbcl-0.9.x-testing/library/de/setf/utility/conditions.lisp
branches/sbcl-0.9.x-testing/library/define-system.lisp
branches/sbcl-0.9.x-testing/load.lisp
branches/sbcl-0.9.x-testing/sysdcl.lisp
Log:
rest of changes/hacks for CL-XML to work with SBCL 0.9.8
Added: branches/sbcl-0.9.x-testing/cl-xml.asd
==============================================================================
--- (empty file)
+++ branches/sbcl-0.9.x-testing/cl-xml.asd Tue Feb 14 11:57:14 2006
@@ -0,0 +1,48 @@
+;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
+
+(defpackage #:cl-xml-system
+ (:use #:cl #:asdf))
+
+(in-package #:cl-xml-system)
+
+;; set some options
+(pushnew :xml-symbols *features*)
+(setf *features* (remove :nameset-tokenizer *features*))
+
+;; system
+(defsystem cl-xml
+ :description "Common Lisp support for the 'Extensible Markup Language'"
+ :author "James Anderson "
+ :version "0.949"
+ :licence "LGPL"
+ :components
+ ((:module
+ :library
+ :components
+ ((:file "define-system")))
+ (:file "sysdcl" :depends-on (:library))
+ (:file "load" :depends-on ("sysdcl"))))
+;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
+
+(defpackage #:cl-xml-system
+ (:use #:cl #:asdf))
+
+(in-package #:cl-xml-system)
+
+;; set some options
+(pushnew :xml-symbols *features*)
+(setf *features* (remove :nameset-tokenizer *features*))
+
+;; system
+(defsystem cl-xml
+ :description "Common Lisp support for the 'Extensible Markup Language'"
+ :author "James Anderson "
+ :version "0.949"
+ :licence "LGPL"
+ :components
+ ((:module
+ :library
+ :components
+ ((:file "define-system")))
+ (:file "sysdcl" :depends-on (:library))
+ (:file "load" :depends-on ("sysdcl"))))
Modified: branches/sbcl-0.9.x-testing/code/base/parameters.lisp
==============================================================================
--- branches/sbcl-0.9.x-testing/code/base/parameters.lisp (original)
+++ branches/sbcl-0.9.x-testing/code/base/parameters.lisp Tue Feb 14 11:57:14 2006
@@ -77,7 +77,7 @@
(defVar *xml-base* nil
"binds the base uri to serve as the context when resoving identifiers to URLs.
- parsers bind it to each entity's url to enable rrealtive url references.")
+ parsers bind it to each entity's url to enable relative url references.")
(defVar *xml-verbose* nil
"controls diagnostic messages.")
Modified: branches/sbcl-0.9.x-testing/library/de/setf/utility/conditions.lisp
==============================================================================
--- branches/sbcl-0.9.x-testing/library/de/setf/utility/conditions.lisp (original)
+++ branches/sbcl-0.9.x-testing/library/de/setf/utility/conditions.lisp Tue Feb 14 11:57:14 2006
@@ -23,6 +23,9 @@
;; patch restrictive condition implementations
+#+(and sbcl sb-package-locks)
+(sb-ext:unlock-package :cl)
+
(let ((def (fdefinition 'SIMPLE-CONDITION-FORMAT-ARGUMENTS)))
(unless (typep def 'generic-function)
(warn "redefining SIMPLE-CONDITION-FORMAT-ARGUMENTS")
@@ -46,6 +49,8 @@
(defGeneric SIMPLE-CONDITION-FORMAT-string (condition)
(:method ((condition t)) (funcall def condition))))))
+#+(and sbcl sb-package-locks)
+(sb-ext:lock-package :cl)
;;
Modified: branches/sbcl-0.9.x-testing/library/define-system.lisp
==============================================================================
--- branches/sbcl-0.9.x-testing/library/define-system.lisp (original)
+++ branches/sbcl-0.9.x-testing/library/define-system.lisp Tue Feb 14 11:57:14 2006
@@ -18,8 +18,6 @@
(defParameter *physical-binary-type*
(pathname-type (compile-file-pathname (make-pathname :name "source" :type *physical-source-type*))))
-#+sbcl
-(setq sb-fasl:*fasl-file-type* "sbcfsl")
(defMacro define-system ((name &key description) (&rest operations) &body files)
(if operations
@@ -98,10 +96,10 @@
(call-with-src-and-bin
#'(lambda (filename src bin probed-src probed-bin)
(if probed-src
- (defsys-message *trace-output*
- "~%; ~s~@[ (@ ~/print-universal-time/)~] -> ~s (~:[missing~;~1:*@ ~/print-universal-time/~])..."
- probed-src (file-write-date probed-src) bin (when probed-bin (file-write-date probed-bin)))
- (warn "file missing: ~s (= ~s)." filename src)))
+ (defsys-message *trace-output*
+ "~%; ~s~@[ (@ ~/print-universal-time/)~] -> ~s (~:[missing~;~1:*@ ~/print-universal-time/~])..."
+ probed-src (file-write-date probed-src) bin (when probed-bin (file-write-date probed-bin)))
+ (warn "file missing: ~s (= ~s)." filename src)))
filename))
(defun system-p (datum)
Modified: branches/sbcl-0.9.x-testing/load.lisp
==============================================================================
--- branches/sbcl-0.9.x-testing/load.lisp (original)
+++ branches/sbcl-0.9.x-testing/load.lisp Tue Feb 14 11:57:14 2006
@@ -2,23 +2,24 @@
(in-package :CL-USER)
-;;; load configuration without CL-HTTP and with name symbols:
+;; FIXME: sbcl/clc only right now BSA
+(let ((path "/usr/share/common-lisp/source/cl-xml/"))
-#+CL-HTTP
-(cerror "continue load."
- "this is intended to load a configuration without CL-HTTP, yet CL-HTTP is present.")
-
-(load (merge-pathnames (make-pathname :name "define-system" :directory '(:relative "library"))
- *load-pathname*))
-
-(register-system-definition :xparser (merge-pathnames (make-pathname :name "sysdcl") *load-pathname*))
-
-(pushnew :xml-symbols *features*)
-(setf *features* (remove :nameset-tokenizer *features*))
-(execute-system-operations :xparser '(:compile :load))
-
-(format *trace-output* "~%cl xml loaded:~%~s" *features*)
-
-;(execute-system-operations :xtests '( :load))
-
-:EOF
+;; (or (when *load-truename*
+;; (directory-namestring *load-truename*) )
+;; *default-pathname-defaults*)))
+
+;; (format t "~%~%path: ~a~%~%" path)
+ (format t "~%~%path: ~a~%~%" (merge-pathnames (make-pathname :name "sysdcl") path))
+
+ (register-system-definition :xparser
+ (merge-pathnames
+ (make-pathname :name "sysdcl")
+ path))
+ (execute-system-operations :xparser '(:compile :load))
+
+ (register-system-definition :xpath
+ (merge-pathnames
+ (make-pathname :name "sysdcl")
+ path))
+ (execute-system-operations :xpath '(:compile :load)))
Modified: branches/sbcl-0.9.x-testing/sysdcl.lisp
==============================================================================
--- branches/sbcl-0.9.x-testing/sysdcl.lisp (original)
+++ branches/sbcl-0.9.x-testing/sysdcl.lisp Tue Feb 14 11:57:14 2006
@@ -1 +1,414 @@
-;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: cl-user; -*-
#|
implementation packages for
- XQDM: an xml document model which follows the xml-query document
model.
- XQ: a serializer (parser/reader and writer functions) for the document
aspects of xml-query algebra expressions based on the XQDM.
- XPATH: a parser/reader and interpreter for xpath expressions.
- XMLP: a parser for xml expressions based onthe XQDM.
This library is free software;
With the exceptions noted below, you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version,
as ammended below.
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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser 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
The terms of the GNU Lesser General Public License are ammended to include
the stipulation, as paragraph 2.e, that any modifications to the library for
the purpose of correcting bugs must be returned to the copyright holder
for inclusion in future versions of the library.
the license terms for tokenizer implementation are described in the
respective source file.
the www-consortium retains license rights to the respective bnf.
it is distributed herewith under the terms of their software license.
the www-consortium retains license rights to the respective bnf.
it is distributed herewith under the terms of their software license.
the www-consortium retains license rights to the respective bnf.
it is distributed herewith under the terms of their software license.
for information on this module, please contact the author.
lispworks/ansi conformance
CL-HTTP in ALLEGRO
xml-writer
vector-stream moved to utils for data-url support
xparser tokenizers
0.912+lw/allegro tests
first-level tokenization
fixes for instance name compilation;
lispworks comm package(including conditionalization 20020115)
lispworks charachter element set for two-byte characters
|#
(in-package "CL-USER")
(eval-when (:load-toplevel :compile-toplevel :execute)
(let* ((defaults
#+allegro (or *load-truename* *load-pathname* *compile-file-truename*)
#+ccl *load-truename*
#+cmu *load-truename*
#+cormanlisp #p"d:\\Source\\Lisp\\XML-0-918\\sysdcl.lisp"
#+lispWorks (truename (lw:current-pathname))
#+sbcl (or *load-truename* *load-pathname*)
)
(bin-target nil)
(root-target (make-pathname :name :wild :type :wild :version :newest
:directory (append (pathname-directory defaults)
'(:wild-inferiors))
:defaults defaults)))
;; w/o bootstrap lispworks collapsed the bin target to host and type
(setf (logical-pathname-translations "xml")
`(("root;**;*.*.*" ,root-target)))
(setf bin-target
(make-pathname :name :wild
:type (pathname-type (compile-file-pathname "xml:name.lisp"))
:version :newest
:defaults
#+digitool "xml:root;bin;digifasl;**;*.*.*"
#+(and mcl m68k) "xml:root;bin;digim68kfasl;**;*.*.*"
#+(and allegro allegro-version>= (not (version>= 6 0))) "xml:root;bin;acl5fasl;**;*.*.*"
#+(and allegro allegro-version>= (version>= 6 0)) "xml:root;bin;acl6fasl;**;*.*.*"
#+(and lispworks (not mac)) "xml:root;bin;lwfasl;**;*.*.*"
#+(and lispworks mac) "xml:root;bin;lwppcfasl;**;*.*.*"
#+cormanlisp "xml:root;bin;corfasl;**;*.*.*"
#+openmcl "xml:root;bin;omclfasl;**;*.*.*"
#+cmu "xml:root;bin;cmuclfasl;**;*.*.*"
#+sbcl "xml:root;bin;sbclfasl;**;*.*.*"
))
(when *load-verbose*
(format *trace-output* "~%load defaults: ~s.~%compile target: ~s."
defaults bin-target))
(setf (logical-pathname-translations "xml")
`(("**;*.bin.*" ,bin-target)
("**;*.BIN.*" ,bin-target)
("code;**;*.*.*" "xml:root;code;**;*.*.*")
("root;**;*.*.*" ,root-target)
("**;*.bnf.*" "xml:root;bnf;*.*.*")
("**;*.BNF.*" "xml:root;bnf;*.*.*")
("**;*.*.*" "xml:root;**;*.*.*")))
(unless (ignore-errors (LOGICAL-PATHNAME-TRANSLATIONS "Packages"))
(setf (logical-pathname-translations "Packages")
`(("**;*.bin.*" ,bin-target)
("**;*.BIN.*" ,bin-target)
("**;*.*.*" "xml:Library;**;*.*")
("*.*.*" "xml:Library;**;*.*"))))
))
;; configuration
;;
#+CL-HTTP ;; nb. this check is effective in the fasl only
(unless (find :cl-http *features*)
(warn "CL-HTTP not present."))
;;
;; network access
#+(and MCL (not CL-HTTP) (not openmcl))
(eval-when (:compile-toplevel :load-toplevel :execute)
(define-declaration values nil)
(define-declaration arglist nil)
(require "OPENTRANSPORT"))
#+openmcl
(progn
(define-declaration values nil)
(define-declaration arglist nil))
#+(and ALLEGRO (not CL-HTTP))
(eval-when (:compile-toplevel :load-toplevel :execute)
(require "SOCK"))
#+LispWorks
(eval-when (:compile-toplevel :load-toplevel :execute)
(require "comm"))
;; to indicate whether or not to model names as symbols or as instances
;; (pushnew :xml-symbols *features*)
;; to specify the instance names should use tokenizers
(pushnew :nameset-tokenizer *features*)
;; to indicate that all name and string characters are to be checked for legality
;; (pushnew :xml-check-char-codes *features*)
#+Allegro
(when (< excl:real-char-code-limit 65535)
(pushnew :xml-check-char-codes *features*))
#-Allegro
(when (< char-code-limit 65535)
(pushnew :xml-check-char-codes *features*))
#|
;; 20020410.jaa setting the value globally turns out to be inappropriate.
;; the alternative, dynamical binding, is said to be insufficient to affect internal
;; state.
#+LispWorks
(lw:set-default-character-element-type 'lw:simple-char)
;; should that change, the alternative would have been
#+LispWorks ; cause lispworks to use wide-character strings
(lw:*default-character-element-type* 'lw:simple-char)
|#
#+cmu
(progn
(require :gray-streams)
(setq extensions:*inline-expansion-limit* 2)
)
#+sbcl
(progn
(require :gray-streams)
(setq *inline-expansion-limit* 2)
)
#+ccl-5-0-and-0-918
(setq CCL::*CHECK-SLOT-TYPE* nil)
;; the atn-bnf parser must be loaded in order to translate grammars,
;; for regular expressions, and for validation. this is reflected in it presence
;; in the :xparser definition below.
;; nb. this should be refined to load only the minimum for runtime use
(eval-when (:compile-toplevel :execute :load-toplevel)
(define-system
(:base)
()
"xml:code;patch;cmucl"
"xml:library;de;setf;utility;package"
"xml:library;de;setf;utility;string"
"xml:library;de;setf;utility;conditions"
"xml:library;de;setf;utility;test"
"xml:code;base;package"
)
(define-system
(:bnfp)
()
:base
; merged into common package file "xml:code;packages;atn-package"
"xml:code;atn-parser;clifs;inference-system-classes"
"xml:code;atn-parser;clifs;inference-units"
"xml:code;atn-parser;atn-parameters"
"xml:code;atn-parser;atn-classes"
"xml:code;atn-parser;atn-macros"
"xml:code;atn-parser;ebnf-tokenizer"
"xml:code;atn-parser;ebnf-to-atn-translator"
"xml:code;atn-parser;atn-macro-to-canonic-form"
"xml:code;atn-parser;ebnf-grammar.atn" ;; the bnf grammar is coded in a "atn" syntax lisp file.
"xml:code;atn-parser;atn-runtime"
"xml:code;atn-parser;conditions"
"xml:code;atn-parser;atn-lisp-compiler"
"xml:code;atn-parser;atn-regex"
;; the java translator is present here as documentation, as of 20010208 it has
;; not been reintegrated with the changes to compile to lisp.
#+bnfp-java "xml:code;atn-parser;atn-java-compiler"
)
(define-system
(:xutil :description "xml base utilities")
()
:bnfp
"xml:code;base;parameters"
"xml:code;base;cllib"
#+CL-HTTP "xml:code;base;cl-http-utils"
"xml:code;base;utils"
"xml:code;base;parsetable"
"xml:code;base;vector-stream"
#-CL-HTTP "xml:code;base;www-utils-ersatz"
#-CL-HTTP "xml:code;base;tokenizer"
"xml:code;base;conditions")
(define-system
(xqdm :description "model from the x-query data model")
()
:xutil
;; for 0.918 namespaces operations must be defined first
"xml:code;xquerydatamodel;xqdm-namespaces"
"xml:code;xquerydatamodel;xqdm-parameters"
"xml:code;xquerydatamodel;xqdm-character-classes"
"xml:code;xquerydatamodel;xqdm-classes"
"xml:code;xquerydatamodel;xsd-types"
"xml:code;xquerydatamodel;conditions;names;conditions"
"xml:code;xquerydatamodel;conditions;node;conditions"
"xml:code;xquerydatamodel;conditions;model;conditions"
"xml:code;xquerydatamodel;xqdm-operators"
;; "xml:code;xquerydatamodel;xqdm-qnames"
"xml:code;xquerydatamodel;xqdm-validation"
"xml:code;xquerydatamodel;qname-resolution"
"xml:code;xquerydatamodel;xqdm-graph"
"xml:code;xquerydatamodel;node-path-walk"
"xml:code;xquerydatamodel;xqdm-walk"
"xml:code;xquerydatamodel;xqdm-walk-accessors")
(define-system
(xparser :description "xml processor: parsing/serialization for xqdm with standard encoding")
()
:xutil :xqdm
"xml:code;xparser;xml-parameters"
"xml:code;xparser;conditions;codec;conditions"
"xml:code;xparser;xml-stream-coding"
"xml:code;xparser;xml-operators"
"xml:code;xparser;xml-readers"
"xml:code;xparser;xml-tokenizer"
"xml:code;xparser;xml-processing-instruction"
"xml:code;xparser;xml-constructors"
"xml:code;xparser;xml-parser"
"xml:code;xparser;xml-printer"
"xml:code;xparser;xml-writer")
(define-system
(:xpath :description "xml path model and encoding to extend the processor")
()
:xparser
"xml:code;xpath;xpath-parameters"
"xml:code;xpath;xpath-tokenizer"
"xml:code;xpath;xpath-classes"
"xml:code;xpath;xpath-operators"
"xml:code;xpath;xpath-constructors"
"xml:code;xpath;xpath-parser"
"xml:code;xpath;xpath-printer"
"xml:code;xpath;xpath-library")
(define-system
(:xquery :description "xml query processor based on xml processor and xml path")
()
:xparser :xpath
"xml:code;xquery;xq-parameters"
"xml:code;xquery;xqa-classes"
"xml:code;xquery;xqa-operators"
"xml:code;xquery;xql-operators"
"xml:code;xquery;xqa-library"
"xml:code;xquery;xql-library"
"xml:code;xquery;xql-tokenizer"
"xml:code;xquery;xql-constructors"
"xml:code;xquery;xql-parser"
"xml:code;xquery;xq-printer"
)
(define-system
(:xtests
:description
"loads test files")
()
:xparser
"xml:tests;xquerydatamodel;model"
"xml:tests;parser;bom"
"xml:tests;parser;document-internal"
"xml:tests;parser;document-external"
"xml:tests;parser;document-specialized"
"xml:tests;parser;qnames.lisp"
"xml:tests;parser;validation.lisp"
"xml:tests;parser;namespaces.lisp"
"xml:tests;parser;oasis.lisp"
)
(define-system
(:xrelease
:description
"loads test files")
()
:xtests
"xml:code;base;release"
"xml:*.lisp"
"xml:demos;**;*.*"
"xml:library;define-system.lisp"
"xml:**;*.bnf"
"xml:**;*.htm"
"xml:**;*.gif"
"xml:**;*.xql"
"xml:**;*.xml*"
"xml:**;*.dtd"
"xml:**;*.xmlq"
"xml:**;*.txt"
)
(define-system
(:xconformance
:description
"incorporates conformance data files")
()
"xml:standards;XML;XMLConf;**;*.xml"
"xml:standards;XML;XMLConf;**;*.mod"
"xml:standards;XML;XMLConf;**;*.dtd"
"xml:standards;XML;XMLConf;**;*.ent"
"xml:standards;XML;REC-xml-20001006.xml"
"xml:standards;XML;xmlspec-v21.dtd"
"xml:standards;XML;W3CSchema;*.xsd"
"xml:standards;XML;W3CSchema;*.dtd"
"xml:standards;XML;XHTML-MODULAR;**;*.*"
)
)
;; see also xml:tests;test.lisp
;; (load "entwicklung at paz:sourceServer:lisp:xml:define-system.lisp")
;; (register-system-definition :xparser "entwicklung at paz:sourceServer:lisp:xml:sysdcl.lisp")
;; (execute-system-operations :xutil '(:load))
;; (execute-system-operations :xparser '(:load))
;; to test if the pathnames are ok.
;; (execute-system-operations :xparser '(:probe))
;; to load
;; (execute-system-operations :xparser '(:load))
;; (execute-system-operations :xquery '(:load))
;; to compile / load
;; (execute-system-operations :xparser '(:compile))
;; (execute-system-operations :xparser '(:compile :load))
;; (execute-system-operations :xquery '(:compile :load))
;; (execute-system-operations :xquery #'print)
;; (translate-logical-pathname "xml:xxx;yyy;xml-grammar.bnf")
;; (translate-logical-pathname "xml:bnfp;sysdcl")
;; (translate-logical-pathname "xml:code;xquery;xq-printer.lisp")
;; (translate-logical-pathname "xml:code;xquery;xq-printer.bin")
;; (translate-logical-pathname "xml:demo;xq-printer.lisp")
;; (translate-logical-pathname "xml:demo;xq-printer.bin")
:EOF
\ No newline at end of file
+;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: cl-user; -*-
+
+#|
+
+
+ implementation packages for
+
+ - XQDM: an xml document model which follows the xml-query document
+ model.
+ - XQ: a serializer (parser/reader and writer functions) for the document
+ aspects of xml-query algebra expressions based on the XQDM.
+ - XPATH: a parser/reader and interpreter for xpath expressions.
+ - XMLP: a parser for xml expressions based onthe XQDM.
+
+
+
+
+
+ This library is free software;
+ With the exceptions noted below, you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version,
+ as ammended below.
+
+ 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser 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
+
+ The terms of the GNU Lesser General Public License are ammended to include
+ the stipulation, as paragraph 2.e, that any modifications to the library for
+ the purpose of correcting bugs must be returned to the copyright holder
+ for inclusion in future versions of the library.
+
+
+ the license terms for tokenizer implementation are described in the
+ respective source file.
+
+
+ the www-consortium retains license rights to the respective bnf.
+ it is distributed herewith under the terms of their software license.
+
+ the www-consortium retains license rights to the respective bnf.
+ it is distributed herewith under the terms of their software license.
+
+ the www-consortium retains license rights to the respective bnf.
+ it is distributed herewith under the terms of their software license.
+
+
+ for information on this module, please contact the author.
+
+
+
+ lispworks/ansi conformance
+
+ CL-HTTP in ALLEGRO
+ xml-writer
+ vector-stream moved to utils for data-url support
+ xparser tokenizers
+ 0.912+lw/allegro tests
+ first-level tokenization
+ fixes for instance name compilation;
+ lispworks comm package(including conditionalization 20020115)
+ lispworks charachter element set for two-byte characters
+
+
+
+|#
+
+(in-package "CL-USER")
+
+(eval-when (:load-toplevel :compile-toplevel :execute)
+ (let* ((defaults
+ #+allegro (or *load-truename* *load-pathname* *compile-file-truename*)
+ #+ccl *load-truename*
+ #+cmu *load-truename*
+ #+cormanlisp #p"d:\\Source\\Lisp\\XML-0-918\\sysdcl.lisp"
+ #+lispWorks (truename (lw:current-pathname))
+ #+(and sbcl (not asdf)) (or *compile-file-pathname* *load-pathname* *default-pathname-defaults*)
+ #+(and sbcl asdf) (format nil "~acl-xml/" clc::*source-root*))
+ (bin-target nil)
+ (root-target (make-pathname :name :wild :type :wild :version :newest
+ :directory (append (pathname-directory defaults)
+ '(:wild-inferiors))
+ :defaults defaults)))
+ ;; w/o bootstrap lispworks collapsed the bin target to host and type
+ (setf (logical-pathname-translations "xml")
+ `(("root;**;*.*.*" ,root-target)))
+ (setf bin-target
+ (make-pathname :name :wild
+ :type (pathname-type (compile-file-pathname "xml:name.lisp"))
+ :version :newest
+ :defaults
+;; #-asdf
+;; (progn
+ #+digitool "xml:root;bin;digifasl;**;*.*.*"
+ #+(and mcl m68k) "xml:root;bin;digim68kfasl;**;*.*.*"
+ #+(and allegro allegro-version>= (not (version>= 6 0))) "xml:root;bin;acl5fasl;**;*.*.*"
+ #+(and allegro allegro-version>= (version>= 6 0)) "xml:root;bin;acl6fasl;**;*.*.*"
+ #+lispworks "xml:root;bin;lwfasl;**;*.*.*"
+ #+cormanlisp "xml:root;bin;corfasl;**;*.*.*"
+ #+openmcl "xml:root;bin;omclfasl;**;*.*.*"
+ #+cmu "xml:root;bin;cmuclfasl;**;*.*.*"
+ #+sbcl "xml:root;bin;sbclfasl;**;*.*.*"
+;; )
+;; #+asdf
+;; (progn
+;; (if (find-package :clc)
+;; (format nil "~acl-xml/bin/" clc::*fasl-root*)
+;; "xml:root;bin;sbclfasl;**;*.*.*")) ;; FIXME for non clc
+ ))
+ (when *load-verbose*
+ (format *trace-output* "~%load defaults: ~s.~%compile target: ~s."
+ defaults bin-target))
+ (setf (logical-pathname-translations "xml")
+ `(("**;*.bin.*" ,bin-target)
+ ("**;*.BIN.*" ,bin-target)
+ ("code;**;*.*.*" "xml:root;code;**;*.*.*")
+ ("root;**;*.*.*" ,root-target)
+ ("**;*.bnf.*" "xml:root;bnf;*.*.*")
+ ("**;*.BNF.*" "xml:root;bnf;*.*.*")
+ ("**;*.*.*" "xml:root;**;*.*.*")))
+
+ (unless (ignore-errors (LOGICAL-PATHNAME-TRANSLATIONS "Packages"))
+ (setf (logical-pathname-translations "Packages")
+ `(("**;*.bin.*" ,bin-target)
+ ("**;*.BIN.*" ,bin-target)
+ ("**;*.*.*" "xml:Library;**;*.*")
+ ("*.*.*" "xml:Library;**;*.*"))))
+ ))
+
+;; configuration
+;;
+
+#+CL-HTTP ;; nb. this check is effective in the fasl only
+(unless (find :cl-http *features*)
+ (warn "CL-HTTP not present."))
+
+;;
+;; network access
+#+(and MCL (not CL-HTTP) (not openmcl))
+(eval-when (:compile-toplevel :load-toplevel :execute)
+ (define-declaration values nil)
+ (define-declaration arglist nil)
+ (require "OPENTRANSPORT"))
+
+#+openmcl
+(progn
+ (define-declaration values nil)
+ (define-declaration arglist nil))
+
+#+(and ALLEGRO (not CL-HTTP))
+(eval-when (:compile-toplevel :load-toplevel :execute)
+ (require "SOCK"))
+#+LispWorks
+(eval-when (:compile-toplevel :load-toplevel :execute)
+ (require "comm"))
+
+;; to indicate whether or not to model names as symbols or as instances
+;; (pushnew :xml-symbols *features*)
+
+;; to specify the instance names should use tokenizers
+ (pushnew :nameset-tokenizer *features*)
+
+;; to indicate that all name and string characters are to be checked for legality
+;; (pushnew :xml-check-char-codes *features*)
+#+Allegro
+(when (< excl:real-char-code-limit 65535)
+ (pushnew :xml-check-char-codes *features*))
+
+#-Allegro
+(when (< char-code-limit 65535)
+ (pushnew :xml-check-char-codes *features*))
+
+#|
+;; 20020410.jaa setting the value globally turns out to be inappropriate.
+;; the alternative, dynamical binding, is said to be insufficient to affect internal
+;; state.
+#+LispWorks
+(lw:set-default-character-element-type 'lw:simple-char)
+
+;; should that change, the alternative would have been
+#+LispWorks ; cause lispworks to use wide-character strings
+(lw:*default-character-element-type* 'lw:simple-char)
+|#
+
+#+cmu
+(progn
+ (require :gray-streams)
+ (setq extensions:*inline-expansion-limit* 2)
+ )
+
+#+sbcl
+(setq *inline-expansion-limit* 2)
+
+#|#+ccl ; 0.918 in 5.0b
+(setq CCL::*CHECK-SLOT-TYPE* nil)|#
+
+;; the atn-bnf parser must be loaded in order to translate grammars,
+;; for regular expressions, and for validation. this is reflected in it presence
+;; in the :xparser definition below.
+;; nb. this should be refined to load only the minimum for runtime use
+
+(eval-when (:compile-toplevel :execute :load-toplevel)
+
+ (define-system
+ (:base)
+ ()
+ "xml:code;patch;cmucl"
+ "xml:library;de;setf;utility;package"
+ "xml:library;de;setf;utility;string"
+ "xml:library;de;setf;utility;conditions"
+ "xml:library;de;setf;utility;test"
+ "xml:code;base;package"
+ )
+
+ (define-system
+ (:bnfp)
+ ()
+ :base
+ ; merged into common package file "xml:code;packages;atn-package"
+ "xml:code;atn-parser;clifs;inference-system-classes"
+ "xml:code;atn-parser;clifs;inference-units"
+ "xml:code;atn-parser;atn-parameters"
+ "xml:code;atn-parser;atn-classes"
+ "xml:code;atn-parser;atn-macros"
+ "xml:code;atn-parser;ebnf-tokenizer"
+ "xml:code;atn-parser;ebnf-to-atn-translator"
+ "xml:code;atn-parser;atn-macro-to-canonic-form"
+ "xml:code;atn-parser;ebnf-grammar.atn" ;; the bnf grammar is coded in a "atn" syntax lisp file.
+ "xml:code;atn-parser;atn-runtime"
+ "xml:code;atn-parser;conditions"
+ "xml:code;atn-parser;atn-lisp-compiler"
+ "xml:code;atn-parser;atn-regex"
+ ;; the java translator is present here as documentation, as of 20010208 it has
+ ;; not been reintegrated with the changes to compile to lisp.
+ #+bnfp-java "xml:code;atn-parser;atn-java-compiler"
+ )
+
+ (define-system
+ (:xutil :description "xml base utilities")
+ ()
+ :bnfp
+ "xml:code;base;parameters"
+ "xml:code;base;cllib"
+ #+CL-HTTP "xml:code;base;cl-http-utils"
+ "xml:code;base;utils"
+ "xml:code;base;parsetable"
+ "xml:code;base;vector-stream"
+ #-CL-HTTP "xml:code;base;www-utils-ersatz"
+ #-CL-HTTP "xml:code;base;tokenizer"
+ "xml:code;base;conditions")
+
+ (define-system
+ (xqdm :description "model from the x-query data model")
+ ()
+ :xutil
+ ;; for 0.918 namespaces operations must be defined first
+ "xml:code;xquerydatamodel;xqdm-namespaces"
+ "xml:code;xquerydatamodel;xqdm-parameters"
+ "xml:code;xquerydatamodel;xqdm-character-classes"
+ "xml:code;xquerydatamodel;xqdm-classes"
+ "xml:code;xquerydatamodel;xsd-types"
+ "xml:code;xquerydatamodel;conditions;names;conditions"
+ "xml:code;xquerydatamodel;conditions;node;conditions"
+ "xml:code;xquerydatamodel;conditions;model;conditions"
+ "xml:code;xquerydatamodel;xqdm-operators"
+ ;; "xml:code;xquerydatamodel;xqdm-qnames"
+ "xml:code;xquerydatamodel;xqdm-validation"
+ "xml:code;xquerydatamodel;qname-resolution"
+ "xml:code;xquerydatamodel;xqdm-graph"
+ "xml:code;xquerydatamodel;node-path-walk"
+ "xml:code;xquerydatamodel;xqdm-walk"
+ "xml:code;xquerydatamodel;xqdm-walk-accessors")
+
+ (define-system
+ (xparser :description "xml processor: parsing/serialization for xqdm with standard encoding")
+ ()
+ :xutil :xqdm
+ "xml:code;xparser;xml-parameters"
+ "xml:code;xparser;conditions;codec;conditions"
+ "xml:code;xparser;xml-stream-coding"
+ "xml:code;xparser;xml-operators"
+ "xml:code;xparser;xml-readers"
+ "xml:code;xparser;xml-tokenizer"
+ "xml:code;xparser;xml-processing-instruction"
+ "xml:code;xparser;xml-constructors"
+ "xml:code;xparser;xml-parser"
+ "xml:code;xparser;xml-printer"
+ "xml:code;xparser;xml-writer")
+
+ (define-system
+ (:xpath :description "xml path model and encoding to extend the processor")
+ ()
+ :xparser
+ "xml:code;xpath;xpath-parameters"
+ "xml:code;xpath;xpath-tokenizer"
+ "xml:code;xpath;xpath-classes"
+ "xml:code;xpath;xpath-operators"
+ "xml:code;xpath;xpath-constructors"
+ "xml:code;xpath;xpath-parser"
+ "xml:code;xpath;xpath-printer"
+ "xml:code;xpath;xpath-library")
+
+ (define-system
+ (:xquery :description "xml query processor based on xml processor and xml path")
+ ()
+ :xparser :xpath
+ "xml:code;xquery;xq-parameters"
+ "xml:code;xquery;xqa-classes"
+ "xml:code;xquery;xqa-operators"
+ "xml:code;xquery;xql-operators"
+ "xml:code;xquery;xqa-library"
+ "xml:code;xquery;xql-library"
+ "xml:code;xquery;xql-tokenizer"
+ "xml:code;xquery;xql-constructors"
+ "xml:code;xquery;xql-parser"
+ "xml:code;xquery;xq-printer"
+ )
+
+ (define-system
+ (:xtests
+ :description
+ "loads test files")
+ ()
+ :xparser
+
+ "xml:tests;xquerydatamodel;model"
+
+ "xml:tests;parser;bom"
+ "xml:tests;parser;document-internal"
+ "xml:tests;parser;document-external"
+ "xml:tests;parser;document-specialized"
+ "xml:tests;parser;qnames.lisp"
+ "xml:tests;parser;validation.lisp"
+ "xml:tests;parser;namespaces.lisp"
+ "xml:tests;parser;oasis.lisp"
+ )
+
+ (define-system
+ (:xrelease
+ :description
+ "loads test files")
+ ()
+ :xtests
+ "xml:code;base;release"
+ "xml:*.lisp"
+ "xml:demos;**;*.*"
+ "xml:library;define-system.lisp"
+ "xml:**;*.bnf"
+ "xml:**;*.htm"
+ "xml:**;*.gif"
+ "xml:**;*.xql"
+ "xml:**;*.xml*"
+ "xml:**;*.dtd"
+ "xml:**;*.xmlq"
+ "xml:**;*.txt"
+ )
+
+ (define-system
+ (:xconformance
+ :description
+ "incorporates conformance data files")
+ ()
+ "xml:standards;XML;XMLConf;**;*.xml"
+ "xml:standards;XML;XMLConf;**;*.mod"
+ "xml:standards;XML;XMLConf;**;*.dtd"
+ "xml:standards;XML;XMLConf;**;*.ent"
+ "xml:standards;XML;REC-xml-20001006.xml"
+ "xml:standards;XML;xmlspec-v21.dtd"
+ "xml:standards;XML;W3CSchema;*.xsd"
+ "xml:standards;XML;W3CSchema;*.dtd"
+ "xml:standards;XML;XHTML-MODULAR;**;*.*"
+ )
+ )
+
+
+;; see also xml:tests;test.lisp
+;; (load "entwicklung at paz:sourceServer:lisp:xml:define-system.lisp")
+;; (register-system-definition :xparser "entwicklung at paz:sourceServer:lisp:xml:sysdcl.lisp")
+;; (execute-system-operations :xutil '(:load))
+;; (execute-system-operations :xparser '(:load))
+
+;; to test if the pathnames are ok.
+;; (execute-system-operations :xparser '(:probe))
+
+;; to load
+;; (execute-system-operations :xparser '(:load))
+;; (execute-system-operations :xquery '(:load))
+
+;; to compile / load
+;; (execute-system-operations :xparser '(:compile))
+;; (execute-system-operations :xparser '(:compile :load))
+;; (execute-system-operations :xquery '(:compile :load))
+
+;; (execute-system-operations :xquery #'print)
+
+;; (translate-logical-pathname "xml:xxx;yyy;xml-grammar.bnf")
+;; (translate-logical-pathname "xml:bnfp;sysdcl")
+;; (translate-logical-pathname "xml:code;xquery;xq-printer.lisp")
+;; (translate-logical-pathname "xml:code;xquery;xq-printer.bin")
+;; (translate-logical-pathname "xml:demo;xq-printer.lisp")
+;; (translate-logical-pathname "xml:demo;xq-printer.bin")
+
+:EOF
From banderson at common-lisp.net Tue Feb 14 18:03:43 2006
From: banderson at common-lisp.net (banderson at common-lisp.net)
Date: Tue, 14 Feb 2006 12:03:43 -0600 (CST)
Subject: [cl-xml-cvs] r13 - branches/sbcl-0.9.x-testing
Message-ID: <20060214180343.5B1E151007@common-lisp.net>
Author: banderson
Date: Tue Feb 14 12:03:43 2006
New Revision: 13
Modified:
branches/sbcl-0.9.x-testing/ (props changed)
Log:
some svn:ignore stuffs