Changeset 11414

Timestamp:

12/04/08 19:19:09 (15 years ago)

Author:

ehuelsmann

Message:

Un-duplicate Stream and FileStream? implementations.

Patch by: Hideo at Yokohama
Tweaked by: me

Location:

branches/open-external-format/src/org/armedbear/lisp

Files:

• FileStream.java (modified) (6 diffs)
• Stream.java (modified) (14 diffs)

branches/open-external-format/src/org/armedbear/lisp/FileStream.java

@@ -50 +50 @@
     private final Pathname pathname;
     private final int bytesPerUnit;
-    private InputStream inst;
-    private OutputStream outst;
-    private Reader reader;
-    private Writer writer;
 
     public FileStream(Pathname pathname, String namestring,
@@ -114 +110 @@
             bytesPerUnit = 1;
       if (isInputStream) {
-    reader = racf.getReader();
+    initAsCharacterInputStream(racf.getReader());
       }
       if (isOutputStream) {
-    writer = racf.getWriter();
+    initAsCharacterOutputStream(racf.getWriter());
       }
         } else {
@@ -130 +126 @@
             bytesPerUnit = width / 8;
       if (isInputStream) {
-    inst = racf.getInputStream();
+    initAsBinaryInputStream(racf.getInputStream());
       }
       if (isOutputStream) {
-    outst = racf.getOutputStream();
+    initAsBinaryOutputStream(racf.getOutputStream());
       }
         }
@@ -163 +159 @@
     {
         return pathname;
-    }
-
-    @Override
-    public LispObject listen() throws ConditionThrowable
-    {
-        try {
-      if (isInputStream) {
-    return (racf.position() < racf.length()) ? T : NIL;
-      } else {
-    streamNotInputStream();
-      }
-        }
-  catch (IOException e) {
-            error(new StreamError(this, e));
-        }
-        // Not reached.
-        return NIL;
     }
 
@@ -210 +189 @@
     }
 
-    // Returns -1 at end of file.
-    @Override
-    protected int _readChar() throws ConditionThrowable
-    {
-        try {
-            int c = reader.read();
-            if (eolStyle == EolStyle.CRLF) {
-                if (c == '\r') {
-                    int c2 = reader.read();
-                    if (c2 == '\n') {
-                        ++lineNumber;
-                        return c2;
-                    } else {
-      // '\r' was not followed by '\n'
-      // we cannot depend on characters to contain 1 byte only
-      // so we need to revert to the last known position.
-      // The classical use case for unreadChar
-      racf.unreadChar((char)c2);
-        }
-                }
-                return c;
-            } else if (c == eolChar) {
-                ++lineNumber;
-                return c;
-            } else {
-    return c;
-      }
-        }
-        catch (NullPointerException e) {
-            streamNotInputStream();
-        }
-        catch (IOException e) {
-            error(new StreamError(this, e));
-        }
-        // Not reached.
-        return -1;
-    }
-
     @Override
     protected void _unreadChar(int n) throws ConditionThrowable
@@ -263 +204 @@
     {
         return true;
-    }
-
-    @Override
-    public void _writeChar(char c) throws ConditionThrowable
-    {
-        try {
-            if (c == '\n') {
-                if (eolStyle == EolStyle.CRLF)
-                    writer.write('\r');
-                writer.write(eolChar);
-                charPos = 0;
-            } else {
-                writer.write(c);
-                ++charPos;
-            }
-        }
-        catch (IOException e) {
-            error(new StreamError(this, e));
-        }
-    }
-
-    @Override
-    public void _writeChars(char[] chars, int start, int end)
-        throws ConditionThrowable {
-  _writeChars(chars, start, end, true);
-    }
-
-    public void _writeChars(char[] chars, int start, int end, boolean maintainCharPos)
-        throws ConditionThrowable
-    {
-        try {
-      if (eolStyle == EolStyle.LF) {
-    /* we can do a little bit better in this special case */
-    writer.write(chars, start, end);
-    if (maintainCharPos) {
-        int lastlfpos = -1;
-        for (int i = start; i < end; i++) {
-      if (chars[i] == '\n') {
-          lastlfpos = i;
-      }
-        }
-        if (lastlfpos == -1) {
-      charPos += end - start;
-        } else {
-      charPos = end - lastlfpos;
-        }
-    }
-      } else if (eolStyle == EolStyle.CRLF) {
-                for (int i = start; i < end; i++) {
-                    char c = chars[i];
-                    if (c == '\n') {
-                        writer.write('\r');
-                        writer.write('\n');
-                        charPos = 0;
-                    } else {
-                        writer.write(c);
-                        ++charPos;
-                    }
-                }
-            } else {
-                for (int i = start; i < end; i++) {
-                    char c = chars[i];
-                    if (c == '\n') {
-                        writer.write(eolChar);
-                        charPos = 0;
-                    } else {
-                        writer.write(c);
-                        ++charPos;
-                    }
-                }
-            }
-        }
-        catch (IOException e) {
-            error(new StreamError(this, e));
-        }
-    }
-
-    @Override
-    public void _writeString(String s) throws ConditionThrowable
-    {
-        _writeChars(s.toCharArray(), 0, s.length(), true);
-    }
-
-    @Override
-    public void _writeLine(String s) throws ConditionThrowable
-    {
-  _writeChars(s.toCharArray(), 0, s.length(), false);
-        if (eolStyle == EolStyle.CRLF)
-            _writeChar('\r');
-        _writeChar(eolChar);
-        charPos = 0;
-    }
-
-    // Reads an 8-bit byte.
-    @Override
-    public int _readByte() throws ConditionThrowable
-    {
-        try {
-            return inst.read(); // Reads an 8-bit byte.
-        }
-        catch (NullPointerException e) {
-            streamNotInputStream();
-        }
-        catch (IOException e) {
-            error(new StreamError(this, e));
-        }
-        // Not reached.
-        return -1;
-    }
-
-    // Writes an 8-bit byte.
-    @Override
-    public void _writeByte(int n) throws ConditionThrowable
-    {
-        try {
-            outst.write(n); // Writes an 8-bit byte.
-        }
-        catch (NullPointerException e) {
-            streamNotOutputStream();
-        }
-        catch (IOException e) {
-            error(new StreamError(this, e));
-        }
     }
 

