Changeset 14023 in project


Ignore:
Timestamp:
04/01/09 02:25:57 (11 years ago)
Author:
Ivan Raikov
Message:

Removed some debug msgs.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • chicken/branches/chicken-3/regex.scm

    r13991 r14023  
    112112
    113113(define (string-match rx str . rest)
    114   (print "begin string-match")
    115114  (let ((rx (unregexp rx)))
    116115    (and-let* ((m (irregex-match rx str)))
     
    118117                 (res '()))
    119118        (if (fx<= i 0)
    120             (begin
    121               (print "end string-match")
    122               (cons str res)
    123               )
     119            (cons str res)
    124120            (loop (fx- i 1) (cons (irregex-match-substring m i) res)))))))
    125121
    126122(define (string-match-positions rx str . rest)
    127   (print "begin string-match-positions")
    128123  (let ((rx (unregexp rx)))
    129124    (and-let* ((m (irregex-match rx str)))
     
    131126                 (res '()))
    132127        (if (fx<= i 0)
    133             (begin
    134               (print "end string-match-positions")
    135               (cons (list 0 (string-length str)) res)
    136               )
     128            (cons (list 0 (string-length str)) res)
    137129            (loop (fx- i 1) (cons (list (irregex-match-start-index m i)
    138130                                        (irregex-match-end-index m i))
     
    140132
    141133(define (string-search rx str #!optional (start 0) (range (string-length str)))
    142   (print "begin string-search")
    143134  (let ((rx (unregexp rx)))
    144135    (and-let* ((n (string-length str))
     
    147138                 (res '()))
    148139        (if (fx< i 0)
    149             (begin
    150               (print "end string-search")
    151               res)
     140            res
    152141            (loop (fx- i 1) (cons (irregex-match-substring m i) res)))))))
    153142
    154143(define (string-search-positions rx str #!optional (start 0) (range (string-length str)))
    155   (print "begin string-search-positions")
    156144  (let ((rx (unregexp rx)))
    157145    (and-let* ((n (string-length str))
     
    160148                 (res '()))
    161149        (if (fx< i 0)
    162             (begin
    163               (print "end string-search-positions")
    164               res)
     150            res
    165151            (loop (fx- i 1) (cons (list (irregex-match-start-index m i)
    166152                                        (irregex-match-end-index m i))
     
    176162        [string-search-positions string-search-positions] )
    177163    (lambda (rgxp str . mode-and-start)
    178       (print "begin string-split-fields")
    179164      (##sys#check-string str 'string-split-fields)
    180165      (let* ([argc (length mode-and-start)]
     
    209194                          (loop (cons (fetch start (fx+ from 1) (fx+ to 2)) ms) (fx+ to 1)) )
    210195                      (loop (cons (fetch start from to) ms) to) ) )
    211                 (begin
    212                   (print "end string-split-fields")
    213                   (fini ms start) ) ) ) ) ) ) ))
     196                  (fini ms start) ) ) ) ) ) ) )
    214197
    215198
     
    222205        [string-search-positions string-search-positions] )
    223206    (lambda (regex subst string . flag)
    224       (print "begin string-substitute")
    225207      (##sys#check-string subst 'string-substitute)
    226208      (let* ([which (if (pair? flag) (car flag) 1)]
     
    266248                            (loop upto (fx+ count 1)) ) ) ) ]
    267249                  [else
    268                    (print "end string-substitute")
    269 
    270250                   (push (substring string index (##sys#size string)))
    271251                   (##sys#fragments->string total (reverse result)) ] ) ) ) ) ) ) )
     
    274254  (let ([string-substitute string-substitute])
    275255    (lambda (str smap . mode)
    276       (print "begin string-substitute*")
    277 
    278256      (##sys#check-string str 'string-substitute*)
    279257      (##sys#check-list smap 'string-substitute*)
     
    281259        (let loop ((str str) (smap smap))
    282260          (if (null? smap)
    283               (begin
    284                 (print "end string-substitute*")
    285                 str)
     261              str
    286262              (let ((sm (car smap)))
    287263                (loop (string-substitute (car sm) (cdr sm) str mode)
     
    294270(define (glob? str)
    295271  (##sys#check-string str 'glob?)
    296   (print "begin glob?")
    297272  (let loop ([idx (fx- (string-length str) 1)])
    298273    (and (fx<= 0 idx)
     
    300275           [(#\* #\] #\?)
    301276             (or (fx= 0 idx)
    302                  (begin
    303                    (print "end glob?")
    304                    (not (char=? #\\ (string-ref str (fx- idx 1)))))
     277                 (not (char=? #\\ (string-ref str (fx- idx 1))))
    305278                 (loop (fx- idx 2)))]
    306279           [else
     
    311284        [string->list string->list] )
    312285    (lambda (s)
    313       (print "begin glob->regexp")
    314286      (##sys#check-string s 'glob->regexp)
    315287      (list->string
    316288       (let loop ((cs (string->list s)))
    317289         (if (null? cs)
    318              (begin
    319                (print "end glob->regexp")
    320                '())
     290             '()
    321291             (let ([c (car cs)]
    322292                   [rest (cdr cs)] )
     
    349319  (let ([string-search string-search])
    350320    (lambda (rgxp lst)
    351       (print "begin grep")
    352321      (##sys#check-list lst 'grep)
    353322      (let loop ([lst lst])
    354323        (if (null? lst)
    355             (begin
    356               (print "end grep")
    357               '())
     324            '()
    358325            (let ([x (car lst)]
    359326                  [r (cdr lst)] )
     
    369336        [get-output-string get-output-string] )
    370337    (lambda (str)
    371       (print "begin regexp-escape")
    372338      (##sys#check-string str 'regexp-escape)
    373339      (let ([out (open-output-string)]
     
    375341        (let loop ([i 0])
    376342          (cond [(fx>= i len)
    377                  (print "end regexp-escape")
    378343                 (get-output-string out)]
    379344                [(memq (##core#inline "C_subchar" str i)
Note: See TracChangeset for help on using the changeset viewer.