Index: /branches/ide-1.0/ccl/hemlock/src/htext1.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/htext1.lisp	(revision 6579)
+++ /branches/ide-1.0/ccl/hemlock/src/htext1.lisp	(revision 6580)
@@ -50,31 +50,55 @@
 
 
-
-(defun grow-open-chars (buffer &optional (new-length (* (buffer-line-cache-length buffer) 2)))
+#+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)))
   "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 (- (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)
+	(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 ()
   "Stuffs the characters in the currently open line back into the line they
-  came from, and sets (buffer-open-line buffer) to Nil."
-  (when (buffer-open-line buffer)
+  came from, and sets *open-line* to Nil."
+  (when *open-line*
     (hemlock-ext:without-interrupts
-      (let* ((length (+ (buffer-left-open-pos buffer)
-                        (- (buffer-line-cache-length buffer)
-                           (buffer-right-open-pos buffer))))
+      (let* ((length (+ *left-open-pos* (- *line-cache-length* *right-open-pos*)))
 	     (string (make-string length)))
-	(%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)))))
+	(%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)))))
 
 ;;; We stick decrementing fixnums in the line-chars slot of the open line
@@ -89,49 +113,46 @@
   "Closes the current *Open-Line* and opens the given Line at the Mark.
   Don't call this, use modifying-line instead."
-  (let* ((buffer (line-%buffer line)))
-    (cond ((eq line (buffer-open-line buffer))
+  (cond ((eq line *open-line*)
 	   (let ((charpos (mark-charpos mark)))
-	     (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)
+	     (cond ((< charpos *left-open-pos*) ; BLT 'em right!
+		    (let ((right-start (- *right-open-pos*
+					  (- *left-open-pos* charpos))))
+		      (%sp-byte-blt *open-chars*
 				    charpos
-				    (buffer-open-chars buffer)
+				    *open-chars*
 				    right-start
-				    (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)
+				    *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*
 				  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)))))
+		    (setf *right-open-pos*
+			  (+ *right-open-pos*
+			     (- charpos *left-open-pos*)))
+		    (setf *left-open-pos* charpos)))))
 
 	  (t
-	   (close-line buffer)
+	   (close-line)
 	   (let* ((chars (line-chars line))
 		  (len (length chars)))
 	     (declare (simple-string chars))
-	     (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)))))))
+	     (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*)))))
 
 
@@ -141,12 +162,10 @@
 (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 (buffer-open-line buffer)'s chars.  This must be called within
+  if not.  Sticks a tick in the *open-line*'s chars.  This must be called within
   the body of a Modifying-Buffer form."
-  (let* ((buffer (gensym)))
-  `(let* ((,buffer (line-%buffer ,line)))
-    (unless (and (= (mark-charpos ,mark) (buffer-left-open-pos ,buffer))
-                 (eq ,line (buffer-open-line ,buffer)))
+  `(progn
+    (unless (and (= (mark-charpos ,mark) *left-open-pos*) (eq ,line *open-line*))
       (open-line ,line ,mark))
-    (setf (line-chars (buffer-open-line ,buffer)) (decf *cache-modification-tick*)))))
+    (setf (line-chars *open-line*) (decf *cache-modification-tick*))))
 
 ;;; Now-Tick tells us when now is and isn't.
@@ -341,8 +360,7 @@
   "Returns the characters in the line as a string.  The resulting string
   must not be destructively modified.  This may be set with Setf."
-  (let* ((buffer (line-%buffer line)))
-    (if (eq line (buffer-open-line buffer))
-      (close-line buffer))
-    (line-chars line)))
+  (if (eq line *open-line*)
+    (close-line))
+  (line-chars line))
 
 (defun %set-line-string (line string)
@@ -351,6 +369,5 @@
       (unless (simple-string-p string) 
 	(setq string (coerce string 'simple-string)))
-      (when (eq line (buffer-open-line buffer))
-        (setf (buffer-open-line buffer) nil))
+      (when (eq line *open-line*) (setq *open-line* nil))
       (let ((length (length (the simple-string string))))
 	(dolist (m (line-marks line))
@@ -363,18 +380,16 @@
   "Return the Index'th character in Line.  If the index is the length of the
   line then #\newline is returned."
-  (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))))
+  (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 ((chars (line-chars line)))
 	(declare (simple-string chars))
 	(if (= index (length chars))
-          #\newline
-          (schar chars index))))))
+	    #\newline
+	    (schar chars index)))))
 
 
@@ -546,10 +561,7 @@
   "Returns T if the line pointer to by Mark contains no characters, Nil 
   or otherwise."
