FM / ice-9

/usr/share/guile/3.0/ice-9

Name	Size	Mode	Actions
peg/	-	0755	rm
and-let-star.scm	2593	0644	edit dl rm
arrays.scm	2692	0644	edit dl rm
atomic.scm	1592	0644	edit dl rm
binary-ports.scm	2773	0644	edit dl rm
boot-9.scm	170413	0644	edit dl rm
buffered-input.scm	4935	0644	edit dl rm
calling.scm	10790	0644	edit dl rm
command-line.scm	19050	0644	edit dl rm
common-list.scm	9160	0644	edit dl rm
control.scm	4181	0644	edit dl rm
copy-tree.scm	3119	0644	edit dl rm
curried-definitions.scm	1829	0644	edit dl rm
deprecated.scm	1573	0644	edit dl rm
documentation.scm	7584	0644	edit dl rm
eval-string.scm	3058	0644	edit dl rm
eval.scm	25677	0644	edit dl rm
exceptions.scm	14730	0644	edit dl rm
expect.scm	5628	0644	edit dl rm
fdes-finalizers.scm	1084	0644	edit dl rm
format.scm	67038	0644	edit dl rm
ftw.scm	25666	0644	edit dl rm
futures.scm	10739	0644	edit dl rm
gap-buffer.scm	9825	0644	edit dl rm
getopt-long.scm	16888	0644	edit dl rm
hash-table.scm	1813	0644	edit dl rm
hcons.scm	2614	0644	edit dl rm
history.scm	2343	0644	edit dl rm
i18n.scm	21002	0644	edit dl rm
iconv.scm	3268	0644	edit dl rm
lineio.scm	3941	0644	edit dl rm
list.scm	1319	0644	edit dl rm
local-eval.scm	10072	0644	edit dl rm
ls.scm	3275	0644	edit dl rm
match.scm	2233	0644	edit dl rm
match.upstream.scm	36797	0644	edit dl rm
networking.scm	3407	0644	edit dl rm
null.scm	1239	0644	edit dl rm
occam-channel.scm	7436	0644	edit dl rm
optargs.scm	16123	0644	edit dl rm
peg.scm	1684	0644	edit dl rm
poe.scm	3382	0644	edit dl rm
poll.scm	5929	0644	edit dl rm
popen.scm	9490	0644	edit dl rm
ports.scm	19535	0644	edit dl rm
posix.scm	2793	0644	edit dl rm
pretty-print.scm	17289	0644	edit dl rm
psyntax-pp.scm	187271	0644	edit dl rm
psyntax.scm	152542	0644	edit dl rm
q.scm	4297	0644	edit dl rm
quasisyntax.scm	5348	0644	edit dl rm
r5rs.scm	1602	0644	edit dl rm
r6rs-libraries.scm	10633	0644	edit dl rm
r7rs-libraries.scm	4387	0644	edit dl rm
rdelim.scm	7902	0644	edit dl rm
read.scm	33301	0644	edit dl rm
readline.scm	9791	0644	edit dl rm
receive.scm	1082	0644	edit dl rm
regex.scm	9084	0644	edit dl rm
runq.scm	8379	0644	edit dl rm
rw.scm	1047	0644	edit dl rm
safe-r5rs.scm	7676	0644	edit dl rm
safe.scm	1279	0644	edit dl rm
sandbox.scm	35062	0644	edit dl rm
save-stack.scm	2198	0644	edit dl rm
scm-style-repl.scm	11900	0644	edit dl rm
serialize.scm	3869	0644	edit dl rm
session.scm	18146	0644	edit dl rm
slib.scm	1583	0644	edit dl rm
stack-catch.scm	1983	0644	edit dl rm
streams.scm	6004	0644	edit dl rm
string-fun.scm	9916	0644	edit dl rm
suspendable-ports.scm	30576	0644	edit dl rm
textual-ports.scm	2346	0644	edit dl rm
threads.scm	12839	0644	edit dl rm
time.scm	2121	0644	edit dl rm
top-repl.scm	2695	0644	edit dl rm
unicode.scm	1005	0644	edit dl rm
vlist.scm	22081	0644	edit dl rm
weak-vector.scm	1229	0644	edit dl rm

Edit: /usr/share/guile/3.0/ice-9/gap-buffer.scm (9825B)

;;; gap-buffer.scm --- String buffer that supports point

;;;	Copyright (C) 2002, 2003, 2006 Free Software Foundation, Inc.
;;;
;;;; This library is free software; you can redistribute it and/or
;;;; modify it under the terms of the GNU Lesser General Public
;;;; License as published by the Free Software Foundation; either
;;;; version 3 of the License, or (at your option) any later version.
;;;; 
;;;; This library is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;;;; Lesser General Public License for more details.
;;;; 
;;;; You should have received a copy of the GNU Lesser General Public
;;;; License along with this library; if not, write to the Free Software
;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
;;;

;;; Author: Thien-Thi Nguyen <ttn@gnu.org>

