| 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))))))))))) |