-  (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)))
+  (let ((line (mark-line mark)))
+    (if (eq line *open-line*)
+	(and (= *left-open-pos* 0) (= *right-open-pos* *line-cache-length*))
 	(= (length (line-chars line)) 0))))
 
@@ -566,17 +578,15 @@
 ;;;
 (defun blank-between-positions (line start end)
-  (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))))))
+  (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 ((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 6579)
+++ /branches/ide-1.0/ccl/hemlock/src/htext2.lisp	(revision 6580)
@@ -26,5 +26,5 @@
 (defun region-to-string (region)
   "Returns a string containing the characters in the given Region."
-  (close-line (line-%buffer (mark-line (region-start region))))
+  (close-line)
   (let* ((dst-length (count-characters region))
 	 (string (make-string dst-length))
@@ -99,42 +99,36 @@
 (defun previous-character (mark)
   "Returns the character immediately before the given Mark."
-  (let* ((line (mark-line mark))
-         (buffer (line-%buffer line))
-         (charpos (mark-charpos mark)))
+  (let ((line (mark-line mark))
+	(charpos (mark-charpos mark)))
     (if (= charpos 0)
-      (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))))))
+	(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))))))
 
 (defun next-character (mark)
   "Returns the character immediately after the given Mark."
-  (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))))))
+  (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))))))
 
 
@@ -154,5 +148,5 @@
       (modifying-line line mark)
       (cond ((= (mark-charpos mark)
-		(- (buffer-line-cache-length buffer) (- (buffer-right-open-pos buffer) (buffer-left-open-pos buffer))))
+		(- *line-cache-length* (- *right-open-pos* *left-open-pos*)))
 	     ;; The mark is at the end of the line.
 	     (unless next
@@ -163,13 +157,13 @@
 	       (let ((chars (line-chars next)))
 		 (declare (simple-string chars))
-		 (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)))
+		 (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*))
 	       (move-some-marks (charpos next line) 
-				(+ charpos (buffer-left-open-pos buffer)))
+				(+ charpos *left-open-pos*))
 	       (setq next (line-next next))
 	       (setf (line-next line) next)
@@ -177,18 +171,18 @@
 	    ((char= character #\newline)
 	     ;; The char is being changed to a newline, so we must split lines.
-	     (incf (buffer-right-open-pos buffer))
-	     (let* ((len (- (buffer-line-cache-length buffer) (buffer-right-open-pos buffer)))	   
+	     (incf *right-open-pos*)
+	     (let* ((len (- *line-cache-length* *right-open-pos*))	   
 		    (chars (make-string len))
 		    (new (make-line :chars chars  :previous line 
 				    :next next  :%buffer buffer)))
-	       (%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))
+	       (%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))
 	       (setf (line-next line) new)
 	       (when next (setf (line-previous next) new))
-	       (setf (buffer-right-open-pos buffer) (buffer-line-cache-length buffer))
+	       (setq *right-open-pos* *line-cache-length*)
 	       (number-line new)))
 	    (t
-	     (setf (char (the simple-string (buffer-open-chars buffer)) (buffer-right-open-pos buffer))
+	     (setf (char (the simple-string *open-chars*) *right-open-pos*)
 		   character)
 	     (hi::buffer-note-modification buffer mark 1)))))
@@ -386,39 +380,14 @@
 
 (defun %print-whole-line (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)))))
+  (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))))
 
 (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))
@@ -427,14 +396,36 @@
 	(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  :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)))
+	      ((eq line *open-line*)
+	       (cond ((< charpos *left-open-pos*)
+		      (write-string *open-chars* stream :end charpos))
 		     (t
-		      (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))))))
+		      (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*)))))
 	      (t
 	       (write-string chars stream  :start charpos  :end length))))
@@ -464,5 +455,4 @@
 	 (end (region-end region))
 	 (first-line (mark-line start))
