Index: /branches/ide-1.0/ccl/hemlock/src/cursor.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/cursor.lisp	(revision 6570)
+++ /branches/ide-1.0/ccl/hemlock/src/cursor.lisp	(revision 6571)
@@ -145,13 +145,14 @@
 ;;;
 (defun cached-real-line-length (line width start end)
-  (declare (fixnum width start end) (ignore line))
-  (let ((offset (- *right-open-pos* *left-open-pos*))
+  (declare (fixnum width start end))
+  (let* ((buffer (line-%buffer line))
+         (offset (- (buffer-right-open-pos buffer) (buffer-left-open-pos buffer)))
 	(bound 0))
     (declare (fixnum offset bound))
     (cond
-     ((>= start *left-open-pos*)
+     ((>= start (buffer-left-open-pos buffer))
       (setq start (+ start offset)  bound (setq end (+ end offset))))
-     ((> end *left-open-pos*)
-      (setq bound *left-open-pos*  end (+ end offset)))
+     ((> end (buffer-left-open-pos buffer))
+      (setq bound (buffer-left-open-pos buffer)  end (+ end offset)))
      (t
       (setq bound end)))
@@ -166,6 +167,6 @@
       (when (= start bound)
 	(when (= start end) (return (values xpos ypos)))
-	(setq start *right-open-pos*  bound end))
-      (setq losing (%fcwa *open-chars* start bound losing-char))
+	(setq start (buffer-right-open-pos buffer)  bound end))
+      (setq losing (%fcwa (buffer-open-chars buffer) start bound losing-char))
       (cond
        (losing
@@ -173,8 +174,8 @@
 	  (truncate (+ xpos (- losing start)) width))
 	(setq ypos (+ ypos dy)  start losing)
-	(do ((last (or (%fcwa *open-chars* start bound winning-char) bound)) str)
+	(do ((last (or (%fcwa (buffer-open-chars buffer) start bound winning-char) bound)) str)
 	    ((= start last))
 	  (declare (fixnum last))
-	  (setq str (get-rep (schar *open-chars* start)))
+	  (setq str (get-rep (schar (buffer-open-chars buffer) start)))
 	  (incf start)
 	  (unless (simple-string-p str) (setq str (funcall str xpos)))
@@ -296,9 +297,10 @@
   an infinitely wide screen.  This takes into account tabs and control
   characters."
-  (let ((charpos (mark-charpos mark))
-	(line (mark-line mark)))
-    (if (eq line *open-line*)
-	(values (cached-real-line-length line 10000 0 charpos))
-	(values (real-line-length line 10000 0 charpos)))))
+  (let* ((charpos (mark-charpos mark))
+         (line (mark-line mark))
+         (buffer (line-%buffer line)))
+    (if (eq line (buffer-open-line buffer))
+      (values (cached-real-line-length line 10000 0 charpos))
+      (values (real-line-length line 10000 0 charpos)))))
 
 
@@ -310,5 +312,6 @@
 ;;;
 (defun find-position (line position start end width)
-  (do* ((cached (eq line *open-line*))
+  (do* ((buffer (line-%buffer line))
+        (cached (eq line (buffer-open-line buffer)))
 	(lo start)
 	(hi (1- end))
Index: /branches/ide-1.0/ccl/hemlock/src/files.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/files.lisp	(revision 6570)
+++ /branches/ide-1.0/ccl/hemlock/src/files.lisp	(revision 6571)
@@ -62,5 +62,5 @@
 			  :element-type 'base-char
 			  :if-exists if-exists-action)
-      (close-line)
+      (close-line (line-%buffer (mark-line (region-start region))))
       (fast-write-file region file))
     ;; ### access is always ignored
Index: /branches/ide-1.0/ccl/hemlock/src/htext1.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/htext1.lisp	(revision 6570)
+++ /branches/ide-1.0/ccl/hemlock/src/htext1.lisp	(revision 6571)
@@ -50,55 +50,31 @@
 
 
-#+no
-(defvar *line-cache-length* 200
-  "Length of Open-Chars.")
-
-
-
-#+no
-(defvar *open-line* ()
-  "Line open for hacking on.")
-
-
-
-#+no
-(defvar *open-chars*  (make-string *line-cache-length*)
-  "Vector of characters for hacking on.")
-
-
-
-#+no
-(defvar *left-open-pos* 0
-  "Index to first free character to left of mark in *Open-Chars*.")
-
-
-
-#+no
-(defvar *right-open-pos* 0
-  "Index to first used character to right of mark in *Open-Chars*.")
-
-(defun grow-open-chars (&optional (new-length (* *line-cache-length* 2)))
+
+(defun grow-open-chars (buffer &optional (new-length (* (buffer-line-cache-length buffer) 2)))
   "Grows *Open-Chars* to twice its current length, or the New-Length if
   specified."
   (let ((new-chars (make-string new-length))
-	(new-right (- new-length (- *line-cache-length* *right-open-pos*))))
-    (%sp-byte-blt *open-chars* 0 new-chars 0 *left-open-pos*)
-    (%sp-byte-blt *open-chars* *right-open-pos* new-chars new-right new-length)
-    (setf *right-open-pos* new-right)
-    (setf *open-chars* new-chars)
-    (setf *line-cache-length* new-length)))
-
-
-(defun close-line ()
+	(new-right (- new-length (- (buffer-line-cache-length buffer)
+                                    (buffer-right-open-pos buffer)))))
+    (%sp-byte-blt (buffer-open-chars buffer) 0 new-chars 0 (buffer-left-open-pos buffer))
+    (%sp-byte-blt (buffer-open-chars buffer) (buffer-right-open-pos buffer) new-chars new-right new-length)
+    (setf (buffer-right-open-pos buffer) new-right)
+    (setf (buffer-open-chars buffer) new-chars)
+    (setf (buffer-line-cache-length buffer) new-length)))
+
+
+(defun close-line (buffer)
   "Stuffs the characters in the currently open line back into the line they
-  came from, and sets *open-line* to Nil."
-  (when *open-line*
+  came from, and sets (buffer-open-line buffer) to Nil."
+  (when (buffer-open-line buffer)
     (hemlock-ext:without-interrupts
-      (let* ((length (+ *left-open-pos* (- *line-cache-length* *right-open-pos*)))
+      (let* ((length (+ (buffer-left-open-pos buffer)
+                        (- (buffer-line-cache-length buffer)
+                           (buffer-right-open-pos buffer))))
 	     (string (make-string length)))
-	(%sp-byte-blt *open-chars* 0 string 0 *left-open-pos*)
-	(%sp-byte-blt *open-chars* *right-open-pos*  string *left-open-pos* length)
-	(setf (line-chars *open-line*) string)
-	(setf *open-line* nil)))))
+	(%sp-byte-blt (buffer-open-chars buffer) 0 string 0 (buffer-left-open-pos buffer))
+	(%sp-byte-blt (buffer-open-chars buffer) (buffer-right-open-pos buffer)  string (buffer-left-open-pos buffer) length)
+	(setf (line-chars (buffer-open-line buffer)) string)
+	(setf (buffer-open-line buffer) nil)))))
 
 ;;; We stick decrementing fixnums in the line-chars slot of the open line
@@ -113,46 +89,49 @@
   "Closes the current *Open-Line* and opens the given Line at the Mark.
   Don't call this, use modifying-line instead."
-  (cond ((eq line *open-line*)
+  (let* ((buffer (line-%buffer line)))
+    (cond ((eq line (buffer-open-line buffer))
 	   (let ((charpos (mark-charpos mark)))
-	     (cond ((< charpos *left-open-pos*) ; BLT 'em right!
-		    (let ((right-start (- *right-open-pos*
-					  (- *left-open-pos* charpos))))
-		      (%sp-byte-blt *open-chars*
+	     (cond ((< charpos (buffer-left-open-pos buffer)) ; BLT 'em right!
+		    (let ((right-start (- (buffer-right-open-pos buffer)
+					  (- (buffer-left-open-pos buffer)
+                                             charpos))))
+		      (%sp-byte-blt (buffer-open-chars buffer)
 				    charpos
-				    *open-chars*
+				    (buffer-open-chars buffer)
 				    right-start
-				    *right-open-pos*)
-		      (setf *left-open-pos* charpos)
-		      (setf *right-open-pos* right-start)))
-		   ((> charpos *left-open-pos*) ; BLT 'em left!
-		    (%sp-byte-blt *open-chars*
-				  *right-open-pos*
-				  *open-chars*
-				  *left-open-pos*
+				    (buffer-right-open-pos buffer))
+		      (setf (buffer-left-open-pos buffer) charpos)
+		      (setf (buffer-right-open-pos buffer) right-start)))
+		   ((> charpos (buffer-left-open-pos buffer)) ; BLT 'em left!
+		    (%sp-byte-blt (buffer-open-chars buffer)
+				  (buffer-right-open-pos buffer)
+				  (buffer-open-chars buffer)
+				  (buffer-left-open-pos buffer)
 				  charpos)
-		    (setf *right-open-pos*
-			  (+ *right-open-pos*
-			     (- charpos *left-open-pos*)))
-		    (setf *left-open-pos* charpos)))))
+		    (setf (buffer-right-open-pos buffer)
+			  (+ (buffer-right-open-pos buffer)
+			     (- charpos (buffer-left-open-pos buffer))))
+		    (setf (buffer-left-open-pos buffer) charpos)))))
 
 	  (t
-	   (close-line)
+	   (close-line buffer)
 	   (let* ((chars (line-chars line))
 		  (len (length chars)))
 	     (declare (simple-string chars))
-	     (when (> len *line-cache-length*)
-	       (setf *line-cache-length* (* len 2))
-	       (setf *open-chars* (make-string *line-cache-length*)))
-	     (setf *open-line* line)
-	     (setf *left-open-pos* (mark-charpos mark))
-	     (setf *right-open-pos*
-		   (- *line-cache-length*
-		      (- (length chars) *left-open-pos*)))
-	     (%sp-byte-blt chars 0 *open-chars* 0
-			   *left-open-pos*)
-	     (%sp-byte-blt chars *left-open-pos*
-			   *open-chars*
-			   *right-open-pos*
-			   *line-cache-length*)))))
+	     (when (> len (buffer-line-cache-length buffer))
+	       (setf (buffer-line-cache-length buffer) (* len 2))
+	       (setf (buffer-open-chars buffer)
+                     (make-string (buffer-line-cache-length buffer))))
+	     (setf (buffer-open-line buffer) line)
+	     (setf (buffer-left-open-pos buffer) (mark-charpos mark))
+	     (setf (buffer-right-open-pos buffer)
+		   (- (buffer-line-cache-length buffer)
+		      (- (length chars) (buffer-left-open-pos buffer))))
+	     (%sp-byte-blt chars 0 (buffer-open-chars buffer) 0
+			   (buffer-left-open-pos buffer))
+	     (%sp-byte-blt chars (buffer-left-open-pos buffer)
+			   (buffer-open-chars buffer)
+			   (buffer-right-open-pos buffer)
+			   (buffer-line-cache-length buffer)))))))
 
 
@@ -162,10 +141,12 @@
 (defmacro modifying-line (line mark)
   "Checks to see if the Line is already opened at the Mark, and calls Open-Line
-  if not.  Sticks a tick in the *open-line*'s chars.  This must be called within
+  if not.  Sticks a tick in the (buffer-open-line buffer)'s chars.  This must be called within
   the body of a Modifying-Buffer form."
-  `(progn
-    (unless (and (= (mark-charpos ,mark) *left-open-pos*) (eq ,line *open-line*))
+  (let* ((buffer (gensym)))
+  `(let* ((,buffer (line-%buffer ,line)))
+    (unless (and (= (mark-charpos ,mark) (buffer-left-open-pos ,buffer))
+                 (eq ,line (buffer-open-line ,buffer)))
       (open-line ,line ,mark))
-    (setf (line-chars *open-line*) (decf *cache-modification-tick*))))
+    (setf (line-chars (buffer-open-line ,buffer)) (decf *cache-modification-tick*)))))
 
 ;;; Now-Tick tells us when now is and isn't.
