Changeset 12646

Timestamp:

05/01/10 21:43:28 (14 years ago)

Author:

ehuelsmann

Message:

Re #93: Instead of fixing just readList and readDelimitedList,
document the protocol for processChar and fix that. Also, remove
a pattern from LispReader?.java (return null) which can't be used
by Lisp functions.

This commit fixes a much broader range of cases of the symptom
reported in #93.

Location:

trunk/abcl/src/org/armedbear/lisp

Files:

• LispReader.java (modified) (2 diffs)
• Stream.java (modified) (4 diffs)

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

@@ -47 +47 @@
 
         {
-          try 
+          try
             {
               while (true) {
                 int n = stream._readChar();
                 if (n < 0)
-                  return null;
+                  return LispThread.currentThread().setValues();
                 if (n == '\n')
-                  return null;
+                  return LispThread.currentThread().setValues();
               }
             }
           catch (java.io.IOException e)
             {
-              return null;
+                return LispThread.currentThread().setValues();
             }
         }
@@ -329 +329 @@
         {
             stream.skipBalancedComment();
-            return null;
+            return LispThread.currentThread().setValues();
         }
     };

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

@@ -482 +482 @@
                 if (rt.isWhitespace(c))
                     continue;
-                LispObject result = processChar(c, rt);
+                LispObject result = processChar(thread, c, rt);
                 if (result != null)
                     return result;
@@ -498 +498 @@
     }
 
-    private final LispObject processChar(char c, Readtable rt)
-
+    /** Dispatch macro function if 'c' has one associated,
+     * read a token otherwise.
+     *
+     * When the macro function returns zero values, this function
+     * returns null or the token or returned value otherwise.
+     */
+    private final LispObject processChar(LispThread thread,
+                                         char c, Readtable rt)
     {
         final LispObject handler = rt.getReaderMacroFunction(c);
-        if (handler instanceof ReaderMacroFunction)
-            return ((ReaderMacroFunction)handler).execute(this, c);
-        if (handler != null && handler != NIL)
-            return handler.execute(this, LispCharacter.getInstance(c));
-        return readToken(c, rt);
+        LispObject value;
+
+        if (handler instanceof ReaderMacroFunction) {
+            thread._values = null;
+            value = ((ReaderMacroFunction)handler).execute(this, c);
+        }
+        else if (handler != null && handler != NIL) {
+            thread._values = null;
+            value = handler.execute(this, LispCharacter.getInstance(c));
+        }
+        else
+            return readToken(c, rt);
+
+        // If we're looking at zero return values, set 'value' to null
+        if (value == NIL) {
+            LispObject[] values = thread._values;
+            if (values != null && values.length == 0)
+                value = null;
+        }
+        return value;
     }
 
@@ -659 +680 @@
                 }
 
-                thread._values = null;
-                LispObject obj = processChar(c, rt);
-                if (obj == null) {
-                    // A comment.
+                LispObject obj = processChar(thread, c, rt);
+                if (obj == null)
                     continue;
-                }
-
-                if (! (obj == NIL && thread._values != null
-                       && thread._values.length == 0)) {
-                    // Don't add the return value NIL to the list
-                    // if the _values array indicates no values have been returned
-                    if (first == null) {
-                        first = new Cons(obj);
-                        last = first;
-                    } else {
-                        Cons newCons = new Cons(obj);
-                        last.cdr = newCons;
-                        last = newCons;
-                    }
+
+
+                if (first == null) {
+                    first = new Cons(obj);
+                    last = first;
+                } else {
+                    Cons newCons = new Cons(obj);
+                    last.cdr = newCons;
+                    last = newCons;
                 }
             }
@@ -1449 +1463 @@
                 break;
 
-            thread._values = null;
-            LispObject obj = processChar(c, rt);
-            if (obj != null &&
-                ! (obj == NIL && thread._values != null
-                   && thread._values.length == 0))
-                // Don't add 'obj' to the list, if _values indicates
-                // no values have been returned
+            LispObject obj = processChar(thread, c, rt);
+            if (obj != null)
                 result = new Cons(obj, result);
         }