-         (buffer (line-%buffer first-line))
 	 (last-line (mark-line end)))
     (cond
@@ -479,16 +469,16 @@
 		((or (< cs 0) (> ce len))
 		 (write-string "{bad region}" stream))
-		((eq first-line (buffer-open-line buffer))
-		 (let ((gap (- (buffer-right-open-pos buffer) (buffer-left-open-pos buffer))))
+		((eq first-line *open-line*)
+		 (let ((gap (- *right-open-pos* *left-open-pos*)))
 		   (cond
-		    ((<= 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)
+		    ((<= 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)
 				   :end (+ ce gap)))
 		    (t
-		     (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)
+		     (write-string *open-chars* stream :start cs
+				   :end *left-open-pos*)
+		     (write-string *open-chars* stream :start *right-open-pos*
 				   :end (+ gap ce))))))
 		(t
Index: /branches/ide-1.0/ccl/hemlock/src/htext3.lisp
===================================================================
--- /branches/ide-1.0/ccl/hemlock/src/htext3.lisp	(revision 6579)
+++ /branches/ide-1.0/ccl/hemlock/src/htext3.lisp	(revision 6580)
@@ -47,35 +47,33 @@
 		      (cond ((char= character #\newline)
 			     (let* ((next (line-next line))
-				    (new-chars (subseq (the simple-string (buffer-open-chars buffer))
-						       0 (buffer-left-open-pos buffer)))
+				    (new-chars (subseq (the simple-string *open-chars*)
+						       0 *left-open-pos*))
 				    (new-line (make-line :%buffer buffer
 							 :chars (decf *cache-modification-tick*)
 							 :previous line
 							 :next next)))
-			       (maybe-move-some-marks (charpos line new-line) (buffer-left-open-pos buffer)
-						      (- charpos (buffer-left-open-pos buffer)))
+			       (maybe-move-some-marks (charpos line new-line) *left-open-pos*
+						      (- charpos *left-open-pos*))
 			       (setf (line-%chars line) new-chars)
 			       (setf (line-next line) new-line)
 			       (if next (setf (line-previous next) new-line))
 			       (number-line new-line)
-			       (setf (buffer-open-line buffer) new-line
-                                     (buffer-left-open-pos buffer) 0)))
+			       (setq *open-line* new-line  *left-open-pos* 0)))
 			    (t
-			     (if (= (buffer-right-open-pos buffer)
-                                    (buffer-left-open-pos buffer))
-			       (grow-open-chars buffer))
+			     (if (= *right-open-pos* *left-open-pos*)
+			       (grow-open-chars))
 	     
-			     (maybe-move-some-marks (charpos line) (buffer-left-open-pos buffer)
+			     (maybe-move-some-marks (charpos line) *left-open-pos*
 						    (1+ charpos))
 	     
 			     (cond
 			       ((eq (mark-%kind mark) :right-inserting)
-				(decf (buffer-right-open-pos buffer))
-				(setf (char (the simple-string (buffer-open-chars buffer)) (buffer-right-open-pos buffer))
+				(decf *right-open-pos*)
+				(setf (char (the simple-string *open-chars*) *right-open-pos*)
 				      character))
 			       (t
-				(setf (char (the simple-string (buffer-open-chars buffer)) (buffer-left-open-pos buffer))
+				(setf (char (the simple-string *open-chars*) *left-open-pos*)
 				      character)
-				(incf (buffer-left-open-pos buffer))))))
+				(incf *left-open-pos*)))))
 		      (buffer-note-insertion buffer mark 1))))
 
@@ -109,18 +107,18 @@
 	 (modifying-line line mark)
 	 (let ((length (- end start)))
-	   (if (<= (buffer-right-open-pos buffer) (+ (buffer-left-open-pos buffer) end))
-	     (grow-open-chars buffer (* (+ (buffer-line-cache-length buffer) end) 2)))
+	   (if (<= *right-open-pos* (+ *left-open-pos* end))
+	     (grow-open-chars (* (+ *line-cache-length* end) 2)))
 	      
-	   (maybe-move-some-marks (charpos line) (buffer-left-open-pos buffer)
+	   (maybe-move-some-marks (charpos line) *left-open-pos*
 				  (+ charpos length))
 	   (cond
 	     ((eq (mark-%kind mark) :right-inserting)
-	      (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)))
+	      (let ((new (- *right-open-pos* length)))
+		(%sp-byte-blt string start *open-chars* new *right-open-pos*)
+		(setq *right-open-pos* new)))
 	     (t
-	      (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)))))
+	      (let ((new (+ *left-open-pos* length)))
+		(%sp-byte-blt string start *open-chars* *left-open-pos* new)
+		(setq *left-open-pos* new)))))
 	 (buffer-note-insertion buffer mark (- end start)))))))
 
@@ -135,5 +133,4 @@
 	 (end (region-end region))
 	 (first-line (mark-line start))
-         (buffer (line-%buffer first-line))
 	 (last-line (mark-line end))
 	 (first-charpos (mark-charpos start))
@@ -143,12 +140,12 @@
      ((eq first-line last-line)
       ;; simple case -- just BLT the characters in with insert-string
-      (if (eq first-line (buffer-open-line buffer))
-        (close-line buffer))
+      (if (eq first-line *open-line*) (close-line))
       (insert-string mark (line-chars first-line) first-charpos last-charpos))
      (t
-      (close-line buffer)
+      (close-line)
       (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))
@@ -208,20 +205,19 @@
 	 (first-charpos (mark-charpos start))
 	 (last-charpos (mark-charpos end))