@@ -360,7 +341,8 @@
   "Returns the characters in the line as a string.  The resulting string
   must not be destructively modified.  This may be set with Setf."
-  (if (eq line *open-line*)
-    (close-line))
-  (line-chars line))
+  (let* ((buffer (line-%buffer line)))
+    (if (eq line (buffer-open-line buffer))
+      (close-line buffer))
+    (line-chars line)))
 
 (defun %set-line-string (line string)
@@ -369,5 +351,6 @@
       (unless (simple-string-p string) 
 	(setq string (coerce string 'simple-string)))
-      (when (eq line *open-line*) (setq *open-line* nil))
+      (when (eq line (buffer-open-line buffer))
+        (setf (buffer-open-line buffer) nil))
       (let ((length (length (the simple-string string))))
 	(dolist (m (line-marks line))
@@ -380,16 +363,18 @@
   "Return the Index'th character in Line.  If the index is the length of the
   line then #\newline is returned."
-  (if (eq line *open-line*)
-      (if (< index *left-open-pos*)
-	  (schar *open-chars* index)
-	  (let ((index (+ index (- *right-open-pos* *left-open-pos*))))
-	    (if (= index *line-cache-length*)
-		#\newline
-		(schar *open-chars* index))))
+  (let* ((buffer (line-%buffer line)))
+    (if (eq line (buffer-open-line buffer))
+      (if (< index (buffer-left-open-pos buffer))
+        (schar (buffer-open-chars buffer) index)
+        (let ((index (+ index (- (buffer-right-open-pos buffer)
+                                 (buffer-left-open-pos buffer)))))
+          (if (= index (buffer-line-cache-length buffer))
+            #\newline
+            (schar (buffer-open-chars buffer) index))))
       (let ((chars (line-chars line)))
 	(declare (simple-string chars))
 	(if (= index (length chars))
-	    #\newline
-	    (schar chars index)))))
+          #\newline
+          (schar chars index))))))
 
 
@@ -561,7 +546,10 @@
   "Returns T if the line pointer to by Mark contains no characters, Nil 
   or otherwise."
-  (let ((line (mark-line mark)))
-    (if (eq line *open-line*)
-	(and (= *left-open-pos* 0) (= *right-open-pos* *line-cache-length*))
+  (let* ((line (mark-line mark))
+         (buffer (line-%buffer line)))
+    (if (eq line (buffer-open-line buffer))
+	(and (= (buffer-left-open-pos buffer) 0)
+             (= (buffer-right-open-pos buffer)
+                (buffer-line-cache-length buffer)))
 	(= (length (line-chars line)) 0))))
 
@@ -578,15 +566,17 @@
 ;;;
 (defun blank-between-positions (line start end)
-  (if (eq line *open-line*)
-      (let ((gap (- *right-open-pos* *left-open-pos*)))
-	(cond ((>= start *left-open-pos*)
-	       (check-range *open-chars* (+ start gap) (+ end gap)))
-	      ((<= end *left-open-pos*)
-	       (check-range *open-chars* start end))
-	      (t
-	       (and (check-range *open-chars* start *left-open-pos*)
-		    (check-range *open-chars* *right-open-pos* (+ end gap))))))
+  (let* ((buffer (line-%buffer line)))
+    (if (eq line (buffer-open-line buffer))
+      (let ((gap (- (buffer-right-open-pos buffer)
+                    (buffer-left-open-pos buffer))))
+        (cond ((>= start (buffer-left-open-pos buffer))
+               (check-range (buffer-open-chars buffer) (+ start gap) (+ end gap)))
+              ((<= end (buffer-left-open-pos buffer))
+               (check-range (buffer-open-chars buffer) start end))
+              (t
+               (and (check-range (buffer-open-chars buffer) start (buffer-left-open-pos buffer))
+                    (check-range (buffer-open-chars buffer) (buffer-right-open-pos buffer) (+ end gap))))))
       (let ((chars (line-chars line)))
-	(check-range chars start end))))
+        (check-range chars start end)))))
 
 (defun blank-line-p (line)
Index: /branches/ide-1.0/ccl/hemlock/src/htext2.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/htext2.lisp	(revision 6570)
+++ /branches/ide-1.0/ccl/hemlock/src/htext2.lisp	(revision 6571)
@@ -26,5 +26,5 @@
 (defun region-to-string (region)
   "Returns a string containing the characters in the given Region."
-  (close-line)
+  (close-line (line-%buffer (mark-line (region-start region))))
   (let* ((dst-length (count-characters region))
 	 (string (make-string dst-length))
@@ -99,36 +99,42 @@
 (defun previous-character (mark)
   "Returns the character immediately before the given Mark."
-  (let ((line (mark-line mark))
-	(charpos (mark-charpos mark)))
+  (let* ((line (mark-line mark))
+         (buffer (line-%buffer line))
+         (charpos (mark-charpos mark)))
     (if (= charpos 0)
-	(if (line-previous line)
-	    #\newline
-	    nil)
-	(if (eq line *open-line*)
-	    (char (the simple-string *open-chars*)
-		  (if (<= charpos *left-open-pos*)
-		      (1- charpos)
-		      (1- (+ *right-open-pos* (- charpos *left-open-pos*)))))
-	    (schar (line-chars line) (1- charpos))))))
+      (if (line-previous line)
+        #\newline
+        nil)
+      (if (eq line (buffer-open-line buffer))
+        (schar (the simple-string (buffer-open-chars buffer))
+               (if (<= charpos (buffer-left-open-pos buffer))
+                 (1- charpos)
+                 (1- (+ (buffer-right-open-pos buffer)
+                        (- charpos (buffer-left-open-pos buffer))))))
+        (schar (line-chars line) (1- charpos))))))
 
 (defun next-character (mark)
   "Returns the character immediately after the given Mark."
-  (let ((line (mark-line mark))
-	(charpos (mark-charpos mark)))
-    (if (eq line *open-line*)
-	(if (= charpos (- *line-cache-length* (- *right-open-pos* *left-open-pos*)))
-	    (if (line-next line)
-		#\newline
-		nil)
-	    (schar *open-chars*
-		   (if (< charpos *left-open-pos*)
-		       charpos
-		       (+ *right-open-pos* (- charpos *left-open-pos*)))))
-	(let ((chars (line-chars line)))
-	  (if (= charpos (strlen chars))
-	      (if (line-next line)
-		  #\newline
-		  nil)
-	      (schar chars charpos))))))
+  (let* ((line (mark-line mark))
+         (buffer (line-%buffer line))
+         (charpos (mark-charpos mark)))
+    (if (eq line (buffer-open-line buffer))
+      (if (= charpos (- (buffer-line-cache-length buffer)
+                        (- (buffer-right-open-pos buffer)
+                           (buffer-left-open-pos buffer))))
+        (if (line-next line)
+          #\newline
+          nil)
+        (schar (buffer-open-chars buffer)
+               (if (< charpos (buffer-left-open-pos buffer))
+                 charpos
+                 (+ (buffer-right-open-pos buffer)
+                    (- charpos (buffer-left-open-pos buffer))))))
+      (let ((chars (line-chars line)))
+        (if (= charpos (strlen chars))
+          (if (line-next line)
+            #\newline
+            nil)
+          (schar chars charpos))))))
 
 
@@ -148,5 +154,5 @@
       (modifying-line line mark)
       (cond ((= (mark-charpos mark)
-		(- *line-cache-length* (- *right-open-pos* *left-open-pos*)))
+		(- (buffer-line-cache-length buffer) (- (buffer-right-open-pos buffer) (buffer-left-open-pos buffer))))
 	     ;; The mark is at the end of the line.
 	     (unless next
@@ -157,13 +163,13 @@
 	       (let ((chars (line-chars next)))
 		 (declare (simple-string chars))
-		 (setq *right-open-pos* (- *line-cache-length* (length chars)))
-		 (when (<= *right-open-pos* *left-open-pos*)
-		   (grow-open-chars (* (+ (length chars) *left-open-pos* 1) 2)))
-		 (%sp-byte-blt chars 0 *open-chars* *right-open-pos* 
-			       *line-cache-length*)
-		 (setf (schar *open-chars* *left-open-pos*) character)
-		 (incf *left-open-pos*))
+		 (setf (buffer-right-open-pos buffer) (- (buffer-line-cache-length buffer) (length chars)))
+		 (when (<= (buffer-right-open-pos buffer) (buffer-left-open-pos buffer))
+		   (grow-open-chars buffer (* (+ (length chars) (buffer-left-open-pos buffer) 1) 2)))
+		 (%sp-byte-blt chars 0 (buffer-open-chars buffer) (buffer-right-open-pos buffer) 
+			       (buffer-line-cache-length buffer))
+		 (setf (schar (buffer-open-chars buffer) (buffer-left-open-pos buffer)) character)
+		 (incf (buffer-left-open-pos buffer)))
 	       (move-some-marks (charpos next line) 
-				(+ charpos *left-open-pos*))
+				(+ charpos (buffer-left-open-pos buffer)))
 	       (setq next (line-next next))
 	       (setf (line-next line) next)
@@ -171,18 +177,18 @@
 	    ((char= character #\newline)
 	     ;; The char is being changed to a newline, so we must split lines.
-	     (incf *right-open-pos*)
-	     (let* ((len (- *line-cache-length* *right-open-pos*))	   
+	     (incf (buffer-right-open-pos buffer))
+	     (let* ((len (- (buffer-line-cache-length buffer) (buffer-right-open-pos buffer)))	   
 		    (chars (make-string len))
 		    (new (make-line :chars chars  :previous line 
 				    :next next  :%buffer buffer)))
-	       (%sp-byte-blt *open-chars* *right-open-pos* chars 0 len)
-	       (maybe-move-some-marks* (charpos line new) *left-open-pos*
-				       (- charpos *left-open-pos* 1))
+	       (%sp-byte-blt (buffer-open-chars buffer) (buffer-right-open-pos buffer) chars 0 len)
+	       (maybe-move-some-marks* (charpos line new) (buffer-left-open-pos buffer)
+				       (- charpos (buffer-left-open-pos buffer) 1))
 	       (setf (line-next line) new)
 	       (when next (setf (line-previous next) new))
-	       (setq *right-open-pos* *line-cache-length*)
+	       (setf (buffer-right-open-pos buffer) (buffer-line-cache-length buffer))
 	       (number-line new)))
 	    (t
-	     (setf (char (the simple-string *open-chars*) *right-open-pos*)
+	     (setf (char (the simple-string (buffer-open-chars buffer)) (buffer-right-open-pos buffer))
 		   character)
 	     (hi::buffer-note-modification buffer mark 1)))))
@@ -380,14 +386,39 @@
 
 (defun %print-whole-line (structure stream)
-  (cond ((eq structure *open-line*)
-	 (write-string *open-chars* stream :end *left-open-pos*)
-	 (write-string *open-chars* stream :start *right-open-pos*
-		       :end *line-cache-length*))
-	(t
-	 (write-string (line-chars structure) stream))))
+  (let* ((buffer (line-%buffer structure)))
+    (cond ((eq structure (buffer-open-line buffer))
+           (write-string (buffer-open-chars buffer) stream :end (buffer-left-open-pos buffer))
+           (write-string (buffer-open-chars buffer) stream :start (buffer-right-open-pos buffer)
+                         :end (buffer-line-cache-length buffer)))
+          (t
+           (write-string (line-chars structure) stream)))))
 
 (defun %print-before-mark (mark stream)
   (if (mark-line mark)
+    (let* ((line (mark-line mark))
+           (buffer (line-%buffer line))
+           (chars (line-chars line))
+           (charpos (mark-charpos mark))
+           (length (line-length line)))
+      (declare (simple-string chars))
+      (cond ((or (> charpos length) (< charpos 0))
+             (write-string "{bad mark}" stream))
+            ((eq line (buffer-open-line buffer))
+             (cond ((< charpos (buffer-left-open-pos buffer))
+                    (write-string (buffer-open-chars buffer) stream :end charpos))
+                   (t
+                    (write-string (buffer-open-chars buffer) stream :end (buffer-left-open-pos buffer))
+                    (let ((p (+ charpos (- (buffer-right-open-pos buffer) (buffer-left-open-pos buffer)))))
+                      (write-string (buffer-open-chars buffer) stream  :start (buffer-right-open-pos buffer)
+                                    :end p)))))
+            (t
+             (write-string chars stream :end charpos))))
+    (write-string "{deleted mark}" stream)))
+
+
+(defun %print-after-mark (mark stream)
+  (if (mark-line mark)
       (let* ((line (mark-line mark))
+             (buffer (line-%buffer line))
 	     (chars (line-chars line))
 	     (charpos (mark-charpos mark))
@@ -396,36 +427,14 @@
 	(cond ((or (> charpos length) (< charpos 0))
 	       (write-string "{bad mark}" stream))
-	      ((eq line *open-line*)
-	       (cond ((< charpos *left-open-pos*)
-		      (write-string *open-chars* stream :end charpos))
+	      ((eq line (buffer-open-line buffer))
+	       (cond ((< charpos (buffer-left-open-pos buffer))
+		      (write-string (buffer-open-chars buffer) stream  :start charpos
+				    :end (buffer-left-open-pos buffer))
+		      (write-string (buffer-open-chars buffer) stream  :start (buffer-right-open-pos buffer)
+				    :end (buffer-line-cache-length buffer)))
 		     (t
-		      (write-string *open-chars* stream :end *left-open-pos*)
-		      (let ((p (+ charpos (- *right-open-pos* *left-open-pos*))))
-			(write-string *open-chars* stream  :start *right-open-pos*
-				      :end p)))))
-	      (t
-	       (write-string chars stream :end charpos))))
-      (write-string "{deleted mark}" stream)))
-
-
-(defun %print-after-mark (mark stream)
-  (if (mark-line mark)
-      (let* ((line (mark-line mark))
-	     (chars (line-chars line))
-	     (charpos (mark-charpos mark))
-	     (length (line-length line)))
-	(declare (simple-string chars))
-	(cond ((or (> charpos length) (< charpos 0))
-	       (write-string "{bad mark}" stream))
-	      ((eq line *open-line*)
-	       (cond ((< charpos *left-open-pos*)
-		      (write-string *open-chars* stream  :start charpos
-				    :end *left-open-pos*)
-		      (write-string *open-chars* stream  :start *right-open-pos*
-				    :end *line-cache-length*))
-		     (t
-		      (let ((p (+ charpos (- *right-open-pos* *left-open-pos*))))
-			(write-string *open-chars* stream :start p
-				      :end *line-cache-length*)))))
+		      (let ((p (+ charpos (- (buffer-right-open-pos buffer) (buffer-left-open-pos buffer)))))
+			(write-string (buffer-open-chars buffer) stream :start p
+				      :end (buffer-line-cache-length buffer))))))
 	      (t
 	       (write-string chars stream  :start charpos  :end length))))
@@ -455,4 +464,5 @@
 	 (end (region-end region))
 	 (first-line (mark-line start))
+         (buffer (line-%buffer first-line))
 	 (last-line (mark-line end)))
     (cond
@@ -469,16 +479,16 @@
 		((or (< cs 0) (> ce len))
 		 (write-string "{bad region}" stream))
-		((eq first-line *open-line*)
-		 (let ((gap (- *right-open-pos* *left-open-pos*)))
+		((eq first-line (buffer-open-line buffer))
+		 (let ((gap (- (buffer-right-open-pos buffer) (buffer-left-open-pos buffer))))
 		   (cond
-		    ((<= ce *left-open-pos*)
-		     (write-string *open-chars* stream  :start cs  :end ce))
-		    ((>= cs *left-open-pos*)
-		     (write-string *open-chars* stream  :start (+ cs gap)
+		    ((<= ce (buffer-left-open-pos buffer))
+		     (write-string (buffer-open-chars buffer) stream  :start cs  :end ce))
+		    ((>= cs (buffer-left-open-pos buffer))
+		     (write-string (buffer-open-chars buffer) stream  :start (+ cs gap)
 				   :end (+ ce gap)))
 		    (t
-		     (write-string *open-chars* stream :start cs
-				   :end *left-open-pos*)
-		     (write-string *open-chars* stream :start *right-open-pos*
+		     (write-string (buffer-open-chars buffer) stream :start cs
+				   :end (buffer-left-open-pos buffer))
+		     (write-string (buffer-open-chars buffer) stream :start (buffer-right-open-pos buffer)
 				   :end (+ gap ce))))))
 		(t
Index: /branches/ide-1.0/ccl/hemlock/src/htext3.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/htext3.lisp	(revision 6570)
+++ /branches/ide-1.0/ccl/hemlock/src/htext3.lisp	(revision 6571)
@@ -47,33 +47,35 @@
 		      (cond ((char= character #\newline)
 			     (let* ((next (line-next line))
-				    (new-chars (subseq (the simple-string *open-chars*)
-						       0 *left-open-pos*))
+				    (new-chars (subseq (the simple-string (buffer-open-chars buffer))
+						       0 (buffer-left-open-pos buffer)))
 				    (new-line (make-line :%buffer buffer
 							 :chars (decf *cache-modification-tick*)
 							 :previous line
 							 :next next)))
-			       (maybe-move-some-marks (charpos line new-line) *left-open-pos*
-						      (- charpos *left-open-pos*))
+			       (maybe-move-some-marks (charpos line new-line) (buffer-left-open-pos buffer)
+						      (- charpos (buffer-left-open-pos buffer)))
 			       (setf (line-%chars line) new-chars)
 			       (setf (line-next line) new-line)
 			       (if next (setf (line-previous next) new-line))
 			       (number-line new-line)
-			       (setq *open-line* new-line  *left-open-pos* 0)))
+			       (setf (buffer-open-line buffer) new-line
+                                     (buffer-left-open-pos buffer) 0)))
 			    (t
-			     (if (= *right-open-pos* *left-open-pos*)
-			       (grow-open-chars))
+			     (if (= (buffer-right-open-pos buffer)
+                                    (buffer-left-open-pos buffer))
+			       (grow-open-chars buffer))
 	     
-			     (maybe-move-some-marks (charpos line) *left-open-pos*
+			     (maybe-move-some-marks (charpos line) (buffer-left-open-pos buffer)
 						    (1+ charpos))
 	     
 			     (cond
 			       ((eq (mark-%kind mark) :right-inserting)
-				(decf *right-open-pos*)
-				(setf (char (the simple-string *open-chars*) *right-open-pos*)
+				(decf (buffer-right-open-pos buffer))
+				(setf (char (the simple-string (buffer-open-chars buffer)) (buffer-right-open-pos buffer))
 				      character))
 			       (t
-				(setf (char (the simple-string *open-chars*) *left-open-pos*)
+				(setf (char (the simple-string (buffer-open-chars buffer)) (buffer-left-open-pos buffer))
 				      character)
-				(incf *left-open-pos*)))))
+				(incf (buffer-left-open-pos buffer))))))
 		      (buffer-note-insertion buffer mark 1))))
 
@@ -107,18 +109,18 @@
 	 (modifying-line line mark)
 	 (let ((length (- end start)))
-	   (if (<= *right-open-pos* (+ *left-open-pos* end))
-	     (grow-open-chars (* (+ *line-cache-length* end) 2)))
+	   (if (<= (buffer-right-open-pos buffer) (+ (buffer-left-open-pos buffer) end))
+	     (grow-open-chars buffer (* (+ (buffer-line-cache-length buffer) end) 2)))
 	      
-	   (maybe-move-some-marks (charpos line) *left-open-pos*
+	   (maybe-move-some-marks (charpos line) (buffer-left-open-pos buffer)
 				  (+ charpos length))
 	   (cond
 	     ((eq (mark-%kind mark) :right-inserting)
-	      (let ((new (- *right-open-pos* length)))
-		(%sp-byte-blt string start *open-chars* new *right-open-pos*)
-		(setq *right-open-pos* new)))
+	      (let ((new (- (buffer-right-open-pos buffer) length)))
+		(%sp-byte-blt string start (buffer-open-chars buffer) new (buffer-right-open-pos buffer))
+		(setf (buffer-right-open-pos buffer) new)))
 	     (t
-	      (let ((new (+ *left-open-pos* length)))
-		(%sp-byte-blt string start *open-chars* *left-open-pos* new)
-		(setq *left-open-pos* new)))))
+	      (let ((new (+ (buffer-left-open-pos buffer) length)))
+		(%sp-byte-blt string start (buffer-open-chars buffer) (buffer-left-open-pos buffer) new)
+		(setf (buffer-left-open-pos buffer) new)))))
 	 (buffer-note-insertion buffer mark (- end start)))))))
 