;;; Commentary:

;; A gap buffer is a structure that models a string but allows relatively
;; efficient insertion of text somewhere in the middle.  The insertion
;; location is called `point' with minimum value 1, and a maximum value of the
;; length of the string (which is not fixed).
;;
;; Specifically, we allocate a continuous buffer of characters that is
;; composed of the BEFORE, the GAP and the AFTER (reading L->R), like so:
;;
;;                          +--- POINT
;;                          v
;;    +--------------------+--------------------+--------------------+
;;    |       BEFORE       |        GAP         |       AFTER        |
;;    +--------------------+--------------------+--------------------+
;;
;;     <----- bef-sz ----->|<----- gap-sz ----->|<----- aft-sz ----->
;;
;;     <-------------------|       usr-sz       |------------------->
;;
;;     <-------------------------- all-sz -------------------------->
;;
;; This diagram also shows how the different sizes are computed, and the
;; location of POINT.  Note that the user-visible buffer size `usr-sz' does
;; NOT include the GAP, while the allocation `all-sz' DOES.
;;
;; The consequence of this arrangement is that "moving point" is simply a
;; matter of kicking characters across the GAP, while insertion can be viewed
;; as filling up the gap, increasing `bef-sz' and decreasing `gap-sz'.  When
;; `gap-sz' falls below some threshold, we reallocate with a larger `all-sz'.
;;
;; In the implementation, we actually keep track of the AFTER start offset
;; `aft-ofs' since it is used more often than `gap-sz'.  In fact, most of the
;; variables in the diagram are for conceptualization only.
;;
;; A gap buffer port is a soft port (see Guile manual) that wraps a gap
;; buffer.  Character and string writes, as well as character reads, are
;; supported.  Flushing and closing are not supported.
;;
;; These procedures are exported:
;;   (gb? OBJ)
;;   (make-gap-buffer . INIT)
;;   (gb-point GB)
;;   (gb-point-min GB)
;;   (gb-point-max GB)
;;   (gb-insert-string! GB STRING)
;;   (gb-insert-char! GB CHAR)
;;   (gb-delete-char! GB COUNT)
;;   (gb-goto-char GB LOCATION)
;;   (gb->string GB)
;;   (gb-filter! GB STRING-PROC)
;;   (gb->lines GB)
;;   (gb-filter-lines! GB LINES-PROC)
;;   (make-gap-buffer-port GB)
;;
;; INIT is an optional port or a string.  COUNT and LOCATION are integers.
;; STRING-PROC is a procedure that takes and returns a string.  LINES-PROC is
;; a procedure that takes and returns a list of strings, each representing a
;; line of text (newlines are stripped and added back automatically).
;;
;; (The term and concept of "gap buffer" are borrowed from Emacs.  We will
;; gladly return them when libemacs.so is available. ;-)
;;
;; Notes:
;; - overrun errors are suppressed silently

;;; Code:

(define-module (ice-9 gap-buffer)
  #:use-module (srfi srfi-9)
  #:export (gb?
            make-gap-buffer
            gb-point
            gb-point-min
            gb-point-max
            gb-insert-string!
            gb-insert-char!
            gb-delete-char!
            gb-erase!
            gb-goto-char
            gb->string
            gb-filter!
            gb->lines
            gb-filter-lines!
            make-gap-buffer-port))

(define-record-type gap-buffer
  (new)
  gb?
  (s s: s!)                             ; the buffer, a string
  (all-sz all-sz: all-sz!)              ; total allocation
  (gap-ofs gap-ofs: gap-ofs!)           ; GAP starts, aka (1- point)
  (aft-ofs aft-ofs: aft-ofs!))          ; AFTER starts

;; todo: expose
(define default-initial-allocation 128)
(define default-chunk-size 128)
(define default-realloc-threshold 32)

(define (round-up n)
  (* default-chunk-size (+ 1 (quotient n default-chunk-size))))

(define (realloc gb inc)
  (let* ((old-s   (s: gb))
         (all-sz  (all-sz: gb))
         (new-sz  (+ all-sz inc))
         (gap-ofs (gap-ofs: gb))
         (aft-ofs (aft-ofs: gb))
         (new-s   (make-string new-sz))
         (new-aft-ofs (+ aft-ofs inc)))
    (substring-move! old-s 0 gap-ofs new-s 0)
    (substring-move! old-s aft-ofs all-sz new-s new-aft-ofs)
    (s! gb new-s)
    (all-sz! gb new-sz)
    (aft-ofs! gb new-aft-ofs)))

