Debian Codegraph @

ext/sxml/src/sxpath-ext.scm

raw
1 ;; W3C compliant extensions to SXPathlib
2 ; $Id: sxpath-ext.scm,v 1.2 2004-02-09 06:33:03 shirok Exp $:
3 ;
4 ; This software is in Public Domain.
5 ; IT IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
6 ;
7 ; Please send bug reports and comments to:
8 ; [email protected] Kirill Lisovsky
9 ; [email protected] Dmitry Lizorkin
10
11 ;=========================================================================
12 ; SXML counterparts to W3C XPath Core Functions Library
13
14 ; The counterpart to XPath 'string' function (section 4.2 XPath Rec.)
15 ; Converts a given object to a string
16 ; NOTE:
17 ; 1. When converting a nodeset - a document order is not preserved
18 ; 2. number->string function returns the result in a form which is slightly
19 ; different from XPath Rec. specification
20 (define (sxml:string object)
21 (cond
22 ((string? object) object)
23 ((nodeset? object) (if (null? object)
24 ""
25 (sxml:string-value (car object))))
26 ((number? object) (number->string object))
27 ((boolean? object) (if object "true" "false"))
28 (else ""))) ; Unknown type -> empty string.
29 ; Option: write its value to string port?
30
31 ; The counterpart to XPath 'boolean' function (section 4.3 XPath Rec.)
32 ; Converts its argument to a boolean
33 (define (sxml:boolean object)
34 (cond
35 ((boolean? object) object)
36 ((number? object) (not (= object 0)))
37 ((string? object) (> (string-length object) 0))
38 ((nodeset? object) (not (null? object)))
39 (else #f))) ; Not specified in XPath Rec.
40
41 ; The counterpart to XPath 'number' function (section 4.4 XPath Rec.)
42 ; Converts its argument to a number
43 ; NOTE:
44 ; 1. The argument is not optional (yet?)
45 ; 2. string->number conversion is not IEEE 754 round-to-nearest
46 ; 3. NaN is represented as 0
47 (define (sxml:number obj)
48 (cond
49 ((number? obj) obj)
50 ((string? obj)
51 (let ((nmb (call-with-input-string obj read)))
52 (if (number? nmb)
53 nmb
54 0))) ; NaN
55 ((boolean? obj) (if obj 1 0))
56 ((nodeset? obj) (sxml:number (sxml:string obj)))
57 (else 0))) ; unknown datatype
58
59 ; Returns a string value for a given node in accordance to
60 ; XPath Rec. 5.1 - 5.7
61 (define (sxml:string-value node)
62 (if
63 (not (pair? node)) ; a text node?
64 (if (string? node)
65 node
66 "") ; for XPath 1.0 it is an incorrect situation
67 (apply
68 string-append
69 (cons ""
70 (map
71 sxml:string-value
72 ((cond
73 ((null? (cdr node)) cdr)
74 ((not (pair? (cadr node))) cdr)
75 ((not (equal? (caadr node) '@)) cdr)
76 (else cddr))
77 node))))))
78
79 ; Select SXML element by its unique IDs
80 ; XPath Rec. 4.1
81 ; object - a nodeset or a datatype which can be converted to a string by means
82 ; of a 'string' function
83 ; id-index = ( (id-value . element) (id-value . element) ... )
84 ; This index is used for selection of an element by its unique ID.
85 ; The result is a nodeset
86 (define (sxml:id id-index)
87 (lambda(object)
88 (if (nodeset? object)
89 (let loop ((str-lst (map sxml:string-value object))
90 (res '()))
91 (if (null? str-lst)
92 (reverse res)
93 (let ((node (sxml:lookup (car str-lst) id-index)))
94 (if (not node) ; no such element
95 (loop (cdr str-lst) res)
96 (loop (cdr str-lst) (cons node res))))))
97 (let rpt ((lst (string->list (sxml:string object)))
98 (tmp '())
99 (res '()))
100 (cond
101 ((null? lst)
102 (if (null? tmp)
103 (reverse res)
104 (let ((node (sxml:lookup (list->string (reverse tmp)) id-index)))
105 (if (not node)
106 (reverse res)
107 (reverse (cons node res))))))
108 ((member (car lst) '(#\space #\return #\newline #\tab))
109 (if (null? tmp)
110 (rpt (cdr lst) tmp res)
111 (let ((node (sxml:lookup (list->string (reverse tmp)) id-index)))
112 (if (not node)
113 (rpt (cdr lst) '() res)
114 (rpt (cdr lst) '() (cons node res))))))
115 (else (rpt (cdr lst) (cons (car lst) tmp) res)))))))
116
117
118 ;=========================================================================
119 ; Comparators for XPath objects
120
121 ; A helper for XPath equality operations: = , !=
122 ; 'bool-op', 'number-op' and 'string-op' are comparison operations for
123 ; a pair of booleans, numbers and strings respectively
124 (define (sxml:equality-cmp bool-op number-op string-op)
125 (lambda (obj1 obj2)
126 (cond
127 ((and (not (nodeset? obj1)) (not (nodeset? obj2)))
128 ; neither object is a nodeset
129 (cond
130 ((boolean? obj1) (bool-op obj1 (sxml:boolean obj2)))
131 ((boolean? obj2) (bool-op (sxml:boolean obj1) obj2))
132 ((number? obj1) (number-op obj1 (sxml:number obj2)))
133 ((number? obj2) (number-op (sxml:number obj1) obj2))
134 (else ; both objects are strings
135 (string-op obj1 obj2))))
136 ((and (nodeset? obj1) (nodeset? obj2)) ; both objects are nodesets
137 (let first ((str-set1 (map sxml:string-value obj1))
138 (str-set2 (map sxml:string-value obj2)))
139 (cond
140 ((null? str-set1) #f)
141 ((let second ((elem (car str-set1))
142 (set2 str-set2))
143 (cond
144 ((null? set2) #f)
145 ((string-op elem (car set2)) #t)
146 (else (second elem (cdr set2))))) #t)
147 (else
148 (first (cdr str-set1) str-set2)))))
149 (else ; one of the objects is a nodeset, another is not
150 (let*-values
151 (((nset elem)
152 ; Equality operations are commutative
153 (if (nodeset? obj1) (values obj1 obj2) (values obj2 obj1))))
154 (cond
155 ((boolean? elem) (bool-op elem (sxml:boolean nset)))
156 ((number? elem)
157 (let loop ((nset
158 (map
159 (lambda (node) (sxml:number (sxml:string-value node)))
160 nset)))
161 (cond
162 ((null? nset) #f)
163 ((number-op elem (car nset)) #t)
164 (else (loop (cdr nset))))))
165 ((string? elem)
166 (let loop ((nset (map sxml:string-value nset)))
167 (cond
168 ((null? nset) #f)
169 ((string-op elem (car nset)) #t)
170 (else (loop (cdr nset))))))
171 (else ; unknown datatype
172 (cerr "Unknown datatype: " elem nl)
173 #f)))))))
174
175
176 (define sxml:equal? (sxml:equality-cmp eq? = string=?))
177
178 (define sxml:not-equal?
179 (sxml:equality-cmp
180 (lambda (bool1 bool2) (not (eq? bool1 bool2)))
181 (lambda (num1 num2) (not (= num1 num2)))
182 (lambda (str1 str2) (not (string=? str1 str2)))))
183
184
185 ; Relational operation ( < , > , <= , >= ) for two XPath objects
186 ; op is comparison procedure: < , > , <= or >=
187 (define (sxml:relational-cmp op)
188 (lambda (obj1 obj2)
189 (cond
190 ((not (or (nodeset? obj1) (nodeset? obj2))) ; neither obj is a nodeset
191 (op (sxml:number obj1) (sxml:number obj2)))
192 ((boolean? obj1) ; 'obj1' is a boolean, 'obj2' is a nodeset
193 (op (sxml:number obj1) (sxml:number (sxml:boolean obj2))))
194 ((boolean? obj2) ; 'obj1' is a nodeset, 'obj2' is a boolean
195 (op (sxml:number (sxml:boolean obj1)) (sxml:number obj2)))
196 ((or (null? obj1) (null? obj2)) ; one of the objects is an empty nodeset
197 #f)
198 (else ; at least one object is a nodeset
199 (op
200 (cond
201 ((nodeset? obj1) ; 'obj1' is a (non-empty) nodeset
202 (let ((nset1 (map
203 (lambda (node) (sxml:number (sxml:string-value node)))
204 obj1)))
205 (let first ((num1 (car nset1))
206 (nset1 (cdr nset1)))
207 (cond
208 ((null? nset1) num1)
209 ((op num1 (car nset1)) (first num1 (cdr nset1)))
210 (else (first (car nset1) (cdr nset1)))))))
211 ((string? obj1) (sxml:number obj1))
212 (else ; 'obj1' is a number
213 obj1))
214 (cond
215 ((nodeset? obj2) ; 'obj2' is a (non-empty) nodeset
216 (let ((nset2 (map
217 (lambda (node) (sxml:number (sxml:string-value node)))
218 obj2)))
219 (let second ((num2 (car nset2))
220 (nset2 (cdr nset2)))
221 (cond
222 ((null? nset2) num2)
223 ((op num2 (car nset2)) (second (car nset2) (cdr nset2)))
224 (else (second num2 (cdr nset2)))))))
225 ((string? obj2) (sxml:number obj2))
226 (else ; 'obj2' is a number
227 obj2)))))))
228
229 ;=========================================================================
230 ; XPath axises
231 ; An order in resulting nodeset is preserved
232
233 ; Ancestor axis
234 (define (sxml:ancestor test-pred?)
235 (lambda (root-node) ; node or nodeset
236 (lambda (node) ; node or nodeset
237 (if (nodeset? node)
238 (map-union ((sxml:ancestor test-pred?) root-node) node)
239 (let rpt ((paths (if (nodeset? root-node)
240 (map list root-node)
241 (list (list root-node)))))
242 (if (null? paths)
243 '()
244 (let ((path (car paths)))
245 (if (eq? (car path) node)
246 ((sxml:filter test-pred?) (cdr path))
247 (rpt (append
248 (map
249 (lambda (arg) (cons arg path))
250 (append
251 ((sxml:attribute (ntype?? '*)) (car path))
252 ((sxml:child sxml:node?) (car path))))
253 (cdr paths)))))))))))
254
255 ; Ancestor-or-self axis
256 (define (sxml:ancestor-or-self test-pred?)
257 (lambda (root-node) ; node or nodeset
258 (lambda (node) ; node or nodeset
259 (if (nodeset? node)
260 (map-union ((sxml:ancestor-or-self test-pred?) root-node) node)
261 (let rpt ((paths (if (nodeset? root-node)
262 (map list root-node)
263 (list (list root-node)))))
264 (if (null? paths)
265 ((sxml:filter test-pred?) (list node))
266 (let ((path (car paths)))
267 (if (eq? (car path) node)
268 ((sxml:filter test-pred?) path)
269 (rpt (append
270 (map
271 (lambda (arg) (cons arg path))
272 (append
273 ((sxml:attribute (ntype?? '*)) (car path))
274 ((sxml:child sxml:node?) (car path))))
275 (cdr paths)))))))))))
276
277 ; Descendant axis
278 ; It's similar to original 'node-closure' a resulting nodeset is
279 ; in depth-first order rather than breadth-first
280 ; Fix: din't descend in non-element nodes!
281 (define (sxml:descendant test-pred?)
282 (lambda (node) ; node or nodeset
283 (if (nodeset? node)
284 (map-union (sxml:descendant test-pred?) node)
285 (let rpt ((res '())
286 (more ((sxml:child sxml:node?) node)))
287 (if (null? more)
288 (reverse res)
289 (rpt (if (test-pred? (car more))
290 (cons (car more) res)
291 res)
292 (append ((sxml:child sxml:node?) (car more))
293 (cdr more))))))))
294
295 ; Descendant-or-self axis
296 (define (sxml:descendant-or-self test-pred?)
297 (lambda (node) ; node or nodeset
298 (if (nodeset? node)
299 (map-union (sxml:descendant-or-self test-pred?) node)
300 (let rpt ((res '())
301 (more (list node)))
302 (if (null? more)
303 (reverse res)
304 (rpt (if (test-pred? (car more))
305 (cons (car more) res)
306 res)
307 (append ((sxml:child sxml:node?) (car more))
308 ; sxml:node?
309 (cdr more))))))))
310
311 ; Following axis
312 (define (sxml:following test-pred?)
313 (lambda (root-node) ; node or nodeset
314 (lambda (node) ; node or nodeset
315 (if (nodeset? node)
316 (map-union ((sxml:following test-pred?) root-node) node)
317 (let loop ((seq (if (nodeset? root-node)
318 (list root-node)
319 (list (list root-node)))))
320 (cond
321 ((null? seq) '())
322 ((null? (car seq)) (loop (cdr seq)))
323 ((eq? (caar seq) node)
324 (let rpt ((seq (cdr (apply append seq)))
325 (res '()))
326 (if (null? seq)
327 res
328 (rpt (cdr seq)
329 (append
330 res
331 ((sxml:descendant-or-self test-pred?) (car seq)))))))
332 ((and (sxml:element? (caar seq))
333 (memq node (sxml:attr-list (caar seq))))
334 (let rpt ((sq (cdr (apply append seq)))
335 (res ((sxml:descendant test-pred?) (caar seq))))
336 (if (null? sq)
337 res
338 (rpt (cdr sq)
339 (append res
340 ((sxml:descendant-or-self test-pred?) (car sq)))))))
341 (else
342 (loop (cons
343 ((sxml:child sxml:node?) (caar seq))
344 (cons (cdar seq) (cdr seq)))))))))))
345
346 ; Following-sibling axis
347 (define (sxml:following-sibling test-pred?)
348 (lambda (root-node) ; node or nodeset
349 (lambda (node) ; node or nodeset
350 (if (nodeset? node)
351 (map-union ((sxml:following-sibling test-pred?) root-node) node)
352 (let loop ((seqs (if (nodeset? root-node)
353 (list root-node)
354 (list (list root-node)))))
355 (if (null? seqs)
356 '()
357 (let rpt ((seq (car seqs)))
358 (cond
359 ((null? seq)
360 (loop (append
361 (map (sxml:child sxml:node?)
362 (car seqs))
363 (cdr seqs))))
364 ((eq? (car seq) node) ((sxml:filter test-pred?) (cdr seq)))
365 (else (rpt (cdr seq)))))))))))
366
367 ; Namespace axis
368 (define (sxml:namespace test-pred?)
369 (lambda (node) ; node or nodeset
370 ((sxml:filter test-pred?)
371 (sxml:ns-list node))))
372
373 ; Preceding axis
374 (define (sxml:preceding test-pred?)
375 (lambda (root-node) ; node or nodeset
376 (lambda (node) ; node or nodeset
377 (if (nodeset? node)
378 (map-union ((sxml:preceding test-pred?) root-node) node)
379 (let loop ((seq (if (nodeset? root-node)
380 (list (reverse root-node))
381 (list (list root-node)))))
382 (cond
383 ((null? seq) '())
384 ((null? (car seq)) (loop (cdr seq)))
385 ((or (eq? (caar seq) node)
386 (not (null? ((sxml:attribute
387 (lambda (n)
388 (eq? n node)))
389 (caar seq)))))
390 (let rpt ((seq (cdr (apply append seq)))
391 (res '()))
392 (if (null? seq)
393 res
394 (rpt (cdr seq)
395 (append res
396 (reverse ((sxml:descendant-or-self test-pred?)
397 (car seq))))))))
398 (else (loop (cons (reverse ((sxml:child sxml:node?) (caar seq)))
399 (cons (cdar seq) (cdr seq)))))))))))
400
401 ; Preceding-sibling axis
402 (define (sxml:preceding-sibling test-pred?)
403 (lambda (root-node) ; node or nodeset
404 (lambda (node) ; node or nodeset
405 (if(nodeset? node)
406 (map-union ((sxml:preceding-sibling test-pred?) root-node) node)
407 (let loop ((seqs (if (nodeset? root-node)
408 (list root-node)
409 (list (list root-node)))))
410 (if (null? seqs)
411 '()
412 (let rpt ((seq (car seqs)))
413 (cond
414 ((null? seq)
415 (loop (append
416 (map
417 (lambda (n)
418 (reverse ((sxml:child sxml:node?) n)))
419 (car seqs))
420 (cdr seqs))))
421 ((eq? (car seq) node) ((sxml:filter test-pred?) (cdr seq)))
422 (else (rpt (cdr seq)))))))))))