branches/open-external-format/src/org/armedbear/lisp/Stream.java

@@ -44 +44 @@
 import java.io.PrintWriter;
 import java.io.PushbackReader;
+import java.io.Reader;
 import java.io.StringWriter;
 import java.io.Writer;
@@ -67 +68 @@
 
   // Character input.
-  private PushbackReader reader;
+  private Reader reader;
+  private PushbackReader pushbackReader;
   protected int offset;
   protected int lineNumber;
@@ -107 +109 @@
   
   // Binary input.
-  private BufferedInputStream in;
+  private InputStream in;
 
   // Binary output.
-  private BufferedOutputStream out;
+  private OutputStream out;
+
+  // end of line character sequence.
+  private char[] eolseq;
+  
+  private void setEolSeq() {
+    if (eolStyle == EolStyle.CRLF) {
+      eolseq = new char[] { '\r', '\n' };
+    } else if (eolStyle == EolStyle.CR) {
+      eolseq = new char[] { '\r' };
+    } else {
+      eolseq = new char[] { '\n' };
+    }
+  }
 
   protected Stream()
   {
+    setEolSeq();
   }
 
   public Stream(InputStream inputStream, LispObject elementType)
     {
-  this(inputStream, elementType, null);
+      this(inputStream, elementType, null);
     }
 
@@ -128 +144 @@
     if (elementType == Symbol.CHARACTER || elementType == Symbol.BASE_CHAR)
       {
-        isCharacterStream = true;
         InputStreamReader inputStreamReader;
         try
@@ -143 +158 @@
               new InputStreamReader(inputStream);
           }
-        reader = new PushbackReader(new BufferedReader(inputStreamReader),
-                                    2);
+        pushbackReader = new PushbackReader(new BufferedReader(inputStreamReader),
+              2);
+  initAsCharacterInputStream(pushbackReader);
       }
     else
       {
         isBinaryStream = true;
-        in = new BufferedInputStream(inputStream);
-      }
-    isInputStream = true;
-    isOutputStream = false;
+        InputStream in = new BufferedInputStream(inputStream);
+  initAsBinaryInputStream(in);
+      }
+    setEolSeq();
   }
 
@@ -163 +179 @@
   public Stream(OutputStream outputStream, LispObject elementType)
     {
-  this(outputStream, elementType, null);
+      this(outputStream, elementType, null);
     }
     
@@ -172 +188 @@
     if (elementType == Symbol.CHARACTER || elementType == Symbol.BASE_CHAR)
       {
-        isCharacterStream = true;
+  Writer writer;
         try
           {
@@ -184 +200 @@
             writer = new OutputStreamWriter(outputStream);
           }
+  initAsCharacterOutputStream(writer);
       }
     else
       {
-        isBinaryStream = true;
-        out = new BufferedOutputStream(outputStream);
-      }
-    isInputStream = false;
-    isOutputStream = true;
+        OutputStream out = new BufferedOutputStream(outputStream);
+  initAsBinaryOutputStream(out);
+      }
+    setEolSeq();
   }
 
@@ -199 +215 @@
     this(outputStream, elementType);
     setInteractive(interactive);
+  }
+
+  protected void initAsCharacterInputStream(Reader reader)
+  {
+    this.reader = reader;
+    isInputStream = true;
+    isCharacterStream = true;
+  }
+
+  protected void initAsBinaryInputStream(InputStream in) {
+    this.in = in;
+    isInputStream = true;
+    isBinaryStream = true;
+  }
+
+  protected void initAsCharacterOutputStream(Writer writer) {
+    this.writer = writer;
+    isOutputStream = true;
+    isCharacterStream = true;
+  }
+
+  protected void initAsBinaryOutputStream(OutputStream out) {
+    this.out = out;
+    isOutputStream = true;
+    isBinaryStream = true;
   }
 
@@ -255 +296 @@
       eolChar = (eolStyle == EolStyle.CR) ? '\r' : '\n';
       externalFormat = format;
-      
+      setEolSeq();
       return;
     }
@@ -1798 +1839 @@
     try
       {
-        reader.unread(n);
+        pushbackReader.unread(n);
         --offset;
         if (n == eolChar)
@@ -1849 +1890 @@
       {
         if (c == '\n') {
-          if (eolStyle == EolStyle.CRLF)
-              writer.write('\r');
-          writer.write(eolChar);
+    writer.write(eolseq);
           writer.flush();
           charPos = 0;
@@ -1899 +1938 @@
                 index = i;
                 break;
-              }
-          }
+    }
+  }
         if (index < 0)
           {
             // No newline.
             charPos += (end - start);
-          }
+        }
         else
           {
             charPos = end - (index + 1);
             writer.flush();
-          }
-      }
+      }
+    }
     catch (NullPointerException e)
       {
@@ -1935 +1974 @@
     try
       {
-        for (int i = 0; i < s.length(); i++)
-          //###FIXME: the number of writes can be greatly reduced by
-          // writing the space between newlines as chunks.
-          _writeChar(s.charAt(i));
+  _writeChars(s.toCharArray(), 0, s.length());
       }
     catch (NullPointerException e)