(define (make-gap-buffer . init)        ; port/string
  (let ((gb (new)))
    (cond ((null? init)
           (s! gb (make-string default-initial-allocation))
           (all-sz! gb default-initial-allocation)
           (gap-ofs! gb 0)
           (aft-ofs! gb default-initial-allocation))
          (else (let ((jam! (lambda (string len)
                              (let ((alloc (round-up len)))
                                (s! gb (make-string alloc))
                                (all-sz! gb alloc)
                                (substring-move! string 0 len (s: gb) 0)
                                (gap-ofs! gb len)
                                (aft-ofs! gb alloc))))
                      (v (car init)))
                  (cond ((port? v)
                         (let ((next (lambda () (read-char v))))
                           (let loop ((c (next)) (acc '()) (len 0))
                             (if (eof-object? c)
                                 (jam! (list->string (reverse acc)) len)
                                 (loop (next) (cons c acc) (1+ len))))))
                        ((string? v)
                         (jam! v (string-length v)))
                        (else (error "bad init type"))))))
    gb))

(define (gb-point gb)
  (1+ (gap-ofs: gb)))

(define (gb-point-min gb) 1)            ; no narrowing (for now)

(define (gb-point-max gb)
  (1+ (- (all-sz: gb) (- (aft-ofs: gb) (gap-ofs: gb)))))

(define (insert-prep gb len)
  (let* ((gap-ofs (gap-ofs: gb))
         (aft-ofs (aft-ofs: gb))
         (slack (- (- aft-ofs gap-ofs) len)))
    (and (< slack default-realloc-threshold)
         (realloc gb (round-up (- slack))))
    gap-ofs))

(define (gb-insert-string! gb string)
  (let* ((len (string-length string))
         (gap-ofs (insert-prep gb len)))
    (substring-move! string 0 len (s: gb) gap-ofs)
    (gap-ofs! gb (+ gap-ofs len))))

(define (gb-insert-char! gb char)
  (let ((gap-ofs (insert-prep gb 1)))
    (string-set! (s: gb) gap-ofs char)
    (gap-ofs! gb (+ gap-ofs 1))))

(define (gb-delete-char! gb count)
  (cond ((< count 0)                    ; backwards
         (gap-ofs! gb (max 0 (+ (gap-ofs: gb) count))))
        ((> count 0)                    ; forwards
         (aft-ofs! gb (min (all-sz: gb) (+ (aft-ofs: gb) count))))
        ((= count 0)                    ; do nothing
         #t)))

(define (gb-erase! gb)
  (gap-ofs! gb 0)
  (aft-ofs! gb (all-sz: gb)))

(define (point++n! gb n s gap-ofs aft-ofs) ; n>0; warning: reckless
  (substring-move! s aft-ofs (+ aft-ofs n) s gap-ofs)
  (gap-ofs! gb (+ gap-ofs n))
  (aft-ofs! gb (+ aft-ofs n)))

(define (point+-n! gb n s gap-ofs aft-ofs) ; n<0; warning: reckless
  (substring-move! s (+ gap-ofs n) gap-ofs s (+ aft-ofs n))
  (gap-ofs! gb (+ gap-ofs n))
  (aft-ofs! gb (+ aft-ofs n)))

(define (gb-goto-char gb new-point)
  (let ((pmax (gb-point-max gb)))
    (or (and (< new-point 1)    (gb-goto-char gb 1))
        (and (> new-point pmax) (gb-goto-char gb pmax))
        (let ((delta (- new-point (gb-point gb))))
          (or (= delta 0)
              ((if (< delta 0)
                   point+-n!
                   point++n!)
               gb delta (s: gb) (gap-ofs: gb) (aft-ofs: gb))))))
  new-point)

(define (gb->string gb)
  (let ((s (s: gb)))
    (string-append (substring s 0 (gap-ofs: gb))
                   (substring s (aft-ofs: gb)))))

(define (gb-filter! gb string-proc)
  (let ((new (string-proc (gb->string gb))))
    (gb-erase! gb)
    (gb-insert-string! gb new)))

(define (gb->lines gb)
  (let ((str (gb->string gb)))
    (let loop ((start 0) (acc '()))
      (cond ((string-index str #\newline start)
             => (lambda (w)
                  (loop (1+ w) (cons (substring str start w) acc))))
            (else (reverse (cons (substring str start) acc)))))))

(define (gb-filter-lines! gb lines-proc)
  (let ((new-lines (lines-proc (gb->lines gb))))
    (gb-erase! gb)
    (gb-insert-string! gb (string-join new-lines #\newline))))

(define (make-gap-buffer-port gb)
  (or (gb? gb)
      (error "not a gap-buffer:" gb))
  (make-soft-port
   (vector
    (lambda (c) (gb-insert-char! gb c))
    (lambda (s) (gb-insert-string! gb s))
    #f
    (lambda () (let ((gap-ofs (gap-ofs: gb))
                     (aft-ofs (aft-ofs: gb)))
                 (if (= aft-ofs (all-sz: gb))
                     #f
                     (let* ((s (s: gb))
                            (c (string-ref s aft-ofs)))
                       (string-set! s gap-ofs c)
                       (gap-ofs! gb (1+ gap-ofs))
                       (aft-ofs! gb (1+ aft-ofs))
                       c))))
    #f)
   "rw"))

;;; gap-buffer.scm ends here

cmd: