;;;; string-fun.scm --- string manipulation functions
;;;;
-;;;; Copyright (C) 1995, 1996, 1997, 1999 Free Software Foundation, Inc.
+;;;; Copyright (C) 1995, 1996, 1997, 1999, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; along with this software; see the file COPYING. If not, write to
;;;; the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
;;;; Boston, MA 02111-1307 USA
+;;;;
+;;;; As a special exception, the Free Software Foundation gives permission
+;;;; for additional uses of the text contained in its release of GUILE.
+;;;;
+;;;; The exception is that, if you link the GUILE library with other files
+;;;; to produce an executable, this does not by itself cause the
+;;;; resulting executable to be covered by the GNU General Public License.
+;;;; Your use of that executable is in no way restricted on account of
+;;;; linking the GUILE library code into it.
+;;;;
+;;;; This exception does not however invalidate any other reasons why
+;;;; the executable file might be covered by the GNU General Public License.
+;;;;
+;;;; This exception applies only to the code released by the
+;;;; Free Software Foundation under the name GUILE. If you copy
+;;;; code from other Free Software Foundation releases into a copy of
+;;;; GUILE, as the General Public License permits, the exception does
+;;;; not apply to the code that you add in this way. To avoid misleading
+;;;; anyone as to the status of such modified files, you must delete
+;;;; this exception notice from them.
+;;;;
+;;;; If you write modifications of your own for GUILE, it is your choice
+;;;; whether to permit this exception to apply to your modifications.
+;;;; If you do not wish that, delete this exception notice.
;;;;
\f
-(define-module (ice-9 string-fun))
+(define-module (ice-9 string-fun)
+ :export (split-after-char split-before-char split-discarding-char
+ split-after-char-last split-before-char-last
+ split-discarding-char-last split-before-predicate
+ split-after-predicate split-discarding-predicate
+ separate-fields-discarding-char separate-fields-after-char
+ separate-fields-before-char string-prefix-predicate string-prefix=?
+ sans-surrounding-whitespace sans-trailing-whitespace
+ sans-leading-whitespace sans-final-newline has-trailing-newline?))
;;;;
;;;
;;; complicated with these functions, consider using regular expressions.
;;;
-(define-public (split-after-char char str ret)
+(define (split-after-char char str ret)
(let ((end (cond
((string-index str char) => 1+)
(else (string-length str)))))
(ret (substring str 0 end)
(substring str end))))
-(define-public (split-before-char char str ret)
+(define (split-before-char char str ret)
(let ((end (or (string-index str char)
(string-length str))))
(ret (substring str 0 end)
(substring str end))))
-(define-public (split-discarding-char char str ret)
+(define (split-discarding-char char str ret)
(let ((end (string-index str char)))
(if (not end)
(ret str "")
(ret (substring str 0 end)
(substring str (1+ end))))))
-(define-public (split-after-char-last char str ret)
+(define (split-after-char-last char str ret)
(let ((end (cond
((string-rindex str char) => 1+)
(else 0))))
(ret (substring str 0 end)
(substring str end))))
-(define-public (split-before-char-last char str ret)
+(define (split-before-char-last char str ret)
(let ((end (or (string-rindex str char) 0)))
(ret (substring str 0 end)
(substring str end))))
-(define-public (split-discarding-char-last char str ret)
+(define (split-discarding-char-last char str ret)
(let ((end (string-rindex str char)))
(if (not end)
(ret str "")
(ret (substring str 0 end)
(substring str (1+ end))))))
-(define-public (split-before-predicate pred str ret)
+(define (split-before-predicate pred str ret)
(let loop ((n 0))
(cond
((= n (string-length str)) (ret str ""))
((not (pred (string-ref str n))) (loop (1+ n)))
(else (ret (substring str 0 n)
(substring str n))))))
-(define-public (split-after-predicate pred str ret)
+(define (split-after-predicate pred str ret)
(let loop ((n 0))
(cond
((= n (string-length str)) (ret str ""))
(else (ret (substring str 0 (1+ n))
(substring str (1+ n)))))))
-(define-public (split-discarding-predicate pred str ret)
+(define (split-discarding-predicate pred str ret)
(let loop ((n 0))
(cond
((= n (string-length str)) (ret str ""))
(else (ret (substring str 0 n)
(substring str (1+ n)))))))
-(define-public (separate-fields-discarding-char ch str ret)
+(define (separate-fields-discarding-char ch str ret)
(let loop ((fields '())
(str str))
(cond
(substring str 0 w))))
(else (apply ret str fields)))))
-(define-public (separate-fields-after-char ch str ret)
+(define (separate-fields-after-char ch str ret)
(reverse
(let loop ((fields '())
(str str))
(substring str (+ 1 w)))))
(else (apply ret str fields))))))
-(define-public (separate-fields-before-char ch str ret)
+(define (separate-fields-before-char ch str ret)
(let loop ((fields '())
(str str))
(cond
;;; (define-public string-prefix=? (string-prefix-predicate string=?))
;;;
-(define-public ((string-prefix-predicate pred?) prefix str)
+(define ((string-prefix-predicate pred?) prefix str)
(and (<= (string-length prefix) (string-length str))
(pred? prefix (substring str 0 (string-length prefix)))))
-(define-public string-prefix=? (string-prefix-predicate string=?))
+(define string-prefix=? (string-prefix-predicate string=?))
\f
;;; {String Fun: Strippers}
;;; | final-newline
;;;
-(define-public (sans-surrounding-whitespace s)
+(define (sans-surrounding-whitespace s)
(let ((st 0)
(end (string-length s)))
(while (and (< st (string-length s))
""
(substring s st end))))
-(define-public (sans-trailing-whitespace s)
+(define (sans-trailing-whitespace s)
(let ((st 0)
(end (string-length s)))
(while (and (< 0 end)
""
(substring s st end))))
-(define-public (sans-leading-whitespace s)
+(define (sans-leading-whitespace s)
(let ((st 0)
(end (string-length s)))
(while (and (< st (string-length s))
""
(substring s st end))))
-(define-public (sans-final-newline str)
+(define (sans-final-newline str)
(cond
((= 0 (string-length str))
str)
;;; {String Fun: has-trailing-newline?}
;;;
-(define-public (has-trailing-newline? str)
+(define (has-trailing-newline? str)
(and (< 0 (string-length str))
(char=? #\nl (string-ref str (1- (string-length str))))))
HCoop / bpt / guile.git / blobdiff