Changeset 12192 in project


Ignore:
Timestamp:
10/18/08 15:33:16 (12 years ago)
Author:
Alex Shinn
Message:

Making irregex.scm reflect the upcoming API (not incorporating changes
directly from upstream yet). Fixing string-{match,search}-positions.

Location:
chicken/branches/irregular
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • chicken/branches/irregular/irregex.scm

    r12124 r12192  
    7373    res))
    7474
     75(define (irregex-match-num-submatches m)
     76  (quotient (- (vector-length m) 3) 2))
     77
    7578(define (irregex-match-string m)
    7679  (vector-ref m 1))
     
    8083  (vector-set! m 1 str))
    8184
    82 (define (%irregex-match-start m n)
     85(define (irregex-match-start-index m n)
    8386  (vector-ref m (+ 3 (* n 2))))
    84 (define (%irregex-match-end m n)
     87(define (irregex-match-end-index m n)
    8588  (vector-ref m (+ 4 (* n 2))))
    8689
    87 (define (%irregex-match-start-set! m n start)
     90(define (irregex-match-start-index-set! m n start)
    8891  (vector-set! m (+ 3 (* n 2)) start))
    89 (define (%irregex-match-end-set! m n end)
     92(define (irregex-match-end-index-set! m n end)
    9093  (vector-set! m (+ 4 (* n 2)) end))
    9194
    92 (define (%irregex-match-index m opt)
     95(define (irregex-match-index m opt)
    9396  (if (pair? opt)
    9497      (cond ((number? (car opt)) (car opt))
     
    97100      0))
    98101
    99 (define (%irregex-match-valid-index? m n)
     102(define (irregex-match-valid-index? m n)
    100103  (and (< (+ 3 (* n 2)) (vector-length m))
    101104       (vector-ref m (+ 4 (* n 2)))))
    102105
    103106(define (irregex-match-substring m . opt)
    104   (let ((n (%irregex-match-index m opt)))
    105     (and (%irregex-match-valid-index? m n)
     107  (let ((n (irregex-match-index m opt)))
     108    (and (irregex-match-valid-index? m n)
    106109         (substring (irregex-match-string m)
    107110                    (vector-ref m (+ 3 (* n 2)))
     
    109112
    110113(define (irregex-match-start m . opt)
    111   (let ((n (%irregex-match-index m opt)))
    112     (and (%irregex-match-valid-index? m n)
     114  (let ((n (irregex-match-index m opt)))
     115    (and (irregex-match-valid-index? m n)
    113116         (vector-ref m (+ 3 (* n 2))))))
    114117
    115118(define (irregex-match-end m . opt)
    116   (%irregex-match-valid-index? m (%irregex-match-index m opt)))
     119  (irregex-match-valid-index? m (irregex-match-index m opt)))
    117120
    118121;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    15071510        (cond
    15081511         (m-end
    1509           (%irregex-match-start-set! matches 0 start)
    1510           (%irregex-match-end-set! matches 0 m-end)
     1512          (irregex-match-start-index-set! matches 0 start)
     1513          (irregex-match-end-index-set! matches 0 m-end)
    15111514          ((irregex-dfa/extract irx) str start m-end matches)
    15121515          matches)
     
    15291532                    (cond
    15301533                     (m-end
    1531                       (%irregex-match-start-set! matches 0 m-start)
    1532                       (%irregex-match-end-set! matches 0 m-end)
     1534                      (irregex-match-start-index-set! matches 0 m-start)
     1535                      (irregex-match-end-index-set! matches 0 m-end)
    15331536                      ((irregex-dfa/extract irx) str m-start m-end matches)
    15341537                      matches)
     
    15421545               (cond
    15431546                (i
    1544                  (%irregex-match-start-set! matches 0 start)
    1545                  (%irregex-match-end-set! matches 0 i)
     1547                 (irregex-match-start-index-set! matches 0 start)
     1548                 (irregex-match-end-index-set! matches 0 i)
    15461549                 matches)
    15471550                (else
     
    15591562        (cond
    15601563         ((equal? m-end end)
    1561           (%irregex-match-start-set! matches 0 start)
    1562           (%irregex-match-end-set! matches 0 m-end)
     1564          (irregex-match-start-index-set! matches 0 start)
     1565          (irregex-match-end-index-set! matches 0 m-end)
    15631566          ((irregex-dfa/extract irx) str start m-end matches)
    15641567          matches)
     
    15701573        (cond
    15711574         ((equal? i end)
    1572           (%irregex-match-start-set! matches 0 start)
    1573           (%irregex-match-end-set! matches 0 i)
     1575          (irregex-match-start-index-set! matches 0 start)
     1576          (irregex-match-end-index-set! matches 0 i)
    15741577          matches)
    15751578         (else
     
    21142117               (cond
    21152118                ((number? res)
    2116                  (%irregex-match-start-set! matches n i)
    2117                  (%irregex-match-end-set! matches n res)))
     2119                 (irregex-match-start-index-set! matches n i)
     2120                 (irregex-match-end-index-set! matches n res)))
    21182121               res))))
    21192122        (else
     
    23372340                            (cadr sre))))
    23382341                   (lambda (str i matches fail2)
    2339                      (if (%irregex-match-end matches index)
     2342                     (if (irregex-match-end-index matches index)
    23402343                         (pass str i matches fail2)
    23412344                         (fail str i matches fail2)))))
     
    23702373                        flags
    23712374                        (lambda (str i matches fail)
    2372                           (let ((old (%irregex-match-end matches n)))
    2373                             (%irregex-match-end-set! matches n i)
     2375                          (let ((old (irregex-match-end-index matches n)))
     2376                            (irregex-match-end-index-set! matches n i)
    23742377                            (next str i matches
    23752378                                  (lambda ()
    2376                                     (%irregex-match-end-set! matches n old)
     2379                                    (irregex-match-end-index-set! matches n old)
    23772380                                    (fail))))))))
    23782381               (lambda (str i matches fail)
    2379                  (let ((old (%irregex-match-start matches n)))
    2380                    (%irregex-match-start-set! matches n i)
     2382                 (let ((old (irregex-match-start-index matches n)))
     2383                   (irregex-match-start-index-set! matches n i)
    23812384                   (body str i matches
    23822385                         (lambda ()
    2383                            (%irregex-match-start-set! matches n old)
     2386                           (irregex-match-start-index-set! matches n old)
    23842387                           (fail)))))))
    23852388            ((submatch-named)
  • chicken/branches/irregular/regex.scm

    r12131 r12192  
    4545    irregex-new-matches irregex-reset-matches!
    4646    irregex-match-start irregex-match-end irregex-match-substring
     47    irregex-match-num-submatches
    4748    irregex-search irregex-search/matches irregex-match irregex-match-string
    4849    irregex-replace irregex-replace/all
     
    7374    (let ((opts '()))
    7475      (when caseless (set! opts (cons 'i opts)))
     76      (when extended (set! opts (cons 'x opts)))
    7577      (when utf8 (set! opts (cons 'utf8 opts)))
    7678      opts))) )
     
    8486  (let ((rx (unregexp rx)))
    8587    (and-let* ((m (irregex-match rx str)))
    86       (let ((n (irregex-submatches rx)))
    87         (cons
    88          str
    89          (let loop ((i 0))
    90            (if (fx>= i n)
    91                '()
    92                (cons (irregex-match-substring m i) (loop (fx+ i 1))))))))))
     88      (let loop ((i (irregex-match-num-submatches m))
     89                 (res '()))
     90        (if (fx<= i 0)
     91            (cons str res)
     92            (loop (fx- i 1) (cons (irregex-match-substring m i) res)))))))
    9393
    9494(define (string-match-positions rx str)
    9595  (let ((rx (unregexp rx)))
    9696    (and-let* ((m (irregex-match rx str)))
    97       (let ((n (irregex-submatches m)))
    98         (cons
    99          (list (%irregex-match-start m 0)
    100                (%irregex-match-end m 0))
    101          (let loop ((i 0))
    102            (if (fx>= i n)
    103                '()
    104                (cons (list (irregex-match-start m i)
    105                            (irregex-match-end m i))
    106                      (loop (fx+ i 1))))))))))
     97      (let loop ((i (irregex-match-num-submatches m))
     98                 (res '()))
     99        (if (fx<= i 0)
     100            (cons (list 0 (string-length str)) res)
     101            (loop (fx- i 1) (cons (list (irregex-match-start-index m i)
     102                                        (irregex-match-end-index m i))
     103                                  res)))))))
    107104
    108105(define (string-search rx str #!optional (start 0) (range (string-length str)))
    109106  (let ((rx (unregexp rx)))
    110107    (and-let* ((m (irregex-search rx str start (fx+ start range))))
    111       (let loop ((i (irregex-submatches rx))
    112                  (res (list (irregex-match-string m))))
    113         (if (fx< i 0)
    114             res
    115             (loop (fx- i 1)
    116                   (cons (irregex-match-substring m i) res)))))))
     108      (let loop ((i (irregex-match-num-submatches m))
     109                 (res '()))
     110        (if (fx< i 0)
     111            res
     112            (loop (fx- i 1) (cons (irregex-match-substring m i) res)))))))
    117113
    118114(define (string-search-positions rx str #!optional (start 0) (range (string-length str)))
    119115  (let ((rx (unregexp rx)))
    120116    (and-let* ((m (irregex-search rx str start (fx+ start range))))
    121       (let loop ((i (irregex-submatches rx))
    122                  (res (list (list (%irregex-match-start m 0)
    123                                   (%irregex-match-end m 0)))))
    124           (if (fx< i 0)
    125               '()
    126               (loop (fx- i 1)
    127                     (cons (list (irregex-match-start m i)
    128                                 (irregex-match-end m i))
    129                           res)))))))
     117      (let loop ((i (irregex-match-num-submatches m))
     118                 (res '()))
     119        (if (fx< i 0)
     120            res
     121            (loop (fx- i 1) (cons (list (irregex-match-start-index m i)
     122                                        (irregex-match-end-index m i))
     123                                  res)))))))
    130124
    131125
Note: See TracChangeset for help on using the changeset viewer.