@@ -133,4 +135,5 @@
 	 (end (region-end region))
 	 (first-line (mark-line start))
+         (buffer (line-%buffer first-line))
 	 (last-line (mark-line end))
 	 (first-charpos (mark-charpos start))
@@ -140,12 +143,12 @@
      ((eq first-line last-line)
       ;; simple case -- just BLT the characters in with insert-string
-      (if (eq first-line *open-line*) (close-line))
+      (if (eq first-line (buffer-open-line buffer))
+        (close-line buffer))
       (insert-string mark (line-chars first-line) first-charpos last-charpos))
      (t
-      (close-line)
+      (close-line buffer)
       (let* ((line (mark-line mark))
 	     (next (line-next line))
 	     (charpos (mark-charpos mark))
-	     (buffer (line-%buffer line))
 	     (old-chars (line-chars line)))
 	(declare (simple-string old-chars))
@@ -205,19 +208,20 @@
 	 (first-charpos (mark-charpos start))
 	 (last-charpos (mark-charpos end))
-         (nins (count-characters region)))
+         (nins (count-characters region))
+         (buffer (line-%buffer (mark-line mark))))
     (cond
      ((eq first-line last-line)
       ;; Simple case -- just BLT the characters in with insert-string.
-      (if (eq first-line *open-line*) (close-line))
+      (if (eq first-line (buffer-open-line buffer))
+        (close-line buffer))
       (insert-string mark (line-chars first-line) first-charpos last-charpos))
      (t
       (when (bufferp (line-%buffer first-line))
 	(error "Region is linked into Buffer ~S." (line-%buffer first-line)))
-      (close-line)
+      (close-line buffer)
       (let* ((line (mark-line mark))
 	     (second-line (line-next first-line))
 	     (next (line-next line))
 	     (charpos (mark-charpos mark))
-	     (buffer (line-%buffer line))
 	     (old-chars (line-chars line)))
 	(declare (simple-string old-chars))
Index: /branches/ide-1.0/ccl/hemlock/src/htext4.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/htext4.lisp	(revision 6570)
+++ /branches/ide-1.0/ccl/hemlock/src/htext4.lisp	(revision 6571)
@@ -44,16 +44,16 @@
                          (cond
                            ((minusp n)
-                            (setq *left-open-pos* (+ *left-open-pos* n))
+                            (incf (buffer-left-open-pos buffer) n)
                             (move-some-marks (pos line)
-                                             (if (> pos *left-open-pos*)
-                                               (if (<= pos charpos) *left-open-pos* (+ pos n))
+                                             (if (> pos (buffer-left-open-pos buffer))
+                                               (if (<= pos charpos) (buffer-left-open-pos buffer) (+ pos n))
                                                pos)))
 	 
                            (t
-                            (setq *right-open-pos* (+ *right-open-pos* n))
+                            (incf (buffer-right-open-pos buffer) n)
                             (let ((bound (+ charpos n)))
                               (move-some-marks (pos line)
                                                (if (> pos charpos)
-                                                 (if (<= pos bound) *left-open-pos* (- pos n))
+                                                 (if (<= pos bound) (buffer-left-open-pos buffer) (- pos n))
                                                  pos)))))
                          (buffer-note-deletion buffer mark n)
@@ -99,5 +99,5 @@
 	       (modifying-line first-line start)
 	       (let ((num (- last-charpos first-charpos)))
-		 (setq *right-open-pos* (+ *right-open-pos* num))
+		 (incf (buffer-right-open-pos buffer) num)
 		 ;; and fix up any marks in there:
 		 (move-some-marks (charpos first-line)
@@ -109,5 +109,5 @@
 	      (t
 	       ;; hairy case -- squish lines together:
-	       (close-line)
+	       (close-line buffer)
 	       (let* ((first-chars (line-chars first-line))
 		      (last-chars (line-chars last-line))
@@ -177,5 +177,5 @@
                    (modifying-line first-line start)
                    (let* ((num (- last-charpos first-charpos))
-                          (new-right (+ *right-open-pos* num))
+                          (new-right (+ (buffer-right-open-pos buffer) num))
                           (new-chars (make-string num))
                           (new-line (make-line
@@ -183,6 +183,6 @@
                                      :%buffer (incf *disembodied-buffer-counter*))))
                      (declare (simple-string new-chars))
-                     (%sp-byte-blt *open-chars* *right-open-pos* new-chars 0 num) 
-                     (setq *right-open-pos* new-right)
+                     (%sp-byte-blt (buffer-open-chars buffer) (buffer-right-open-pos buffer) new-chars 0 num) 
+                     (setf (buffer-right-open-pos buffer) new-right)
                      ;; and fix up any marks in there:
                      (move-some-marks (charpos first-line)
@@ -197,5 +197,5 @@
                   (t
                    ;; hairy case -- squish lines together:
-                   (close-line)
+                   (close-line buffer)
                    (let* ((first-chars (line-chars first-line))
                           (last-chars (line-chars last-line))
@@ -271,4 +271,5 @@
 	 (end (region-end region))
 	 (first-line (mark-line start))
+         (buffer (line-%buffer first-line))
 	 (last-line (mark-line end))
 	 (first-charpos (mark-charpos start))
@@ -277,5 +278,5 @@
     (cond
      ((eq first-line last-line)
-      (when (eq first-line *open-line*) (close-line))
+      (when (eq first-line (buffer-open-line buffer)) (close-line buffer))
       (let* ((length (- last-charpos first-charpos))
 	     (chars (make-string length))
@@ -285,5 +286,5 @@
 			      (mark line length :left-inserting))))
      (t
-      (close-line)
+      (close-line buffer)
       (let* ((first-chars (line-chars first-line))
 	     (length (- (length first-chars) first-charpos))
@@ -352,12 +353,13 @@
       (modifying-line end-line end)
       (cond ((eq start-line end-line)
-	     (let* ((res (fcs function (subseq *open-chars* first last)))
+	     (let* ((res (fcs function (subseq (buffer-open-chars buffer)
+                                               first last)))
 		    (rlen (length res))
 		    (new-left (+ first rlen))
-		    (delta (- new-left *left-open-pos*)))
+		    (delta (- new-left (buffer-left-open-pos buffer))))
 	       (declare (simple-string res))
-	       (when (> new-left *right-open-pos*)
-		 (grow-open-chars (+ new-left *line-cache-length*)))
-	       (%sp-byte-blt res 0 *open-chars* first *left-open-pos*)
+	       (when (> new-left (buffer-right-open-pos buffer))
+		 (grow-open-chars buffer (+ new-left (buffer-line-cache-length buffer))))
+	       (%sp-byte-blt res 0 (buffer-open-chars buffer) first (buffer-left-open-pos buffer))
 	       ;;
 	       ;; Move marks to start or end of region, depending on kind.
@@ -370,5 +372,5 @@
 				   new-left first)
 			       (+ charpos delta))))))
-	       (setq *left-open-pos* new-left)))
+	       (setf (buffer-left-open-pos buffer) new-left)))
 	    (t
 	     ;;
@@ -403,13 +405,13 @@
 	     ;;
 	     ;; Do the last line, which is cached.
-	     (let* ((res (fcs function (subseq (the simple-string *open-chars*)
+	     (let* ((res (fcs function (subseq (the simple-string (buffer-open-chars buffer))
 					       0 last)))
 		    (rlen (length res))
 		    (delta (- rlen last)))
 	       (declare (simple-string res))
-	       (when (> rlen *right-open-pos*)
-		 (grow-open-chars (+ rlen *line-cache-length*)))
-	       (%sp-byte-blt res 0 *open-chars* 0 rlen)
-	       (setq *left-open-pos* rlen)
+	       (when (> rlen (buffer-right-open-pos buffer))
+		 (grow-open-chars buffer (+ rlen (buffer-line-cache-length buffer))))
+	       (%sp-byte-blt res 0 (buffer-open-chars buffer) 0 rlen)
+	       (setf (buffer-left-open-pos buffer) rlen)
 	       ;;
 	       ;; Adjust marks after the end of the region and save ones in it.
Index: /branches/ide-1.0/ccl/hemlock/src/line.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/line.lisp	(revision 6570)
+++ /branches/ide-1.0/ccl/hemlock/src/line.lisp	(revision 6571)
@@ -140,7 +140,9 @@
 (defmacro line-length* (line)
   "Returns the number of characters on the line, but it's a macro!"
-  `(cond ((eq ,line *open-line*)
-	  (+ *left-open-pos* (- *line-cache-length* *right-open-pos*)))
-	 ((line-buffered-p ,line))
-	 (t
-	  (length (the simple-string (line-%chars ,line))))))
+  (let* ((buffer (gensym)))
+    `(let* ((,buffer (line-%buffer ,line)))
+      (cond ((eq ,line (buffer-open-line ,buffer))
+             (+ (buffer-left-open-pos ,buffer) (- (buffer-line-cache-length ,buffer) (buffer-right-open-pos ,buffer))))
+            ((line-buffered-p ,line))
+            (t
+             (length (the simple-string (line-%chars ,line))))))))
Index: /branches/ide-1.0/ccl/hemlock/src/search1.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/search1.lisp	(revision 6570)
+++ /branches/ide-1.0/ccl/hemlock/src/search1.lisp	(revision 6571)
@@ -634,5 +634,5 @@
   If there is no match for the pattern then Mark is not modified and NIL
   is returned."
-  (close-line)
+  (close-line (line-%buffer (mark-line mark)))
   (multiple-value-bind (line start matched)
 		       (funcall (search-pattern-search-function search-pattern)
@@ -650,19 +650,20 @@
   in the text starting at the given Mark.  If N is Nil, all occurrences 
   following the Mark are replaced."
-  (close-line)
-  (do* ((replacement (coerce replacement 'simple-string))
-	(new (length (the simple-string replacement)))
-	(fun (search-pattern-search-function search-pattern))
-	(forward-p (eq (search-pattern-direction search-pattern) :forward))
-	(n (if n (1- n) -1) (1- n))
-	(m (copy-mark mark :temporary)) line start matched)
-       (())
-    (multiple-value-setq (line start matched)
-      (funcall fun search-pattern (mark-line m) (mark-charpos m)))
-    (unless matched (return m))
-    (setf (mark-line m) line  (mark-charpos m) start)
-    (delete-characters m matched)
-    (insert-string m replacement)
-    (when forward-p (character-offset m new))
-    (when (zerop n) (return m))
-    (close-line)))
+  (let* ((buffer (line-%buffer (mark-line mark))))
+    (close-line buffer)
+    (do* ((replacement (coerce replacement 'simple-string))
+          (new (length (the simple-string replacement)))
+          (fun (search-pattern-search-function search-pattern))
+          (forward-p (eq (search-pattern-direction search-pattern) :forward))
+          (n (if n (1- n) -1) (1- n))
+          (m (copy-mark mark :temporary)) line start matched)
+         (())
+      (multiple-value-setq (line start matched)
+        (funcall fun search-pattern (mark-line m) (mark-charpos m)))
+      (unless matched (return m))
+      (setf (mark-line m) line  (mark-charpos m) start)
+      (delete-characters m matched)
+      (insert-string m replacement)
+      (when forward-p (character-offset m new))
+      (when (zerop n) (return m))
+      (close-line buffer))))
Index: /branches/ide-1.0/ccl/hemlock/src/struct.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/struct.lisp	(revision 6570)
+++ /branches/ide-1.0/ccl/hemlock/src/struct.lisp	(revision 6571)
@@ -111,10 +111,16 @@
   (external-format :unix)     ; Line-termination, for the time being
   process		      ; Maybe a listener
-  (gap-context )	      ; The value of *buffer-gap-context*
-                              ; in the thread that can modify the buffer.
+  (line-cache-length 200)     ; Length of string used for per-buffer gap.
+  (open-chars (make-string 200)) ; String used for per-buffer cache
+  (left-open-pos 0)           ; Index of first free character to left of
+                              ; gap in open-chars.
+  (right-open-pos 0)          ; Index of first used character to right of
+                              ; gap in open-chars
+  %open-line                  ; line which open-chars represent, or nil.
   protected-region            ; (optional) write-protected region
   (font-regions (ccl::init-dll-header (ccl::make-dll-header)))
                                         ; a doubly-linked list of font regions.
   active-font-region                    ; currently active font region
+  (lock (ccl:make-lock))
   )
 
@@ -679,22 +685,16 @@
    any buffer whose fields list contains the field.")
 
-;;; Shared buffer-gap context, used to communicate between command threads
-;;; and the event thread.  Note that this isn't buffer-specific; in particular,
-;;; OPEN-LINE and friends may not point at a line that belongs to any
-;;; buffer.
-
-(defstruct buffer-gap-context
-  (lock (ccl::make-lock))
-  (left-open-pos 0)
-  (right-open-pos 0)
-  (line-cache-length 200)
-  (open-line nil)
-  (open-chars (make-string 200))
-)
-
-(define-symbol-macro *line-cache-length* (buffer-gap-context-line-cache-length *buffer-gap-context*))
-(define-symbol-macro *open-line* (buffer-gap-context-open-line *buffer-gap-context*))
-(define-symbol-macro *open-chars* (buffer-gap-context-open-chars *buffer-gap-context*))
-(define-symbol-macro *left-open-pos* (buffer-gap-context-left-open-pos *buffer-gap-context*))
-(define-symbol-macro *right-open-pos* (buffer-gap-context-right-open-pos *buffer-gap-context*))
-
+
+
+(defun buffer-open-line (buffer)
+  (if (typep buffer 'buffer)
+    (buffer-%open-line buffer)))
+
+(defun (setf buffer-open-line) (line buffer)
+  (setf (buffer-%open-line buffer) line))
+
+
+
+
+
+             
Index: /branches/ide-1.0/ccl/hemlock/src/syntax.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/syntax.lisp	(revision 6570)
+++ /branches/ide-1.0/ccl/hemlock/src/syntax.lisp	(revision 6571)
@@ -455,19 +455,20 @@
 		   chars ,start (strlen chars) ,vector ,mask))))
 ;;;
-(defmacro cache-find-attribute (start result vector mask)
-  `(let ((gap (- *right-open-pos* *left-open-pos*)))
+(defmacro cache-find-attribute (buffer start result vector mask)
+  `(let ((gap (- (buffer-right-open-pos buffer)
+                 (buffer-left-open-pos buffer))))
      (declare (fixnum gap))
      (cond
-      ((>= ,start *left-open-pos*)
+      ((>= ,start (buffer-left-open-pos buffer))
        (setq ,result
 	     (%sp-find-character-with-attribute
-	      *open-chars* (+ ,start gap) *line-cache-length* ,vector ,mask))
+	      (buffer-open-chars buffer) (+ ,start gap) (buffer-line-cache-length buffer) ,vector ,mask))
        (when ,result (decf ,result gap)))
       ((setq ,result (%sp-find-character-with-attribute
-		      *open-chars* ,start *left-open-pos* ,vector ,mask)))
+		      (buffer-open-chars buffer) ,start (buffer-left-open-pos buffer) ,vector ,mask)))
       (t
        (setq ,result
 	     (%sp-find-character-with-attribute
-	      *open-chars* *right-open-pos* *line-cache-length* ,vector ,mask))
+	      (buffer-open-chars buffer) (buffer-right-open-pos buffer) (buffer-line-cache-length buffer) ,vector ,mask))
        (when ,result (decf ,result gap))))))
 ); eval-when (:compile-toplevel :execute)
@@ -475,6 +476,7 @@
 (defun find-attribute (mark attribute &optional (test #'not-zerop))
   "Find the next character whose attribute value satisfies test."
-  (let ((charpos (mark-charpos mark))
+  (let* ((charpos (mark-charpos mark))
 	(line (mark-line mark))
+        (buffer (line-%buffer line))
 	(mask 0)
 	vector end-wins)
@@ -484,6 +486,6 @@
     (cond
      ((cond
-       ((eq line *open-line*)
-	(when (cache-find-attribute charpos charpos vector mask)
+       ((eq line (buffer-open-line buffer))
+	(when (cache-find-attribute buffer charpos charpos vector mask)
 	  (setf (mark-charpos mark) charpos) mark))
        (t
@@ -504,6 +506,6 @@
 	      (return (line-end mark prev))
 	      (return nil)))
-	 ((eq line *open-line*)
-	  (when (cache-find-attribute 0 charpos vector mask)
+	 ((eq line (buffer-open-line buffer))
+	  (when (cache-find-attribute buffer 0 charpos vector mask)
 	    (return (move-to-position mark charpos line))))
 	 (t
@@ -523,16 +525,16 @@
 		    chars 0 ,(or start '(strlen chars)) ,vector ,mask))))
 ;;;
-(defmacro rev-cache-find-attribute (start result vector mask)
-  `(let ((gap (- *right-open-pos* *left-open-pos*)))
+(defmacro rev-cache-find-attribute (buffer start result vector mask)
+  `(let ((gap (- (buffer-right-open-pos buffer) (buffer-left-open-pos buffer))))
      (declare (fixnum gap))
      (cond
       ,@(when start
-	  `(((<= ,start *left-open-pos*)
+	  `(((<= ,start (buffer-left-open-pos buffer))
 	     (setq ,result
 		   (%sp-reverse-find-character-with-attribute
-		    *open-chars* 0 ,start ,vector ,mask)))))
+		    (buffer-open-chars buffer) 0 ,start ,vector ,mask)))))
       ((setq ,result (%sp-reverse-find-character-with-attribute
-		      *open-chars* *right-open-pos*
-		      ,(if start `(+ ,start gap) '*line-cache-length*)
+		      (buffer-open-chars buffer) (buffer-right-open-pos buffer)
+		      ,(if start `(+ ,start gap) '(buffer-line-cache-length buffer))
 		      ,vector ,mask))
        (decf ,result gap))
@@ -540,5 +542,5 @@
        (setq ,result
 	     (%sp-reverse-find-character-with-attribute
-	      *open-chars* 0 *left-open-pos* ,vector ,mask))))))
+	      (buffer-open-chars buffer) 0 (buffer-left-open-pos buffer) ,vector ,mask))))))
 
 ); eval-when (:compile-toplevel :execute)
@@ -547,5 +549,7 @@
   "Find the previous character whose attribute value satisfies test."
   (let* ((charpos (mark-charpos mark))
-	 (line (mark-line mark)) vector mask end-wins)
+	 (line (mark-line mark))
+         (buffer (line-%buffer line))
+         vector mask end-wins)
     (declare (type (or (simple-array (mod 256)) null) vector)
 	     (type (or fixnum null) charpos))
@@ -553,6 +557,6 @@
     (cond 
      ((cond
-       ((eq line *open-line*)
-	(when (rev-cache-find-attribute charpos charpos vector mask)
+       ((eq line (buffer-open-line buffer))
+	(when (rev-cache-find-attribute buffer charpos charpos vector mask)
 	  (setf (mark-charpos mark) (1+ charpos)) mark))
        (t
@@ -572,6 +576,6 @@
 	      (return (line-start mark next))
 	      (return nil)))
-	 ((eq line *open-line*)
-	  (when (rev-cache-find-attribute nil charpos vector mask)
+	 ((eq line (buffer-open-line buffer))
+	  (when (rev-cache-find-attribute buffer nil charpos vector mask)
 	    (return (move-to-position mark (1+ charpos) line))))
 	 (t