-         (nins (count-characters region))
-         (buffer (line-%buffer (mark-line mark))))
+         (nins (count-characters region)))
     (cond
      ((eq first-line last-line)
       ;; Simple case -- just BLT the characters in with insert-string.
-      (if (eq first-line (buffer-open-line buffer))
-        (close-line buffer))
+      (if (eq first-line *open-line*) (close-line))
       (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 buffer)
+      (close-line)
       (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 6579)
+++ /branches/ide-1.0/ccl/hemlock/src/htext4.lisp	(revision 6580)
@@ -44,16 +44,16 @@
                          (cond
                            ((minusp n)
-                            (incf (buffer-left-open-pos buffer) n)
+                            (setq *left-open-pos* (+ *left-open-pos* n))
                             (move-some-marks (pos line)
-                                             (if (> pos (buffer-left-open-pos buffer))
-                                               (if (<= pos charpos) (buffer-left-open-pos buffer) (+ pos n))
+                                             (if (> pos *left-open-pos*)
+                                               (if (<= pos charpos) *left-open-pos* (+ pos n))
                                                pos)))
 	 
                            (t
-                            (incf (buffer-right-open-pos buffer) n)
+                            (setq *right-open-pos* (+ *right-open-pos* n))
                             (let ((bound (+ charpos n)))
                               (move-some-marks (pos line)
                                                (if (> pos charpos)
-                                                 (if (<= pos bound) (buffer-left-open-pos buffer) (- pos n))
+                                                 (if (<= pos bound) *left-open-pos* (- pos n))
                                                  pos)))))
                          (buffer-note-deletion buffer mark n)
@@ -99,5 +99,5 @@
 	       (modifying-line first-line start)
 	       (let ((num (- last-charpos first-charpos)))
-		 (incf (buffer-right-open-pos buffer) num)
+		 (setq *right-open-pos* (+ *right-open-pos* 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 buffer)
+	       (close-line)
 	       (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 (+ (buffer-right-open-pos buffer) num))
+                          (new-right (+ *right-open-pos* 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 (buffer-open-chars buffer) (buffer-right-open-pos buffer) new-chars 0 num) 
-                     (setf (buffer-right-open-pos buffer) new-right)
+                     (%sp-byte-blt *open-chars* *right-open-pos* new-chars 0 num) 
+                     (setq *right-open-pos* 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 buffer)
+                   (close-line)
                    (let* ((first-chars (line-chars first-line))
                           (last-chars (line-chars last-line))
@@ -271,5 +271,4 @@
 	 (end (region-end region))
 	 (first-line (mark-line start))
-         (buffer (line-%buffer first-line))
 	 (last-line (mark-line end))
 	 (first-charpos (mark-charpos start))
@@ -278,5 +277,5 @@
     (cond
      ((eq first-line last-line)
-      (when (eq first-line (buffer-open-line buffer)) (close-line buffer))
+      (when (eq first-line *open-line*) (close-line))
       (let* ((length (- last-charpos first-charpos))
 	     (chars (make-string length))
@@ -286,5 +285,5 @@
 			      (mark line length :left-inserting))))
      (t
-      (close-line buffer)
+      (close-line)
       (let* ((first-chars (line-chars first-line))
 	     (length (- (length first-chars) first-charpos))
@@ -353,13 +352,12 @@
       (modifying-line end-line end)
       (cond ((eq start-line end-line)
-	     (let* ((res (fcs function (subseq (buffer-open-chars buffer)
-                                               first last)))
+	     (let* ((res (fcs function (subseq *open-chars* first last)))
 		    (rlen (length res))
 		    (new-left (+ first rlen))
-		    (delta (- new-left (buffer-left-open-pos buffer))))
+		    (delta (- new-left *left-open-pos*)))
 	       (declare (simple-string res))
-	       (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))
+	       (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*)
 	       ;;
 	       ;; Move marks to start or end of region, depending on kind.
@@ -372,5 +370,5 @@
 				   new-left first)
 			       (+ charpos delta))))))
-	       (setf (buffer-left-open-pos buffer) new-left)))
+	       (setq *left-open-pos* new-left)))
 	    (t
 	     ;;
@@ -405,13 +403,13 @@
 	     ;;
 	     ;; Do the last line, which is cached.
-	     (let* ((res (fcs function (subseq (the simple-string (buffer-open-chars buffer))
+	     (let* ((res (fcs function (subseq (the simple-string *open-chars*)
 					       0 last)))
 		    (rlen (length res))
 		    (delta (- rlen last)))
 	       (declare (simple-string res))
-	       (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)
+	       (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)
 	       ;;
 	       ;; Adjust marks after the end of the region and save ones in it.