Update of /project/flexichain/cvsroot/flexichain
In directory clnet:/tmp/cvs-serv19460
Modified Files:
flexichain-package.lisp flexichain.asd flexichain.lisp
flexicursor.lisp flexirank.lisp rtester.lisp skiplist.lisp
stupid.lisp tester.lisp
Log Message:
flexichain 1.4
* replaced tabs with spaces
* minor indentation and spacing whitespace fixes
Date: Sun Jan 27 01:05:37 2008
Author: charmon
Index: flexichain/flexichain-package.lisp
diff -u flexichain/flexichain-package.lisp:1.2 flexichain/flexichain-package.lisp:1.3
--- flexichain/flexichain-package.lisp:1.2 Fri Jan 25 18:59:21 2008
+++ flexichain/flexichain-package.lisp Sun Jan 27 01:05:37 2008
@@ -22,22 +22,22 @@
(defpackage :flexichain
(:use :common-lisp)
(:export #:flexichain #:standard-flexichain
- #:flexi-error #:flexi-initialization-error
- #:flexi-position-error #:flexi-incompatible-type-error
- #:nb-elements #:flexi-empty-p
- #:insert* #:insert-vector* #:element* #:delete* #:delete-elements*
- #:push-start #:pop-start #:push-end #:pop-end #:rotate
+ #:flexi-error #:flexi-initialization-error
+ #:flexi-position-error #:flexi-incompatible-type-error
+ #:nb-elements #:flexi-empty-p
+ #:insert* #:insert-vector* #:element* #:delete* #:delete-elements*
+ #:push-start #:pop-start #:push-end #:pop-end #:rotate
#:cursorchain #:standard-cursorchain
- #:flexicursor #:standard-flexicursor
- #:left-sticky-flexicursor #:right-sticky-flexicursor
- #:chain
+ #:flexicursor #:standard-flexicursor
+ #:left-sticky-flexicursor #:right-sticky-flexicursor
+ #:chain
#:clone-cursor #:cursor-pos
#:at-beginning-error #:at-end-error
- #:at-beginning-p #:at-end-p
- #:move> #:move<
- #:insert #:insert-sequence
- #:element< #:element> #:delete< #:delete>
- #:flexirank-mixin #:element-rank-mixin #:rank
- #:flexi-first-p #:flexi-last-p
- #:flexi-next #:flexi-prev))
+ #:at-beginning-p #:at-end-p
+ #:move> #:move<
+ #:insert #:insert-sequence
+ #:element< #:element> #:delete< #:delete>
+ #:flexirank-mixin #:element-rank-mixin #:rank
+ #:flexi-first-p #:flexi-last-p
+ #:flexi-next #:flexi-prev))
Index: flexichain/flexichain.asd
diff -u flexichain/flexichain.asd:1.5 flexichain/flexichain.asd:1.6
--- flexichain/flexichain.asd:1.5 Fri Jan 25 18:59:21 2008
+++ flexichain/flexichain.asd Sun Jan 27 01:05:37 2008
@@ -23,7 +23,7 @@
;; for testing.
(asdf:defsystem :flexichain
:name "flexichain"
- :version "1.3"
+ :version "1.4"
:components ((:file "flexichain-package")
(:file "utilities" :depends-on ("flexichain-package"))
(:file "flexichain" :depends-on ("utilities" "flexichain-package"))
Index: flexichain/flexichain.lisp
diff -u flexichain/flexichain.lisp:1.5 flexichain/flexichain.lisp:1.6
--- flexichain/flexichain.lisp:1.5 Sat Jan 26 06:23:09 2008
+++ flexichain/flexichain.lisp Sun Jan 27 01:05:37 2008
@@ -157,7 +157,7 @@
(defun required-space (chain nb-elements)
(with-slots (min-size expand-factor) chain
(+ 2 (max (ceiling (* nb-elements expand-factor))
- min-size))))
+ min-size))))
(defmethod initialize-instance :after ((chain standard-flexichain)
&rest initargs
@@ -182,10 +182,10 @@
(let* ((data-length (if (> (length initial-contents) initial-nb-elements)
(length initial-contents)
initial-nb-elements))
- (size (required-space chain data-length))
- (fill-size (- size data-length 2))
- (sentinel-list (make-list 2 :initial-element fill-element))
- (fill-list (make-list fill-size :initial-element fill-element)))
+ (size (required-space chain data-length))
+ (fill-size (- size data-length 2))
+ (sentinel-list (make-list 2 :initial-element fill-element))
+ (fill-list (make-list fill-size :initial-element fill-element)))
(setf buffer
(if initial-contents
(make-array size
@@ -209,10 +209,10 @@
(defmacro with-virtual-gap ((bl ds gs ge) chain &body body)
(let ((c (gensym)))
`(let* ((,c ,chain)
- (,bl (length (slot-value ,c 'buffer)))
- (,ds (slot-value ,c 'data-start))
- (,gs (slot-value ,c 'gap-start))
- (,ge (slot-value ,c 'gap-end)))
+ (,bl (length (slot-value ,c 'buffer)))
+ (,ds (slot-value ,c 'data-start))
+ (,gs (slot-value ,c 'gap-start))
+ (,ge (slot-value ,c 'gap-end)))
(declare (ignorable ,bl ,ds ,gs ,ge))
(when (< ,gs ,ds) (incf ,gs ,bl))
(when (< ,ge ,ds) (incf ,ge ,bl))
@@ -231,9 +231,9 @@
(with-virtual-gap (bl ds gs ge) chain
(let ((index (+ ds position 1)))
(when (>= index gs)
- (incf index (- ge gs)))
+ (incf index (- ge gs)))
(when (>= index bl)
- (decf index bl))
+ (decf index bl))
index)))
(defun index-position (chain index)
@@ -258,9 +258,9 @@
(defmethod insert* ((chain standard-flexichain) position object)
(with-slots (element-type buffer gap-start) chain
(assert (<= 0 position (nb-elements chain)) ()
- 'flexi-position-error :chain chain :position position)
+ 'flexi-position-error :chain chain :position position)
(assert (typep object element-type) ()
- 'flexi-incompatible-type-error :element object :chain chain)
+ 'flexi-incompatible-type-error :element object :chain chain)
(ensure-gap-position chain position)
(ensure-room chain (1+ (nb-elements chain)))
(setf (aref buffer gap-start) object)
@@ -271,16 +271,16 @@
(defmethod insert-vector* ((chain standard-flexichain) position vector)
(with-slots (element-type buffer gap-start) chain
(assert (<= 0 position (nb-elements chain)) ()
- 'flexi-position-error :chain chain :position position)
- (assert (subtypep (array-element-type vector) element-type) ()
- 'flexi-incompatible-type-error :element vector :chain chain)
+ 'flexi-position-error :chain chain :position position)
+ (assert (subtypep (array-element-type vector) element-type) ()
+ 'flexi-incompatible-type-error :element vector :chain chain)
(ensure-gap-position chain position)
(ensure-room chain (+ (nb-elements chain) (length vector)))
(loop for elem across vector
- do (setf (aref buffer gap-start) elem)
- (incf gap-start)
- (when (= gap-start (length buffer))
- (setf gap-start 0)))))
+ do (setf (aref buffer gap-start) elem)
+ (incf gap-start)
+ (when (= gap-start (length buffer))
+ (setf gap-start 0)))))
(defmethod delete* ((chain standard-flexichain) position)
(with-slots (buffer expand-factor min-size fill-element gap-end) chain
@@ -292,7 +292,7 @@
(when (= gap-end (length buffer))
(setf gap-end 0))
(when (and (> (length buffer) (+ min-size 2))
- (< (+ (nb-elements chain) 2) (/ (length buffer) (square expand-factor))))
+ (< (+ (nb-elements chain) 2) (/ (length buffer) (square expand-factor))))
(decrease-buffer-size chain))))
(defmethod delete-elements* ((chain standard-flexichain) position n)
@@ -324,15 +324,15 @@
(defmethod element* ((chain standard-flexichain) position)
(with-slots (buffer) chain
(assert (< -1 position (nb-elements chain)) ()
- 'flexi-position-error :chain chain :position position)
+ 'flexi-position-error :chain chain :position position)
(aref buffer (position-index chain position))))
(defmethod (setf element*) (object (chain standard-flexichain) position)
(with-slots (buffer element-type) chain
(assert (< -1 position (nb-elements chain)) ()
- 'flexi-position-error :chain chain :position position)
+ 'flexi-position-error :chain chain :position position)
(assert (typep object element-type) ()
- 'flexi-incompatible-type-error :chain chain :element object)
+ 'flexi-incompatible-type-error :chain chain :element object)
(setf (aref buffer (position-index chain position)) object)))
(defmethod push-start ((chain standard-flexichain) object)
@@ -342,19 +342,21 @@
(insert* chain (nb-elements chain) object))
(defmethod pop-start ((chain standard-flexichain))
- (prog1 (element* chain 0)
- (delete* chain 0)))
+ (prog1
+ (element* chain 0)
+ (delete* chain 0)))
(defmethod pop-end ((chain standard-flexichain))
(let ((position (1- (nb-elements chain))))
- (prog1 (element* chain position)
- (delete* chain position))))
+ (prog1
+ (element* chain position)
+ (delete* chain position))))
(defmethod rotate ((chain standard-flexichain) &optional (n 1))
(when (> (nb-elements chain) 1)
(cond ((plusp n) (loop repeat n do (push-start chain (pop-end chain))))
- ((minusp n) (loop repeat (- n) do (push-end chain (pop-start chain))))
- (t nil))))
+ ((minusp n) (loop repeat (- n) do (push-end chain (pop-start chain))))
+ (t nil))))
(defun move-gap (chain hot-spot)
"Moves the elements and gap inside the buffer so that
@@ -474,7 +476,7 @@
(let* ((buffer-size (length buffer))
(rotated-gap-end (if (zerop gap-end) buffer-size gap-end)))
(move-elements chain buffer buffer
- (- rotated-gap-end count) (- gap-start count) gap-start)
+ (- rotated-gap-end count) (- gap-start count) gap-start)
(fill-gap chain (- gap-start count) (min gap-start (- rotated-gap-end count)))
(decf gap-start count)
(setf gap-end (- rotated-gap-end count))
@@ -488,7 +490,7 @@
(let* ((buffer-size (length buffer))
(rotated-gap-start (if (zerop gap-start) buffer-size gap-start)))
(move-elements chain buffer buffer
- (- gap-end count) (- rotated-gap-start count) rotated-gap-start)
+ (- gap-end count) (- rotated-gap-start count) rotated-gap-start)
(fill-gap chain (- rotated-gap-start count) rotated-gap-start)
(setf gap-start (- rotated-gap-start count))
(decf gap-end count)
Index: flexichain/flexicursor.lisp
diff -u flexichain/flexicursor.lisp:1.4 flexichain/flexicursor.lisp:1.5
--- flexichain/flexicursor.lisp:1.4 Sat Jan 26 06:23:09 2008
+++ flexichain/flexicursor.lisp Sun Jan 27 01:05:37 2008
@@ -110,20 +110,20 @@
(defclass right-sticky-flexicursor (standard-flexicursor) ())
(defmethod initialize-instance :after ((cursor left-sticky-flexicursor)
- &rest initargs &key (position 0))
+ &rest initargs &key (position 0))
(declare (ignore initargs))
(with-slots (index chain) cursor
(setf index (position-index chain (1- position)))
(with-slots (cursors) chain
- (push (make-weak-pointer cursor) cursors))))
+ (push (make-weak-pointer cursor) cursors))))
(defmethod initialize-instance :after ((cursor right-sticky-flexicursor)
- &rest initargs &key (position 0))
+ &rest initargs &key (position 0))
(declare (ignore initargs))
(with-slots (index chain) cursor
(setf index (position-index chain position))
(with-slots (cursors) chain
- (push (make-weak-pointer cursor) cursors))))
+ (push (make-weak-pointer cursor) cursors))))
(defun adjust-cursors (cursors start end increment)
(let ((acc '()))
@@ -131,18 +131,18 @@
for cursor = (and cursors (weak-pointer-value (car cursors)))
while cursors
do (cond ((null cursor)
- (pop cursors))
- ((<= start (flexicursor-index cursor) end)
- (incf (flexicursor-index cursor) increment)
- (let ((rest (cdr cursors)))
- (setf (cdr cursors) acc
- acc cursors
- cursors rest)))
- (t
- (let ((rest (cdr cursors)))
- (setf (cdr cursors) acc
- acc cursors
- cursors rest)))))
+ (pop cursors))
+ ((<= start (flexicursor-index cursor) end)
+ (incf (flexicursor-index cursor) increment)
+ (let ((rest (cdr cursors)))
+ (setf (cdr cursors) acc
+ acc cursors
+ cursors rest)))
+ (t
+ (let ((rest (cdr cursors)))
+ (setf (cdr cursors) acc
+ acc cursors
+ cursors rest)))))
acc))
(defmethod move-elements :after ((cc standard-cursorchain) to from start1 start2 end2)
@@ -160,7 +160,7 @@
(defmethod (setf cursor-pos) (position (cursor left-sticky-flexicursor))
(assert (<= 0 position (nb-elements (chain cursor))) ()
- 'flexi-position-error :chain (chain cursor) :position position)
+ 'flexi-position-error :chain (chain cursor) :position position)
(with-slots (chain) cursor
(setf (flexicursor-index cursor) (position-index chain (1- position)))))
@@ -169,7 +169,7 @@
(defmethod (setf cursor-pos) (position (cursor right-sticky-flexicursor))
(assert (<= 0 position (nb-elements (chain cursor))) ()
- 'flexi-position-error :chain (chain cursor) :position position)
+ 'flexi-position-error :chain (chain cursor) :position position)
(with-slots (chain) cursor
(setf (flexicursor-index cursor) (position-index chain position))))
@@ -185,18 +185,18 @@
(defmethod insert-sequence ((cursor standard-flexicursor) sequence)
(map nil
(lambda (object)
- (insert cursor object))
+ (insert cursor object))
sequence))
(defmethod delete* :before ((chain standard-cursorchain) position)
(with-slots (cursors) chain
(let* ((old-index (position-index chain position)))
(loop for cursor-wp in cursors
- as cursor = (weak-pointer-value cursor-wp)
- when (and cursor (= old-index (flexicursor-index cursor)))
- do (typecase cursor
- (right-sticky-flexicursor (incf (cursor-pos cursor)))
- (left-sticky-flexicursor (decf (cursor-pos cursor))))))))
+ as cursor = (weak-pointer-value cursor-wp)
+ when (and cursor (= old-index (flexicursor-index cursor)))
+ do (typecase cursor
+ (right-sticky-flexicursor (incf (cursor-pos cursor)))
+ (left-sticky-flexicursor (decf (cursor-pos cursor))))))))
(defmethod delete-elements* :before ((chain standard-cursorchain) position n)
(with-slots (cursors) chain
@@ -218,17 +218,17 @@
(let ((chain (chain cursor))
(position (cursor-pos cursor)))
(assert (plusp n) ()
- 'flexi-position-error :chain chain :position n)
+ 'flexi-position-error :chain chain :position n)
(loop repeat n
do (delete* chain position))))
(defmethod delete< ((cursor standard-flexicursor) &optional (n 1))
(let ((chain (chain cursor))
- (position (cursor-pos cursor)))
+ (position (cursor-pos cursor)))
(assert (plusp n) ()
- 'flexi-position-error :chain chain :position n)
+ 'flexi-position-error :chain chain :position n)
(loop repeat n
- do (delete* chain (- position n)))))
+ do (delete* chain (- position n)))))
(defmethod element> ((cursor standard-flexicursor))
(assert (not (at-end-p cursor)) ()
Index: flexichain/flexirank.lisp
diff -u flexichain/flexirank.lisp:1.3 flexichain/flexirank.lisp:1.4
--- flexichain/flexirank.lisp:1.3 Tue Oct 17 12:02:02 2006
+++ flexichain/flexirank.lisp Sun Jan 27 01:05:37 2008
@@ -60,21 +60,21 @@
(defmethod move-elements :before ((chain flexirank-mixin) to from start1 start2 end2)
(declare (ignore to))
(loop for old from start2 below end2
- for new from start1
- do (let ((element (aref from old)))
- (when (typep element 'element-rank-mixin)
- (setf (index element) new)))))
+ for new from start1
+ do (let ((element (aref from old)))
+ (when (typep element 'element-rank-mixin)
+ (setf (index element) new)))))
(defmethod insert* :after ((chain flexirank-mixin) position (object element-rank-mixin))
(setf (index object) (position-index chain position)
- (chain object) chain))
+ (chain object) chain))
(defmethod (setf element*) :after ((object element-rank-mixin) (chain flexirank-mixin) position)
(setf (index object) (position-index chain position)
- (chain object) chain))
+ (chain object) chain))
(defmethod insert-vector* :after ((chain flexirank-mixin) position vector)
(loop for elem across vector
- for pos from position
- do (setf (index elem) (position-index chain pos)
- (chain elem) chain)))
+ for pos from position
+ do (setf (index elem) (position-index chain pos)
+ (chain elem) chain)))
Index: flexichain/rtester.lisp
diff -u flexichain/rtester.lisp:1.1.1.1 flexichain/rtester.lisp:1.2
--- flexichain/rtester.lisp:1.1.1.1 Wed Feb 8 21:51:06 2006
+++ flexichain/rtester.lisp Sun Jan 27 01:05:37 2008
@@ -40,30 +40,30 @@
(defun compare ()
;; check that they are the same length
(assert (= (flexichain:nb-elements *fc-real*)
- (stupid:nb-elements *fc-fake*)))
+ (stupid:nb-elements *fc-fake*)))
;; check that they have the same elements in the same places
(loop for pos from 0 below (flexichain:nb-elements *fc-real*)
- do (assert (= (flexichain:element* *fc-real* pos)
- (stupid:element* *fc-fake* pos))))
+ do (assert (= (flexichain:element* *fc-real* pos)
+ (stupid:element* *fc-fake* pos))))
;; check all the cursors
(loop for x in *cursors-real*
- for y in *cursors-fake*
- do (assert (= (flexichain:cursor-pos x)
- (stupid:cursor-pos y)))
- (unless (zerop (flexichain:cursor-pos x))
- (assert (= (flexichain:element< x)
- (stupid:element< y))))
- (unless (= (flexichain:cursor-pos x)
- (flexichain:nb-elements *fc-real*))
- (assert (= (flexichain:element> x)
- (stupid:element> y))))))
+ for y in *cursors-fake*
+ do (assert (= (flexichain:cursor-pos x)
+ (stupid:cursor-pos y)))
+ (unless (zerop (flexichain:cursor-pos x))
+ (assert (= (flexichain:element< x)
+ (stupid:element< y))))
+ (unless (= (flexichain:cursor-pos x)
+ (flexichain:nb-elements *fc-real*))
+ (assert (= (flexichain:element> x)
+ (stupid:element> y))))))
(defun add-inst (inst)
(push inst *instructions*))
(defun i* (&optional
- (pos (random (1+ (stupid:nb-elements *fc-fake*))))
- (elem (random 1000000)))
+ (pos (random (1+ (stupid:nb-elements *fc-fake*))))
+ (elem (random 1000000)))
(add-inst `(i* ,pos ,elem))
(flexichain:insert* *fc-real* pos elem)
(stupid:insert* *fc-fake* pos elem))
@@ -80,7 +80,7 @@
(unless (zerop (stupid:nb-elements *fc-fake*))
(unless pos
(setf pos (random (stupid:nb-elements *fc-fake*))
- elem (random 1000000)))
+ elem (random 1000000)))
(add-inst `(se* ,pos ,elem))
(setf (flexichain:element* *fc-real* pos) elem)
(setf (stupid:element* *fc-fake* pos) elem)))
@@ -88,16 +88,16 @@
(defun mlc ()
(add-inst `(mlc))
(push (make-instance 'flexichain:left-sticky-flexicursor :chain *fc-real*)
- *cursors-real*)
+ *cursors-real*)
(push (make-instance 'stupid:left-sticky-flexicursor :chain *fc-fake*)
- *cursors-fake*))
+ *cursors-fake*))
(defun mrc ()
(add-inst `(mrc))
(push (make-instance 'flexichain:right-sticky-flexicursor :chain *fc-real*)
- *cursors-real*)
+ *cursors-real*)
(push (make-instance 'stupid:right-sticky-flexicursor :chain *fc-fake*)
- *cursors-fake*))
+ *cursors-fake*))
(defun cc (&optional (elt (random (length *cursors-real*))))
@@ -106,15 +106,15 @@
(push (stupid:clone-cursor (elt *cursors-fake* elt)) *cursors-fake*))
(defun scp (&optional
- (elt (random (length *cursors-real*)))
- (pos (random (1+ (flexichain:nb-elements *fc-real*)))))
+ (elt (random (length *cursors-real*)))
+ (pos (random (1+ (flexichain:nb-elements *fc-real*)))))
(add-inst `(scp ,elt ,pos))
(setf (flexichain:cursor-pos (elt *cursors-real* elt)) pos)
(setf (stupid:cursor-pos (elt *cursors-fake* elt)) pos))
(defun ii (&optional
- (elt (random (length *cursors-fake*)))
- (elem (random 1000000)))
+ (elt (random (length *cursors-fake*)))
+ (elem (random 1000000)))
(add-inst `(ii ,elt ,elem))
(flexichain:insert (elt *cursors-real* elt) elem)
(stupid:insert (elt *cursors-fake* elt) elem))
@@ -127,24 +127,24 @@
(defun d> (&optional (elt (random (length *cursors-fake*))))
(unless (= (stupid:cursor-pos (elt *cursors-fake* elt))
- (stupid:nb-elements (stupid:chain (elt *cursors-fake* elt))))
+ (stupid:nb-elements (stupid:chain (elt *cursors-fake* elt))))
(add-inst `(d> ,elt))
(flexichain:delete> (elt *cursors-real* elt))
(stupid:delete> (elt *cursors-fake* elt))))
(defun s< (&optional
- (elt (random (length *cursors-real*)))
- (elem (random 1000000)))
+ (elt (random (length *cursors-real*)))
+ (elem (random 1000000)))
(unless (zerop (stupid:cursor-pos (elt *cursors-fake* elt)))
(add-inst `(s< ,elt ,elem))
(setf (flexichain:element< (elt *cursors-real* elt)) elem)
(setf (stupid:element< (elt *cursors-fake* elt)) elem)))
(defun s> (&optional
- (elt (random (length *cursors-real*)))
- (elem (random 1000000)))
+ (elt (random (length *cursors-real*)))
+ (elem (random 1000000)))
(unless (= (stupid:cursor-pos (elt *cursors-fake* elt))
- (stupid:nb-elements (stupid:chain (elt *cursors-fake* elt))))
+ (stupid:nb-elements (stupid:chain (elt *cursors-fake* elt))))
(add-inst `(s> ,elt ,elem))
(setf (flexichain:element> (elt *cursors-real* elt)) elem)
(setf (stupid:element> (elt *cursors-fake* elt)) elem)))
@@ -152,8 +152,8 @@
(defmacro randomcase (&body clauses)
`(ecase (random ,(length clauses))
,@(loop for clause in clauses
- for i from 0
- collect `(,i ,clause))))
+ for i from 0
+ collect `(,i ,clause))))
(defun i-or-d ()
(if *ins-del-state*
@@ -185,11 +185,11 @@
(mlc)
(mrc)
(loop repeat n
- do (test-step)))
+ do (test-step)))
(defun replay (instructions)
(let ((*instructions* '()))
(reset-all)
(loop for inst in (reverse instructions)
- do (apply (car inst) (cdr inst))
- (compare))))
+ do (apply (car inst) (cdr inst))
+ (compare))))
Index: flexichain/skiplist.lisp
diff -u flexichain/skiplist.lisp:1.1.1.1 flexichain/skiplist.lisp:1.2
--- flexichain/skiplist.lisp:1.1.1.1 Wed Feb 8 21:51:06 2006
+++ flexichain/skiplist.lisp Sun Jan 27 01:05:37 2008
@@ -35,11 +35,11 @@
(print-unreadable-object (s stream :type t)
(with-slots (start) s
(when (entry-next start 0)
- (loop for entry = (entry-next start 0) then (entry-next entry 0)
- do (format stream "(~W ~W) "
- (entry-key entry)
- (entry-obj entry))
- until (last-entry-p start entry 0))))))
+ (loop for entry = (entry-next start 0) then (entry-next entry 0)
+ do (format stream "(~W ~W) "
+ (entry-key entry)
+ (entry-obj entry))
+ until (last-entry-p start entry 0))))))
(defun entry-obj (entry)
(aref entry 0))
@@ -88,18 +88,18 @@
(defun find-entry-level (skiplist entry level key)
(with-slots (start) skiplist
(loop until (or (key-= skiplist (entry-key (entry-next entry level)) key)
- (and (key-< skiplist (entry-key entry) key)
- (key-> skiplist (entry-key (entry-next entry level)) key))
- (and (key-< skiplist (entry-key entry) key)
- (key-< skiplist (entry-key (entry-next entry level)) key)
- (last-entry-p start entry level)
- (eq (entry-next entry level) (entry-next start level)))
- (and (key-> skiplist (entry-key entry) key)
- (key-> skiplist (entry-key (entry-next entry level)) key)
- (last-entry-p start entry level)))
- do (setf entry (entry-next entry level))))
+ (and (key-< skiplist (entry-key entry) key)
+ (key-> skiplist (entry-key (entry-next entry level)) key))
+ (and (key-< skiplist (entry-key entry) key)
+ (key-< skiplist (entry-key (entry-next entry level)) key)
+ (last-entry-p start entry level)
+ (eq (entry-next entry level) (entry-next start level)))
+ (and (key-> skiplist (entry-key entry) key)
+ (key-> skiplist (entry-key (entry-next entry level)) key)
+ (last-entry-p start entry level)))
+ do (setf entry (entry-next entry level))))
entry)
-
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
@@ -111,10 +111,10 @@
(with-slots (current-maxlevel start) skiplist
(let ((entry (entry-next start current-maxlevel)))
(loop for l downfrom current-maxlevel to 0
- do (setf entry (find-entry-level skiplist entry l key)))
+ do (setf entry (find-entry-level skiplist entry l key)))
(if (key-= skiplist (entry-key (entry-next entry 0)) key)
- (values (entry-obj (entry-next entry 0)) t)
- (values nil nil)))))
+ (values (entry-obj (entry-next entry 0)) t)
+ (values nil nil)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
@@ -124,7 +124,7 @@
(assert (not (skiplist-empty-p skiplist)))
(with-slots (start) skiplist
(values (entry-obj (entry-next start 0))
- (entry-key (entry-next start 0)))))
+ (entry-key (entry-next start 0)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
@@ -132,37 +132,37 @@
(defun pick-a-level (maxlevel)
(loop for level from 0 to maxlevel
- while (zerop (random 2))
- finally (return level)))
+ while (zerop (random 2))
+ finally (return level)))
(defun make-entry (level key obj)
(let ((entry (make-array (+ level 3) :initial-element nil)))
(setf (aref entry 0) obj
- (aref entry 1) key)
+ (aref entry 1) key)
entry))
(defun (setf skiplist-find) (obj skiplist key)
(with-slots (current-maxlevel start) skiplist
(if (second (multiple-value-list (skiplist-find skiplist key)))
- (let ((entry (entry-next start current-maxlevel)))
- (loop for l downfrom current-maxlevel to 0
- do (setf entry (find-entry-level skiplist entry l key)))
- (setf (entry-obj (entry-next entry 0)) obj))
- (let* ((level (pick-a-level (maxlevel skiplist)))
- (new-entry (make-entry level key obj)))
- (loop for l downfrom level above current-maxlevel
- do (setf (entry-next start l) new-entry
- (entry-next new-entry l) new-entry))
- (let ((entry (entry-next start current-maxlevel)))
- (loop for l downfrom current-maxlevel above level
- do (setf entry (find-entry-level skiplist entry l key)))
- (loop for l downfrom (min level current-maxlevel) to 0
- do (setf entry (find-entry-level skiplist entry l key))
- (setf (entry-next new-entry l) (entry-next entry l)
- (entry-next entry l) new-entry)
- (when (key-< skiplist key (entry-key entry))
- (setf (entry-next start l) new-entry))))
- (setf current-maxlevel (max current-maxlevel level)))))
+ (let ((entry (entry-next start current-maxlevel)))
+ (loop for l downfrom current-maxlevel to 0
+ do (setf entry (find-entry-level skiplist entry l key)))
+ (setf (entry-obj (entry-next entry 0)) obj))
+ (let* ((level (pick-a-level (maxlevel skiplist)))
+ (new-entry (make-entry level key obj)))
+ (loop for l downfrom level above current-maxlevel
+ do (setf (entry-next start l) new-entry
+ (entry-next new-entry l) new-entry))
+ (let ((entry (entry-next start current-maxlevel)))
+ (loop for l downfrom current-maxlevel above level
+ do (setf entry (find-entry-level skiplist entry l key)))
+ (loop for l downfrom (min level current-maxlevel) to 0
+ do (setf entry (find-entry-level skiplist entry l key))
+ (setf (entry-next new-entry l) (entry-next entry l)
+ (entry-next entry l) new-entry)
+ (when (key-< skiplist key (entry-key entry))
+ (setf (entry-next start l) new-entry))))
+ (setf current-maxlevel (max current-maxlevel level)))))
skiplist)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -174,20 +174,20 @@
(with-slots (current-maxlevel start) skiplist
(let ((entry (entry-next start current-maxlevel)))
(loop for l downfrom current-maxlevel to 0
- do (setf entry (find-entry-level skiplist entry l key))
- when (key-= skiplist (entry-key (entry-next entry l)) key)
- do (cond ((key-= skiplist (entry-key entry) key)
- (setf (entry-next start l) nil))
- ((key-< skiplist (entry-key entry) key)
- (setf (entry-next entry l)
- (entry-next (entry-next entry l) l)))
- (t (setf (entry-next entry l)
- (entry-next (entry-next entry l) l))
- (setf (entry-next start l)
- (entry-next entry l)))))
+ do (setf entry (find-entry-level skiplist entry l key))
+ when (key-= skiplist (entry-key (entry-next entry l)) key)
+ do (cond ((key-= skiplist (entry-key entry) key)
+ (setf (entry-next start l) nil))
+ ((key-< skiplist (entry-key entry) key)
+ (setf (entry-next entry l)
+ (entry-next (entry-next entry l) l)))
+ (t (setf (entry-next entry l)
+ (entry-next (entry-next entry l) l))
+ (setf (entry-next start l)
+ (entry-next entry l)))))
(loop while (and (null (entry-next start current-maxlevel))
- (>= current-maxlevel 0))
- do (decf current-maxlevel))))
+ (>= current-maxlevel 0))
+ do (decf current-maxlevel))))
skiplist)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -197,21 +197,21 @@
(defun update-interval (skiplist entry to update-key)
(with-slots (start) skiplist
(flet ((update-entry (entry)
- (setf (entry-key entry)
- (funcall update-key (entry-key entry) (entry-obj entry)))))
+ (setf (entry-key entry)
+ (funcall update-key (entry-key entry) (entry-obj entry)))))
(loop while (key-<= skiplist (entry-key entry) to)
- do (update-entry entry)
- until (last-entry-p start entry 0)
- do (setf entry (entry-next entry 0))))))
+ do (update-entry entry)
+ until (last-entry-p start entry 0)
+ do (setf entry (entry-next entry 0))))))
(defun skiplist-slide-keys (skiplist from to update-key)
(unless (skiplist-empty-p skiplist)
(with-slots (current-maxlevel start) skiplist
(let ((entry (entry-next start current-maxlevel)))
- (loop for l downfrom current-maxlevel to 0
- do (setf entry (find-entry-level skiplist entry l from)))
- (when (key->= skiplist (entry-key (entry-next entry 0)) from)
- (update-interval skiplist (entry-next entry 0) to update-key)))))
+ (loop for l downfrom current-maxlevel to 0
+ do (setf entry (find-entry-level skiplist entry l from)))
+ (when (key->= skiplist (entry-key (entry-next entry 0)) from)
+ (update-interval skiplist (entry-next entry 0) to update-key)))))
skiplist)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -222,22 +222,22 @@
(unless (skiplist-empty-p skiplist)
(with-slots (current-maxlevel start) skiplist
(let ((entry (entry-next start current-maxlevel)))
- (loop for l downfrom current-maxlevel to 0
- do (setf entry (find-entry-level skiplist entry l to)))
- (when (key-= skiplist (entry-key (entry-next entry 0)) to)
- (setf entry (entry-next entry 0)))
- (cond ((and (key-> skiplist (entry-key entry) to)
- (key-> skiplist (entry-key (entry-next entry 0)) to))
- nil)
- ((and (key-<= skiplist (entry-key entry) to)
- (key-<= skiplist (entry-key (entry-next entry 0)) to))
- (update-interval skiplist (entry-next entry 0) to update-key))
- (t (update-interval skiplist (entry-next start 0) to update-key)
- (loop with entry = (entry-next entry 0)
- for level from 0 to current-maxlevel
- do (loop until (>= (length entry) (+ 3 level))
- do (setf entry (entry-next entry (1- level))))
- (setf (entry-next start level) entry)))))))
+ (loop for l downfrom current-maxlevel to 0
+ do (setf entry (find-entry-level skiplist entry l to)))
+ (when (key-= skiplist (entry-key (entry-next entry 0)) to)
+ (setf entry (entry-next entry 0)))
+ (cond ((and (key-> skiplist (entry-key entry) to)
+ (key-> skiplist (entry-key (entry-next entry 0)) to))
+ nil)
+ ((and (key-<= skiplist (entry-key entry) to)
+ (key-<= skiplist (entry-key (entry-next entry 0)) to))
+ (update-interval skiplist (entry-next entry 0) to update-key))
+ (t (update-interval skiplist (entry-next start 0) to update-key)
+ (loop with entry = (entry-next entry 0)
+ for level from 0 to current-maxlevel
+ do (loop until (>= (length entry) (+ 3 level))
+ do (setf entry (entry-next entry (1- level))))
+ (setf (entry-next start level) entry)))))))
skiplist)
@@ -248,28 +248,28 @@
(defun update-interval-to-end (skiplist entry update-key)
(with-slots (start) skiplist
(flet ((update-entry (entry)
- (setf (entry-key entry)
- (funcall update-key (entry-key entry) (entry-obj entry)))))
+ (setf (entry-key entry)
+ (funcall update-key (entry-key entry) (entry-obj entry)))))
(loop do (update-entry entry)
- until (last-entry-p start entry 0)
- do (setf entry (entry-next entry 0))))))
+ until (last-entry-p start entry 0)
+ do (setf entry (entry-next entry 0))))))
(defun skiplist-rotate-suffix (skiplist from update-key)
(unless (skiplist-empty-p skiplist)
(with-slots (current-maxlevel start) skiplist
(let ((entry (entry-next start current-maxlevel)))
- (loop for l downfrom current-maxlevel to 0
- do (setf entry (find-entry-level skiplist entry l from)))
- (cond ((and (key-< skiplist (entry-key entry) from)
- (key-< skiplist (entry-key (entry-next entry 0)) from))
- nil)
- ((and (key->= skiplist (entry-key entry) from)
- (key->= skiplist (entry-key (entry-next entry 0)) from))
- (update-interval-to-end skiplist (entry-next entry 0) update-key))
- (t (update-interval-to-end skiplist (entry-next entry 0) update-key)
- (loop with entry = (entry-next entry 0)
- for level from 0 to current-maxlevel
- do (loop until (>= (length entry) (+ 3 level))
- do (setf entry (entry-next entry (1- level))))
- (setf (entry-next start level) entry)))))))
+ (loop for l downfrom current-maxlevel to 0
+ do (setf entry (find-entry-level skiplist entry l from)))
+ (cond ((and (key-< skiplist (entry-key entry) from)
+ (key-< skiplist (entry-key (entry-next entry 0)) from))
+ nil)
+ ((and (key->= skiplist (entry-key entry) from)
+ (key->= skiplist (entry-key (entry-next entry 0)) from))
+ (update-interval-to-end skiplist (entry-next entry 0) update-key))
+ (t (update-interval-to-end skiplist (entry-next entry 0) update-key)
+ (loop with entry = (entry-next entry 0)
+ for level from 0 to current-maxlevel
+ do (loop until (>= (length entry) (+ 3 level))
+ do (setf entry (entry-next entry (1- level))))
+ (setf (entry-next start level) entry)))))))
skiplist)
Index: flexichain/stupid.lisp
diff -u flexichain/stupid.lisp:1.1.1.1 flexichain/stupid.lisp:1.2
--- flexichain/stupid.lisp:1.1.1.1 Wed Feb 8 21:51:06 2006
+++ flexichain/stupid.lisp Sun Jan 27 01:05:37 2008
@@ -6,21 +6,21 @@
(defpackage :stupid
(:use :common-lisp)
(:export #:flexichain #:standard-flexichain
- #:flexi-error #:flexi-initialization-error
- #:flexi-position-error #:flexi-incompatible-type-error
- #:nb-elements #:flexi-empty-p
- #:insert* #:element* #:delete*
- #:push-start #:pop-start #:push-end #:pop-end #:rotate
+ #:flexi-error #:flexi-initialization-error
+ #:flexi-position-error #:flexi-incompatible-type-error
+ #:nb-elements #:flexi-empty-p
+ #:insert* #:element* #:delete*
+ #:push-start #:pop-start #:push-end #:pop-end #:rotate
#:cursorchain #:standard-cursorchain
- #:flexicursor #:standard-flexicursor
- #:left-sticky-flexicursor #:right-sticky-flexicursor
- #:chain
+ #:flexicursor #:standard-flexicursor
+ #:left-sticky-flexicursor #:right-sticky-flexicursor
+ #:chain
#:clone-cursor #:cursor-pos
#:at-beginning-error #:at-end-error
- #:at-beginning-p #:at-end-p
- #:move> #:move<
- #:insert #:insert-sequence
- #:element< #:element> #:delete< #:delete>))
+ #:at-beginning-p #:at-end-p
+ #:move> #:move<
+ #:insert #:insert-sequence
+ #:element< #:element> #:delete< #:delete>))
(in-package :stupid)
@@ -118,17 +118,17 @@
(defmethod insert* ((chain standard-flexichain) position object)
(assert (<= 0 position (nb-elements chain)) ()
- 'flexi-position-error :chain chain :position position)
+ 'flexi-position-error :chain chain :position position)
(let* ((remainder (nthcdr (* 2 position) (elements chain))))
(push (remove-if-not (lambda (x) (typep x 'right-sticky-flexicursor)) (car remainder))
- (cdr remainder))
+ (cdr remainder))
(push object (cdr remainder))
(setf (car remainder)
- (remove-if (lambda (x) (typep x 'right-sticky-flexicursor)) (car remainder)))))
+ (remove-if (lambda (x) (typep x 'right-sticky-flexicursor)) (car remainder)))))
(defmethod delete* ((chain standard-flexichain) position)
(assert (< -1 position (nb-elements chain)) ()
- 'flexi-position-error :chain chain :position position)
+ 'flexi-position-error :chain chain :position position)
(let* ((remainder (nthcdr (* 2 position) (elements chain))))
(pop (cdr remainder))
(setf (car remainder) (append (cadr remainder) (car remainder)))
@@ -136,12 +136,12 @@
(defmethod element* ((chain standard-flexichain) position)
(assert (< -1 position (nb-elements chain)) ()
- 'flexi-position-error :chain chain :position position)
+ 'flexi-position-error :chain chain :position position)
(nth (1+ (* 2 position)) (elements chain)))
(defmethod (setf element*) (object (chain standard-flexichain) position)
(assert (< -1 position (nb-elements chain)) ()
- 'flexi-position-error :chain chain :position position)
+ 'flexi-position-error :chain chain :position position)
(setf (nth (1+ (* 2 position)) (elements chain)) object))
(defmethod push-start ((chain standard-flexichain) object)
@@ -152,18 +152,18 @@
(defmethod pop-start ((chain standard-flexichain))
(prog1 (element* chain 0)
- (delete* chain 0)))
+ (delete* chain 0)))
(defmethod pop-end ((chain standard-flexichain))
(let ((position (1- (nb-elements chain))))
(prog1 (element* chain position)
- (delete* chain position))))
+ (delete* chain position))))
(defmethod rotate ((chain standard-flexichain) &optional (n 1))
(when (> (nb-elements chain) 1)
(cond ((plusp n) (loop repeat n do (push-start chain (pop-end chain))))
- ((minusp n) (loop repeat (- n) do (push-end chain (pop-start chain))))
- (t nil))))
+ ((minusp n) (loop repeat (- n) do (push-end chain (pop-start chain))))
+ (t nil))))
(defclass cursorchain (flexichain)
()
@@ -249,7 +249,7 @@
(:documentation "The standard instantiable subclass of FLEXICURSOR"))
(defmethod initialize-instance :after ((cursor standard-flexicursor)
- &rest args &key (position 0))
+ &rest args &key (position 0))
(declare (ignore args))
(push cursor (car (nthcdr (* 2 position) (elements (chain cursor))))))
@@ -259,9 +259,9 @@
(defmethod cursor-pos ((cursor standard-flexicursor))
(loop for sublist on (elements (chain cursor)) by #'cddr
- for pos from 0
- when (member cursor (car sublist) :test #'eq)
- do (return pos)))
+ for pos from 0
+ when (member cursor (car sublist) :test #'eq)
+ do (return pos)))
(defun sublist-of-cursor (cursor)
(nthcdr (* 2 (cursor-pos cursor)) (elements (chain cursor))))
@@ -273,9 +273,9 @@
(defmethod (setf cursor-pos) (position (cursor standard-flexicursor))
(assert (<= 0 position (nb-elements (chain cursor))) ()
- 'flexi-position-error :chain (chain cursor) :position position)
+ 'flexi-position-error :chain (chain cursor) :position position)
(let ((sublist1 (sublist-of-cursor cursor))
- (sublist2 (nthcdr (* 2 position) (elements (chain cursor)))))
+ (sublist2 (nthcdr (* 2 position) (elements (chain cursor)))))
(setf (car sublist1) (remove cursor (car sublist1) :test #'eq))
(push cursor (car sublist2))))
@@ -297,24 +297,24 @@
(defmethod insert-sequence ((cursor standard-flexicursor) sequence)
(map nil
(lambda (object)
- (insert cursor object))
+ (insert cursor object))
sequence))
(defmethod delete> ((cursor standard-flexicursor) &optional (n 1))
(let ((chain (chain cursor))
(position (cursor-pos cursor)))
(assert (plusp n) ()
- 'flexi-position-error :chain chain :position n)
+ 'flexi-position-error :chain chain :position n)
(loop repeat n
do (delete* chain position))))
(defmethod delete< ((cursor standard-flexicursor) &optional (n 1))
(let ((chain (chain cursor))
- (position (cursor-pos cursor)))
+ (position (cursor-pos cursor)))
(assert (plusp n) ()
- 'flexi-position-error :chain chain :position n)
+ 'flexi-position-error :chain chain :position n)
(loop repeat n
- do (delete* chain (- position n)))))
+ do (delete* chain (- position n)))))
(defmethod element> ((cursor standard-flexicursor))
(assert (not (at-end-p cursor)) ()
Index: flexichain/tester.lisp
diff -u flexichain/tester.lisp:1.1.1.1 flexichain/tester.lisp:1.2
--- flexichain/tester.lisp:1.1.1.1 Wed Feb 8 21:51:06 2006
+++ flexichain/tester.lisp Sun Jan 27 01:05:37 2008
@@ -2,9 +2,9 @@
(define-application-frame tester ()
((chain :initform (make-instance 'standard-cursorchain
- :element-type 'character
- :fill-element #\_)
- :reader chain)
+ :element-type 'character
+ :fill-element #\_)
+ :reader chain)
(cursors :initform (make-array 2) :reader cursors))
(:panes
(app :application :width 800 :height 300 :display-function 'display-app)
@@ -15,67 +15,67 @@
(declare (ignore args))
(with-slots (chain cursors) frame
(setf (aref cursors 0)
- (make-instance 'left-sticky-flexicursor :chain chain))
+ (make-instance 'left-sticky-flexicursor :chain chain))
(setf (aref cursors 1)
- (make-instance 'right-sticky-flexicursor :chain chain))))
+ (make-instance 'right-sticky-flexicursor :chain chain))))
(defun run-tester ()
(loop for port in climi::*all-ports*
- do (destroy-port port))
+ do (destroy-port port))
(setq climi::*all-ports* nil)
(run-frame-top-level (make-application-frame 'tester)))
(defun display-app (frame pane)
(let* ((chain (chain frame))
- (buffer (slot-value chain 'flexichain::buffer))
- (length (length buffer))
- (cursors (cursors frame)))
+ (buffer (slot-value chain 'flexichain::buffer))
+ (length (length buffer))
+ (cursors (cursors frame)))
(format pane "nb elments: ~a~%~%" (nb-elements chain))
(loop for i from 0 below (nb-elements chain)
- do (format pane " ~a" (element* chain i)))
+ do (format pane " ~a" (element* chain i)))
(format pane "~%")
(loop for i from 0 below 2
- do (format pane (if (minusp (cursor-pos (aref cursors i)))
- (make-string (* -2 (cursor-pos (aref cursors i)))
- :initial-element #\?)
- (make-string (* 2 (cursor-pos (aref cursors i)))
- :initial-element #\space)))
- (format pane "~a~%" i))
+ do (format pane (if (minusp (cursor-pos (aref cursors i)))
+ (make-string (* -2 (cursor-pos (aref cursors i)))
+ :initial-element #\?)
+ (make-string (* 2 (cursor-pos (aref cursors i)))
+ :initial-element #\space)))
+ (format pane "~a~%" i))
(format pane "~%~%")
(format pane (if (minusp (slot-value chain 'flexichain::gap-start))
- (make-string (* -2 (slot-value chain 'flexichain::gap-start))
- :initial-element #\?)
- (make-string (* 2 (slot-value chain 'flexichain::gap-start))
- :initial-element #\space)))
+ (make-string (* -2 (slot-value chain 'flexichain::gap-start))
+ :initial-element #\?)
+ (make-string (* 2 (slot-value chain 'flexichain::gap-start))
+ :initial-element #\space)))
(format pane ">~%")
(format pane (if (minusp (slot-value chain 'flexichain::gap-end))
- (make-string (* -2 (slot-value chain 'flexichain::gap-end))
- :initial-element #\?)
- (make-string (* 2 (slot-value chain 'flexichain::gap-end))
- :initial-element #\space)))
+ (make-string (* -2 (slot-value chain 'flexichain::gap-end))
+ :initial-element #\?)
+ (make-string (* 2 (slot-value chain 'flexichain::gap-end))
+ :initial-element #\space)))
(format pane "<~%")
(loop for i from 0 below length
- do (format pane "~a~a"
- (if (= i (slot-value chain 'flexichain::data-start))
- #\* #\Space)
- (aref buffer i)))
+ do (format pane "~a~a"
+ (if (= i (slot-value chain 'flexichain::data-start))
+ #\* #\Space)
+ (aref buffer i)))
(format pane "~%")
(loop for i from 0 below 2
- do (format pane (make-string (1+ (* 2 (slot-value (aref cursors i)
- 'flexichain::index)))
- :initial-element #\space))
- (format pane "~a~a~%" i (at-end-p (aref cursors i))))
+ do (format pane (make-string (1+ (* 2 (slot-value (aref cursors i)
+ 'flexichain::index)))
+ :initial-element #\space))
+ (format pane "~a~a~%" i (at-end-p (aref cursors i))))
(format pane "~%~%")))
(defmethod execute-frame-command :around ((frame tester) command)
(declare (ignore command))
(handler-case (call-next-method)
(flexi-error (condition) (format (frame-standard-input *application-frame*)
- "~a~%" condition))))
+ "~a~%" condition))))
(define-tester-command (com-empty :name t) ()
(format (frame-standard-input *application-frame*)
- "~a~%" (flexi-empty-p (chain *application-frame*))))
+ "~a~%" (flexi-empty-p (chain *application-frame*))))
(defun to-char (symbol)
(char-downcase (aref (symbol-name symbol) 0)))
@@ -85,7 +85,7 @@
(define-tester-command (com-element* :name t) ((pos 'integer))
(format (frame-standard-input *application-frame*)
- "~a~%" (element* (chain *application-frame*) pos)))
+ "~a~%" (element* (chain *application-frame*) pos)))
(define-tester-command (com-set-element* :name t) ((pos 'integer) (object 'symbol))
(setf (element* (chain *application-frame*) pos) (to-char object)))
@@ -101,11 +101,11 @@
(define-tester-command (com-pop-start :name t) ()
(format (frame-standard-input *application-frame*)
- "~a~%" (pop-start (chain *application-frame*))))
+ "~a~%" (pop-start (chain *application-frame*))))
(define-tester-command (com-pop-end :name t) ()
(format (frame-standard-input *application-frame*)
- "~a~%" (pop-end (chain *application-frame*))))
+ "~a~%" (pop-end (chain *application-frame*))))
(define-tester-command (com-rotate :name t) ((amount 'integer))
(rotate (chain *application-frame*) amount))
@@ -128,11 +128,11 @@
(define-tester-command (com-clear :name t) ()
(with-slots (chain cursors) *application-frame*
(setf chain (make-instance 'standard-cursorchain
- :element-type 'character :fill-element #\_))
+ :element-type 'character :fill-element #\_))
(setf (aref cursors 0)
- (make-instance 'left-sticky-flexicursor :chain chain))
+ (make-instance 'left-sticky-flexicursor :chain chain))
(setf (aref cursors 1)
- (make-instance 'right-sticky-flexicursor :chain chain))))
+ (make-instance 'right-sticky-flexicursor :chain chain))))
(define-tester-command (com-quit :name t) ()
(frame-exit *application-frame*))
