Changeset 12595

Timestamp:

04/10/10 20:28:06 (13 years ago)

Author:

ehuelsmann

Message:

Consolidate the functionality of faslReadPreservingWhitespace
and readPreservingWhitespace.

File:

• trunk/abcl/src/org/armedbear/lisp/Stream.java (modified) (7 diffs)

trunk/abcl/src/org/armedbear/lisp/Stream.java

@@ -431 +431 @@
     {
         LispObject result = readPreservingWhitespace(eofError, eofValue,
-                                                     recursive, thread);
+                                                     recursive, thread,
+                                                     currentReadtable);
         if (result != eofValue && !recursive) {
             try {
@@ -461 +462 @@
                                                LispObject eofValue,
                                                boolean recursive,
-                                               LispThread thread)
+                                               LispThread thread,
+                                               ReadtableAccessor rta)
 
     {
         if (recursive) {
-            final Readtable rt = (Readtable) Symbol.CURRENT_READTABLE.symbolValue(thread);
+            final Readtable rt = rta.rt(thread);
             while (true) {
                 int n = -1;
@@ -491 +493 @@
             thread.bindSpecial(_SHARP_EQUAL_ALIST_, NIL);
             try {
-                return readPreservingWhitespace(eofError, eofValue, true, thread);
+                return readPreservingWhitespace(eofError, eofValue, true,
+                                                thread, rta);
             } finally {
                 thread.resetSpecialBindings(mark);
@@ -503 +506 @@
     {
         try {
-            LispObject result = faslReadPreservingWhitespace(eofError, eofValue,
-                                recursive, thread);
+            LispObject result =
+                    readPreservingWhitespace(eofError, eofValue, recursive,
+                                             thread, faslReadtable);
             if (result != eofValue && !recursive) {
                 if (_charReady()) {
@@ -522 +526 @@
         } catch (IOException e) {
             return error(new StreamError(this, e));
-        }
-    }
-
-    private final LispObject faslReadPreservingWhitespace(boolean eofError,
-            LispObject eofValue,
-            boolean recursive,
-            LispThread thread)
-    throws IOException {
-        if (recursive) {
-            final Readtable rt = FaslReadtable.getInstance();
-            while (true) {
-                int n = _readChar();
-                if (n < 0) {
-                    if (eofError)
-                        return error(new EndOfFile(this));
-                    else
-                        return eofValue;
-                }
-                char c = (char) n; // ### BUG: Codepoint conversion
-                if (rt.isWhitespace(c))
-                    continue;
-                LispObject result = processChar(c, rt);
-                if (result != null)
-                    return result;
-            }
-        } else {
-            final SpecialBindingsMark mark = thread.markSpecialBindings();
-            thread.bindSpecial(_SHARP_EQUAL_ALIST_, NIL);
-            try {
-                return faslReadPreservingWhitespace(eofError, eofValue, true, thread);
-            } finally {
-                thread.resetSpecialBindings(mark);
-            }
         }
     }
@@ -2266 +2237 @@
             if (preserveWhitespace)
                 result = in.readPreservingWhitespace(eofError, third, false,
-                                                     thread);
+                                                     thread, currentReadtable);
             else
                 result = in.read(eofError, third, false, thread);
@@ -2351 +2322 @@
             return stream.readPreservingWhitespace(eofError, eofValue,
                                                    recursive,
-                                                   LispThread.currentThread());
+                                                   LispThread.currentThread(),
+                                                   currentReadtable);
         }
     };