Changeset 11434

Timestamp:

12/07/08 23:24:31 (14 years ago)

Author:

ehuelsmann

Message:

Merge open-external-format branch back to trunk.

Location:

trunk/j

Files:

• build.xml (modified) (2 diffs)
• src/org/armedbear/lisp/FileStream.java (modified) (18 diffs)
• src/org/armedbear/lisp/Stream.java (modified) (22 diffs)
• src/org/armedbear/lisp/StringInputStream.java (modified) (10 diffs)
• src/org/armedbear/lisp/StringOutputStream.java (modified) (7 diffs)
• src/org/armedbear/lisp/open.lisp (modified) (4 diffs)
• src/org/armedbear/lisp/socket.lisp (modified) (2 diffs)
• src/org/armedbear/lisp/socket_stream.java (modified) (2 diffs)
• src/org/armedbear/lisp/util (copied) (copied from branches/open-external-format/src/org/armedbear/lisp/util)

trunk/j/build.xml

@@ -101 +101 @@
     <patternset id="abcl.source.java">
       <include name="org/armedbear/lisp/*.java"/>
+      <include name="org/armedbear/lisp/util/*.java"/>
       <include name="org/armedbear/Main.java"/>
     </patternset>
@@ -118 +119 @@
     <patternset id="abcl.objects">
       <include name="org/armedbear/lisp/*.class"/>
+      <include name="org/armedbear/lisp/util/*.class"/>
       <include name="org/armedbear/lisp/*.cls"/> 
       <include name="org/armedbear/lisp/*.abcl"/>

trunk/j/src/org/armedbear/lisp/FileStream.java

@@ -3 +3 @@
  *
  * Copyright (C) 2004-2006 Peter Graves
+ * Copyright (C) 2008 Hideo at Yokohama
  * $Id$
  *
@@ -35 +36 @@
 
 import java.io.File;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.Writer;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.RandomAccessFile;
+import org.armedbear.lisp.util.RandomAccessCharacterFile;
 
 public final class FileStream extends Stream
 {
-    private static final int BUFSIZE = 4096;
-
-    private final RandomAccessFile raf;
-    private final RandomAccessFile in;
-    private final RandomAccessFile out;
+    private final RandomAccessCharacterFile racf;
     private final Pathname pathname;
     private final int bytesPerUnit;
-    private final byte[] inputBuffer;
-    private final byte[] outputBuffer;
-
-    private long inputBufferFilePosition;
-    private int inputBufferOffset;
-    private int inputBufferCount;
-    private int outputBufferOffset;
 
     public FileStream(Pathname pathname, String namestring,
                       LispObject elementType, LispObject direction,
-                      LispObject ifExists)
+                      LispObject ifExists, LispObject format)
         throws IOException
     {
+        /* externalFormat is a LispObject of which the first char is a
+         * name of a character encoding (such as :UTF-8 or :ISO-8859-1), used
+         * by ABCL as a string designator, unless the name is :CODE-PAGE.
+         * A real string is (thus) also allowed.
+         * 
+         * Then, a property list follows with 3 possible keys:
+         *   :ID (values: code page numbers supported by MS-DOS/IBM-DOS/MS-Windows
+         *   :EOL-STYLE (values: :CR / :LF / :CRLF [none means native])
+         *   :LITTLE-ENDIAN (values: NIL / T)
+         * 
+         * These definitions have been taken from FLEXI-STREAMS:
+         *    http://www.weitz.de/flexi-streams/#make-external-format
+         */
         final File file = new File(namestring);
         String mode = null;
@@ -74 +82 @@
             isOutputStream = true;
         }
+        
         Debug.assertTrue(mode != null);
-        raf = new RandomAccessFile(file, mode);
-        in = isInputStream ? raf : null;
-        out = isOutputStream ? raf : null;
+        RandomAccessFile raf = new RandomAccessFile(file, mode);
+  
         // ifExists is ignored unless we have an output stream.
         if (isOutputStream) {
@@ -90 +98 @@
             }
         }
+        setExternalFormat(format);
+        
+  // don't touch raf directly after passing it to racf.
+  // the state will become inconsistent if you do that.
+        racf = new RandomAccessCharacterFile(raf, encoding);
+
         this.pathname = pathname;
         this.elementType = elementType;
@@ -95 +109 @@
             isCharacterStream = true;
             bytesPerUnit = 1;
+      if (isInputStream) {
+    initAsCharacterInputStream(racf.getReader());
+      }
+      if (isOutputStream) {
+    initAsCharacterOutputStream(racf.getWriter());
+      }
         } else {
             isBinaryStream = true;
@@ -105 +125 @@
             }
             bytesPerUnit = width / 8;
-        }
-        if (isBinaryStream && isInputStream && !isOutputStream && bytesPerUnit == 1)
-            inputBuffer = new byte[BUFSIZE];
-        else if (isCharacterStream && isInputStream && !isOutputStream)
-            inputBuffer = new byte[BUFSIZE];
-        else
-            inputBuffer = null;
-        if (isBinaryStream && isOutputStream && !isInputStream && bytesPerUnit == 1)
-            outputBuffer = new byte[BUFSIZE];
-        else if (isCharacterStream && isOutputStream && !isInputStream)
-            outputBuffer = new byte[BUFSIZE];
-        else
-            outputBuffer = null;
+      if (isInputStream) {
+    initAsBinaryInputStream(racf.getInputStream());
+      }
+      if (isOutputStream) {
+    initAsBinaryOutputStream(racf.getOutputStream());
+      }
+        }
     }
 
@@ -148 +162 @@
 
     @Override
-    public LispObject listen() throws ConditionThrowable
-    {
-        try {
-            return in.getFilePointer() < in.length() ? T : NIL;
-        }
-        catch (NullPointerException e) {
-            streamNotInputStream();
-        }
-        catch (IOException e) {
-            error(new StreamError(this, e));
-        }
-        // Not reached.
-        return NIL;
-    }
-
-    @Override
     public LispObject fileLength() throws ConditionThrowable
     {
@@ -169 +167 @@
         if (isOpen()) {
             try {
-                length = raf.length();
+                length = racf.length();
             }
             catch (IOException e) {
@@ -192 +190 @@
 
     @Override
-    public LispObject readLine(boolean eofError, LispObject eofValue)
-        throws ConditionThrowable
-    {
-        if (inputBuffer != null) {
-            final LispThread thread = LispThread.currentThread();
-            final FastStringBuffer sb = new FastStringBuffer();
-            while (true) {
-                int n = _readChar();
-                if (n < 0) {
-                    // End of file.
-                    if (sb.length() == 0) {
-                        if (eofError)
-                            return error(new EndOfFile(this));
-                        return thread.setValues(eofValue, T);
-                    }
-                    return thread.setValues(new SimpleString(sb), T);
-                }
-                char c = (char) n;
-                if (c == '\n')
-                    return thread.setValues(new SimpleString(sb), NIL);
-                else
-                    sb.append(c);
-            }
-        } else
-            return super.readLine(eofError, eofValue);
-    }
-
-    // Returns -1 at end of file.
-    @Override
-    protected int _readChar() throws ConditionThrowable
-    {
-        try {
-            int c = _readByte();
-            if (Utilities.isPlatformWindows) {
-                if (c == '\r') {
-                    int c2 = _readByte();
-                    if (c2 == '\n') {
-                        ++lineNumber;
-                        return c2;
-                    }
-                    // '\r' was not followed by '\n'
-                    if (inputBuffer != null && inputBufferOffset > 0) {
-                        --inputBufferOffset;
-                    } else {
-                        clearInputBuffer();
-                        long pos = in.getFilePointer();
-                        if (pos > 0)
-                            in.seek(pos - 1);
-                    }
-                }
-                return c;
-            }
-            if (c == '\n') {
-                ++lineNumber;
-                return c;
-            }
-            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
     {
-        if (inputBuffer != null && inputBufferOffset > 0) {
-            --inputBufferOffset;
-            if (n != '\n')
-                return;
-            --lineNumber;
-            if (!Utilities.isPlatformWindows)
-                return;
-            // Check for preceding '\r'.
-            if (inputBufferOffset > 0) {
-                if (inputBuffer[--inputBufferOffset] != '\r')
-                    ++inputBufferOffset;
-                return;
-            }
-            // We can't go back far enough in the buffered input. Reset and
-            // fall through...
-            ++inputBufferOffset;
-        }
-        try {
-            long pos;
-            if (inputBuffer != null && inputBufferFilePosition >= 0)
-                pos = inputBufferFilePosition + inputBufferOffset;
-            else
-                pos = in.getFilePointer();
-            clearInputBuffer();
-            if (pos > 0)
-                in.seek(pos - 1);
-            if (Utilities.isPlatformWindows && n == '\n') {
-                // Check for preceding '\r'.
-                pos = in.getFilePointer();
-                if (pos > 0) {
-                    in.seek(pos - 1);
-                    n = in.read();
-                    if (n == '\r')
-                        in.seek(pos - 1);
-                }
-            }
-        }
-        catch (NullPointerException e) {
-            streamNotInputStream();
+        try {
+            racf.unreadChar((char)n);
         }
         catch (IOException e) {
@@ -315 +207 @@
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
-    {
-        if (c == '\n') {
-            if (Utilities.isPlatformWindows)
-                _writeByte((byte)'\r');
-            _writeByte((byte)c);
-            charPos = 0;
-        } else {
-            _writeByte((byte)c);
-            ++charPos;
-        }
-    }
-
-    @Override
-    public void _writeChars(char[] chars, int start, int end)
-        throws ConditionThrowable
-    {
-        if (Utilities.isPlatformWindows) {
-            for (int i = start; i < end; i++) {
-                char c = chars[i];
-                if (c == '\n') {
-                    _writeByte((byte)'\r');
-                    _writeByte((byte)c);
-                    charPos = 0;
-                } else {
-                    _writeByte((byte)c);
-                    ++charPos;
-                }
-            }
-        } else {
-            // We're not on Windows, so no newline conversion is necessary.
-            for (int i = start; i < end; i++) {
-                char c = chars[i];
-                _writeByte((byte)c);
-                if (c == '\n')
-                    charPos = 0;
-                else
-                    ++charPos;
-            }
-        }
-    }
-
-    @Override
-    public void _writeString(String s) throws ConditionThrowable
-    {
-        final int length = s.length();
-        if (Utilities.isPlatformWindows) {
-            for (int i = 0; i < length; i++) {
-                char c = s.charAt(i);
-                if (c == '\n') {
-                    _writeByte((byte)'\r');
-                    _writeByte((byte)c);
-                    charPos = 0;
-                } else {
-                    _writeByte((byte)c);
-                    ++charPos;
-                }
-            }
-        } else {
-            // We're not on Windows, so no newline conversion is necessary.
-            for (int i = 0; i < length; i++) {
-                char c = s.charAt(i);
-                _writeByte((byte)c);
-                if (c == '\n')
-                    charPos = 0;
-                else
-                    ++charPos;
-            }
-        }
-    }
-
-    @Override
-    public void _writeLine(String s) throws ConditionThrowable
-    {
-        _writeString(s);
-        if (Utilities.isPlatformWindows)
-            _writeByte((byte)'\r');
-        _writeByte((byte)'\n');
-        charPos = 0;
-    }
-
-    // Reads an 8-bit byte.
-    @Override
-    public int _readByte() throws ConditionThrowable
-    {
-        if (inputBuffer != null)
-            return readByteFromBuffer();
-        try {
-            return in.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
-    {
-        if (outputBuffer != null) {
-            writeByteToBuffer((byte)n);
-        } else {
-            try {
-                out.write((byte)n); // Writes an 8-bit byte.
-            }
-            catch (NullPointerException e) {
-                streamNotOutputStream();
-            }
-            catch (IOException e) {
-                error(new StreamError(this, e));
-            }
-        }
-    }
-
-    @Override
-    public void _finishOutput() throws ConditionThrowable
-    {
-        if (outputBuffer != null)
-            flushOutputBuffer();
-    }
-
-    @Override
     public void _clearInput() throws ConditionThrowable
     {
         try {
-            in.seek(in.length());
-            clearInputBuffer();
-        }
-        catch (NullPointerException e) {
-            streamNotInputStream();
+      if (isInputStream) {
+    racf.position(racf.length());
+      } else {
+    streamNotInputStream();
+      }
         }
         catch (IOException e) {
@@ -459 +224 @@
     protected long _getFilePosition() throws ConditionThrowable
     {
-        if (inputBuffer != null) {
-            if (inputBufferFilePosition >= 0)
-                return inputBufferFilePosition + inputBufferOffset;
-        }
-        if (outputBuffer != null)
-            flushOutputBuffer();
-        try {
-            long pos = raf.getFilePointer();
+        try {
+            long pos = racf.position();
             return pos / bytesPerUnit;
         }
@@ -479 +238 @@
     protected boolean _setFilePosition(LispObject arg) throws ConditionThrowable
     {
-        if (outputBuffer != null)
-            flushOutputBuffer();
-        if (inputBuffer != null)
-            clearInputBuffer();
         try {
             long pos;
@@ -488 +243 @@
                 pos = 0;
             else if (arg == Keyword.END)
-                pos = raf.length();
+                pos = racf.length();
             else {
                 long n = Fixnum.getValue(arg); // FIXME arg might be a bignum
                 pos = n * bytesPerUnit;
             }
-            raf.seek(pos);
+            racf.position(pos);
         }
         catch (IOException e) {
@@ -504 +259 @@
     public void _close() throws ConditionThrowable
     {
-        if (outputBuffer != null)
-            flushOutputBuffer();
-        try {
-            raf.close();
+        try {
+            racf.close();
             setOpen(false);
         }
@@ -515 +268 @@
     }
 
-    private int readByteFromBuffer() throws ConditionThrowable
-    {
-        if (inputBufferOffset >= inputBufferCount) {
-            fillInputBuffer();
-            if (inputBufferCount < 0)
-                return -1;
-        }
-        return inputBuffer[inputBufferOffset++] & 0xff;
-    }
-
-    private void fillInputBuffer() throws ConditionThrowable
-    {
-        try {
-            inputBufferFilePosition = in.getFilePointer();
-            inputBufferOffset = 0;
-            inputBufferCount = in.read(inputBuffer, 0, BUFSIZE);
-        }
-        catch (NullPointerException e) {
-            streamNotInputStream();
-        }
-        catch (IOException e) {
-            error(new StreamError(this, e));
-        }
-    }
-
-    private void clearInputBuffer()
-    {
-        inputBufferFilePosition = -1;
-        inputBufferOffset = 0;
-        inputBufferCount = 0;
-    }
-
-    private void writeByteToBuffer(byte b) throws ConditionThrowable
-    {
-        if (outputBufferOffset == BUFSIZE)
-            flushOutputBuffer();
-        outputBuffer[outputBufferOffset++] = b;
-    }
-
-    private void flushOutputBuffer() throws ConditionThrowable
-    {
-        if (outputBufferOffset > 0) {
-            try {
-                out.write(outputBuffer, 0, outputBufferOffset);
-                outputBufferOffset = 0;
-            }
-            catch (NullPointerException e) {
-                streamNotOutputStream();
-            }
-            catch (IOException e) {
-                error(new StreamError(this, e));
-            }
-        }
-    }
-
     @Override
     public String writeToString() throws ConditionThrowable
@@ -576 +274 @@
     }
 
-    // ### make-file-stream pathname namestring element-type direction if-exists => stream
+    // ### make-file-stream pathname namestring element-type direction if-exists external-format => stream
     private static final Primitive MAKE_FILE_STREAM =
         new Primitive("make-file-stream", PACKAGE_SYS, true,
-                      "pathname namestring element-type direction if-exists")
+                      "pathname namestring element-type direction if-exists external-format")
     {
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third, LispObject fourth,
-                                  LispObject fifth)
+                                  LispObject fifth, LispObject sixth)
             throws ConditionThrowable
         {
@@ -604 +302 @@
             LispObject direction = fourth;
             LispObject ifExists = fifth;
+            LispObject externalFormat = sixth;
+            
             if (direction != Keyword.INPUT && direction != Keyword.OUTPUT &&
                 direction != Keyword.IO)
@@ -609 +309 @@
             try {
                 return new FileStream(pathname, namestring.getStringValue(),
-                                      elementType, direction, ifExists);
+                                      elementType, direction, ifExists,
+                                      externalFormat);
             }
             catch (FileNotFoundException e) {

trunk/j/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;
@@ -63 +64 @@
   protected boolean isBinaryStream;
 
+  private boolean pastEnd = false;
   private boolean interactive;
   private boolean open = true;
-
+  
   // Character input.
-  private PushbackReader reader;
+  protected PushbackReader reader;
   protected int offset;
   protected int lineNumber;
@@ -80 +82 @@
    */
   protected int charPos;
-
+  
+  public enum EolStyle {
+    RAW,
+    CR,
+    CRLF,
+    LF
+  }
+
+  static final protected Symbol keywordDefault = Packages.internKeyword("DEFAULT");
+  
+  static final private Symbol keywordCodePage = Packages.internKeyword("CODE-PAGE");
+  static final private Symbol keywordID = Packages.internKeyword("ID");
+
+  static final private Symbol keywordEolStyle = Packages.internKeyword("EOL-STYLE");
+  static final private Symbol keywordCR = Packages.internKeyword("CR");
+  static final private Symbol keywordLF = Packages.internKeyword("LF");
+  static final private Symbol keywordCRLF = Packages.internKeyword("CRLF");
+  static final private Symbol keywordRAW = Packages.internKeyword("RAW");
+    
+  public final static EolStyle platformEolStyle = Utilities.isPlatformWindows ? EolStyle.CRLF : EolStyle.LF;
+    
+  protected EolStyle eolStyle = platformEolStyle;
+  protected char eolChar = (eolStyle == EolStyle.CR) ? '\r' : '\n';
+  protected LispObject externalFormat = LispObject.NIL;
+  protected String encoding = null;
+  protected char lastChar = 0;
+  
   // Binary input.
-  private BufferedInputStream in;
+  private InputStream in;
 
   // Binary output.
-  private BufferedOutputStream out;
+  private OutputStream out;
 
   protected Stream()
@@ -91 +119 @@
   }
 
+  public Stream(InputStream inputStream, LispObject elementType)
+    {
+      this(inputStream, elementType, keywordDefault);
+    }
+
+
   // Input stream constructors.
-  public Stream(InputStream inputStream, LispObject elementType)
+    public Stream(InputStream inputStream, LispObject elementType, LispObject format)
   {
     this.elementType = elementType;
+    setExternalFormat(format);
     if (elementType == Symbol.CHARACTER || elementType == Symbol.BASE_CHAR)
       {
-        isCharacterStream = true;
         InputStreamReader inputStreamReader;
         try
           {
             inputStreamReader =
-              new InputStreamReader(inputStream, "ISO-8859-1");
+                    (encoding == null) ?
+                        new InputStreamReader(inputStream)
+                        : new InputStreamReader(inputStream, encoding);
           }
         catch (java.io.UnsupportedEncodingException e)
@@ -110 +146 @@
               new InputStreamReader(inputStream);
           }
-        reader = new PushbackReader(new BufferedReader(inputStreamReader),
-                                    2);
+        initAsCharacterInputStream(new BufferedReader(inputStreamReader));
       }
     else
       {
         isBinaryStream = true;
-        in = new BufferedInputStream(inputStream);
-      }
-    isInputStream = true;
-    isOutputStream = false;
+        InputStream stream = new BufferedInputStream(inputStream);
+  initAsBinaryInputStream(stream);
+      }
   }
 
@@ -128 +162 @@
   }
 
+  public Stream(OutputStream outputStream, LispObject elementType)
+    {
+      this(outputStream, elementType, keywordDefault);
+    }
+    
   // Output stream constructors.
-  public Stream(OutputStream outputStream, LispObject elementType)
+  public Stream(OutputStream outputStream, LispObject elementType, LispObject format)
   {
     this.elementType = elementType;
+    setExternalFormat(format);
     if (elementType == Symbol.CHARACTER || elementType == Symbol.BASE_CHAR)
       {
-        isCharacterStream = true;
+  Writer w;
         try
           {
-            writer = new OutputStreamWriter(outputStream, "ISO-8859-1");
+            w = (encoding == null) ?
+                new OutputStreamWriter(outputStream)
+                : new OutputStreamWriter(outputStream, encoding);
           }
         catch (java.io.UnsupportedEncodingException e)
           {
             Debug.trace(e);
-            writer = new OutputStreamWriter(outputStream);
-          }
+            w = new OutputStreamWriter(outputStream);
+          }
+  initAsCharacterOutputStream(w);
       }
     else
       {
-        isBinaryStream = true;
-        out = new BufferedOutputStream(outputStream);
-      }
-    isInputStream = false;
-    isOutputStream = true;
+        OutputStream stream = new BufferedOutputStream(outputStream);
+  initAsBinaryOutputStream(stream);
+      }
   }
 
@@ -161 +202 @@
   }
 
+  protected void initAsCharacterInputStream(Reader reader)
+  {
+    if (! (reader instanceof PushbackReader))
+        this.reader = new PushbackReader(reader, 5);
+    else
+        this.reader = (PushbackReader)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;
+  }
+
   public boolean isInputStream() throws ConditionThrowable
   {
@@ -201 +271 @@
   }
 
+  public LispObject getExternalFormat() {
+      return externalFormat;
+  }
+  
+  public String getEncoding() {
+      return encoding;
+  }
+  
+  public void setExternalFormat(LispObject format) {
+    if (format == keywordDefault) {
+      encoding = null;
+      eolStyle = platformEolStyle;
+      eolChar = (eolStyle == EolStyle.CR) ? '\r' : '\n';
+      externalFormat = format;
+      return;
+    }
+      
+    try {
+      LispObject enc;
+      boolean encIsCp = false;
+      
+      if (format instanceof Cons) {
+          // meaning a non-empty list
+          enc = format.car();
+
+          if (enc == keywordCodePage) {
+              encIsCp = true;
+
+              enc = LispObject.getf(format.cdr(), keywordID, null);
+          }
+          
+          LispObject eol = LispObject.getf(format.cdr(), keywordEolStyle, keywordRAW);
+          if (eol == keywordCR)
+              eolStyle = EolStyle.CR;
+          else if (eol == keywordLF)
+              eolStyle = EolStyle.LF;
+          else if (eol == keywordCRLF)
+              eolStyle = EolStyle.CRLF;
+          else if (eol != keywordRAW)
+              //###FIXME: raise an error
+              ;
+          
+      } else
+        enc = format;
+      
+      if (enc.numberp())
+          encoding = enc.toString();
+      else if (enc instanceof AbstractString)
+          encoding = enc.getStringValue();
+      else if (enc == keywordDefault)
+          // This allows the user to use the encoding determined by
+          // Java to be the default for the current environment
+          // while still being able to set other stream options
+          // (e.g. :EOL-STYLE)
+          encoding = null;
+      else if (enc instanceof Symbol)
+          encoding = ((Symbol)enc).getName();
+      else
+          //###FIXME: raise an error!
+          ;
+      
+      if (encIsCp)
+          encoding = "Cp" + encoding;
+    }
+    catch (ConditionThrowable ct) { }
+    
+    eolChar = (eolStyle == EolStyle.CR) ? '\r' : '\n';
+    externalFormat = format;
+  }
+  
   public boolean isOpen()
   {
@@ -1604 +1744 @@
   public LispObject listen() throws ConditionThrowable
   {
-    return _charReady() ? T : NIL;
+    if (pastEnd)
+      return NIL;
+    
+    if (! _charReady())
+      return NIL;
+    
+    int n = _readChar();
+    if (n < 0)
+      return NIL;
+
+    _unreadChar(n);
+    
+    return T;
   }
 
@@ -1652 +1804 @@
   protected int _readChar() throws ConditionThrowable
   {
+    if (pastEnd)
+      return -1;
+    
     try
       {
         int n = reader.read();
+        
+        if (n < 0) {
+            pastEnd = true;
+            return -1;
+        }
+        
         ++offset;
-        if (n == '\r')
-          {
-            if (interactive && Utilities.isPlatformWindows)
-              return _readChar();
-          }
-        if (n == '\n')
+        if (eolStyle == EolStyle.CRLF && n == '\r') {
+            n = _readChar();
+            if (n != '\n') {
+                _unreadChar(n);
+                return '\r';
+            }
+        }
+
+        if (n == eolChar) {
           ++lineNumber;
+          return '\n';
+        }
+
         return n;
       }
@@ -1689 +1856 @@
         reader.unread(n);
         --offset;
-        if (n == '\n')
+        pastEnd = false;
+        if (n == eolChar)
           --lineNumber;
       }
@@ -1737 +1905 @@
     try
       {
-        writer.write(c);
-        if (c == '\n')
-          {
-            writer.flush();
-            charPos = 0;
-          }
-        else
+        if (c == '\n') {
+    if (eolStyle == EolStyle.CRLF && lastChar != '\r')
+              writer.write('\r');
+
+          writer.write(eolChar);
+          lastChar = eolChar;
+          writer.flush();
+          charPos = 0;
+        } else {
+          writer.write(c);
+          lastChar = c;
           ++charPos;
+        }
       }
     catch (NullPointerException e)
@@ -1770 +1943 @@
     try
       {
+        if (eolStyle != EolStyle.RAW) {
+          for (int i = start; i < end; i++)
+            //###FIXME: the number of writes can be greatly reduced by
+            // writing the space between newlines as chunks.
+            _writeChar(chars[i]);
+          return;
+        }
+        
         writer.write(chars, start, end - start);
+        if (start < end)
+          lastChar = chars[end-1];
+        
         int index = -1;
         for (int i = end; i-- > start;)
@@ -1778 +1962 @@
                 index = i;
                 break;
-              }
-          }
+    }
+  }
         if (index < 0)
           {
             // No newline.
             charPos += (end - start);
-          }
+        }
         else
           {
             charPos = end - (index + 1);
-            writer.flush();
-          }
-      }
+              writer.flush();
+      }
+    }
     catch (NullPointerException e)
       {
@@ -1814 +1998 @@
     try
       {
-        writer.write(s);
-        int index = s.lastIndexOf('\n');
-        if (index < 0)
-          charPos += s.length();
-        else
-          {
-            charPos = s.length() - (index + 1);
-            writer.flush();
-          }
+  _writeChars(s.toCharArray(), 0, s.length());
       }
     catch (NullPointerException e)
@@ -1830 +2006 @@
         else
           throw e;
-      }
-    catch (IOException e)
-      {
-        error(new StreamError(this, e));
       }
   }
@@ -1847 +2019 @@
     try
       {
-        writer.write(s);
-        writer.write('\n');
-        writer.flush();
-        charPos = 0;
+        _writeString(s);
+        _writeChar('\n');
       }
     catch (NullPointerException e)
@@ -1856 +2026 @@
         // writer is null
         streamNotCharacterOutputStream();
-      }
-    catch (IOException e)
-      {
-        error(new StreamError(this, e));
       }
   }
@@ -1873 +2039 @@
     try
       {
-        return in.read(); // Reads an 8-bit byte.
+        int n = in.read();
+        if (n < 0)
+          pastEnd = true;
+        
+        return n; // Reads an 8-bit byte.
       }
     catch (IOException e)
@@ -1934 +2104 @@
     if (reader != null)
       {
-        while (_charReady())
-          _readChar();
+        int c = 0;
+        while (_charReady() && (c >= 0))
+          c = _readChar();
       }
     else if (in != null)
@@ -1941 +2112 @@
         try
           {
+            int n = 0;
             while (in.available() > 0)
-              in.read();
+              n = in.read();
+            
+            if (n < 0)
+              pastEnd = true;
           }
         catch (IOException e)
@@ -2007 +2182 @@
         writer.write(sw.toString());
         writer.write('\n');
+        lastChar = '\n';
         writer.flush();
         charPos = 0;

trunk/j/src/org/armedbear/lisp/StringInputStream.java

@@ -34 +34 @@
 package org.armedbear.lisp;
 
+import java.io.StringReader;
+
 public final class StringInputStream extends Stream
 {
-    final String s;
-    final int start;
-    final int end;
-
+    private final StringReader stringReader;
+    private final int start;
+    
     public StringInputStream(String s)
     {
@@ -53 +54 @@
     {
         elementType = Symbol.CHARACTER;
-        isInputStream = true;
-        isOutputStream = false;
-        isCharacterStream = true;
-        isBinaryStream = false;
-        this.s = s;
+        setExternalFormat(keywordDefault);
+        eolStyle = EolStyle.RAW;
+
         this.start = start;
-        this.end = end;
-        offset = start;
+        
+        stringReader = new StringReader(s.substring(start, end));
+        initAsCharacterInputStream(stringReader);
     }
 
+    @Override
     public LispObject typeOf()
     {
@@ -68 +69 @@
     }
 
+    @Override
     public LispObject classOf()
     {
@@ -73 +75 @@
     }
 
+    @Override
     public LispObject typep(LispObject type) throws ConditionThrowable
     {
@@ -86 +89 @@
     }
 
-    public LispObject close(LispObject abort) throws ConditionThrowable
-    {
-        setOpen(false);
-        return T;
-    }
-
-    public LispObject listen()
-    {
-        return offset < end ? T : NIL;
-    }
-
-    protected int _readChar()
-    {
-        if (offset >= end)
-            return -1;
-        int n = s.charAt(offset);
-        ++offset;
-        if (n == '\n')
-            ++lineNumber;
-        return n;
-    }
-
-    protected void _unreadChar(int n)
-    {
-        if (offset > start) {
-            --offset;
-            if (n == '\n')
-                --lineNumber;
-        }
-    }
-
-    protected boolean _charReady()
-    {
-        return true;
-    }
-
+    @Override
     public String toString()
     {
@@ -127 +95 @@
     }
 
+    @Override
+    public int getOffset() {
+        return start + super.getOffset();
+    }
+    
     // ### make-string-input-stream
     // make-string-input-stream string &optional start end => string-stream
@@ -132 +105 @@
         new Primitive("make-string-input-stream", "string &optional start end")
     {
+        @Override
         public LispObject execute(LispObject arg) throws ConditionThrowable
         {
@@ -137 +111 @@
         }
 
+        @Override
         public LispObject execute(LispObject first, LispObject second)
             throws ConditionThrowable
@@ -145 +120 @@
         }
 
+        @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
@@ -162 +138 @@
         new Primitive("string-input-stream-current", PACKAGE_EXT, true, "stream")
     {
+        @Override
         public LispObject execute(LispObject arg) throws ConditionThrowable
         {

trunk/j/src/org/armedbear/lisp/StringOutputStream.java

@@ -48 +48 @@
     {
         this.elementType = elementType;
-        isInputStream = false;
-        isOutputStream = true;
-        isCharacterStream = true;
-        isBinaryStream = false;
-        setWriter(stringWriter = new StringWriter());
+        this.eolStyle = EolStyle.RAW;
+        initAsCharacterOutputStream(stringWriter = new StringWriter());
     }
 
+    @Override
     public LispObject typeOf()
     {
@@ -60 +58 @@
     }
 
+    @Override
     public LispObject classOf()
     {
@@ -65 +64 @@
     }
 
+    @Override
     public LispObject typep(LispObject type) throws ConditionThrowable
     {
@@ -78 +78 @@
     }
 
-    public void _writeChar(char c) throws ConditionThrowable
-    {
-        if (elementType == NIL)
-            writeError();
-        super._writeChar(c);
-    }
-
-    public void _writeChars(char[] chars, int start, int end)
-        throws ConditionThrowable
-    {
-        if (elementType == NIL)
-            writeError();
-        super._writeChars(chars, start, end);
-    }
-
-    public void _writeString(String s) throws ConditionThrowable
-    {
-        if (elementType == NIL)
-            writeError();
-        super._writeString(s);
-    }
-
-    public void _writeLine(String s) throws ConditionThrowable
-    {
-        if (elementType == NIL)
-            writeError();
-        super._writeLine(s);
-    }
-
-    private void writeError() throws ConditionThrowable
-    {
-        error(new TypeError("Attempt to write to a string output stream of element type NIL."));
-    }
-
+    @Override
     protected long _getFilePosition() throws ConditionThrowable
     {
         if (elementType == NIL)
             return 0;
-        return stringWriter.toString().length();
+        return stringWriter.getBuffer().length();
     }
 
@@ -129 +96 @@
     }
 
+    @Override
     public String toString()
     {
@@ -140 +108 @@
                        "element-type")
     {
+        @Override
         public LispObject execute(LispObject arg) throws ConditionThrowable
         {
@@ -151 +120 @@
         new Primitive("get-output-stream-string", "string-output-stream")
     {
+        @Override
         public LispObject execute(LispObject arg) throws ConditionThrowable
         {

trunk/j/src/org/armedbear/lisp/open.lisp

@@ -107 +107 @@
        (if-does-not-exist nil if-does-not-exist-given)
        (external-format :default))
-  (declare (ignore external-format)) ; FIXME
+;  (declare (ignore external-format)) ; FIXME
   (setf element-type (case element-type
                        ((character base-char)
@@ -144 +144 @@
                    :format-control "The file ~S does not exist."
                    :format-arguments (list namestring)))))
-       (make-file-stream pathname namestring element-type :input nil))
+       (make-file-stream pathname namestring element-type :input nil external-format))
       (:probe
        (case if-does-not-exist
@@ -158 +158 @@
           ;; not yet exist." See java.io.File.createNewFile().
           (create-new-file namestring)))
-       (let ((stream (make-file-stream pathname namestring element-type :input nil)))
+       (let ((stream (make-file-stream pathname namestring element-type
+                                       :input nil external-format)))
          (when stream
            (close stream))
@@ -205 +206 @@
                  :format-control "Option not supported: ~S."
                  :format-arguments (list if-exists))))
-       (let ((stream (make-file-stream pathname namestring element-type direction if-exists)))
+       (let ((stream (make-file-stream pathname namestring element-type
+                                       direction if-exists external-format)))
          (unless stream
            (error 'file-error

trunk/j/src/org/armedbear/lisp/socket.lisp

@@ -32 +32 @@
 (in-package "SYSTEM")
 
-(defun get-socket-stream (socket &key (element-type 'character))
-  ":ELEMENT-TYPE must be CHARACTER or (UNSIGNED-BYTE 8); the default is CHARACTER."
+(defun get-socket-stream (socket &key (element-type 'character) (external-format :default))
+  ":ELEMENT-TYPE must be CHARACTER or (UNSIGNED-BYTE 8); the default is CHARACTER.
+EXTERNAL-FORMAT must be of the same format as specified for OPEN."
   (cond ((eq element-type 'character))
         ((equal element-type '(unsigned-byte 8)))
@@ -40 +41 @@
                 :format-control
                 ":ELEMENT-TYPE must be CHARACTER or (UNSIGNED-BYTE 8).")))
-  (%socket-stream socket element-type))
+  (%socket-stream socket element-type external-format))
 
 (defun make-socket (host port)

trunk/j/src/org/armedbear/lisp/socket_stream.java

@@ -41 +41 @@
     private socket_stream()
     {
-        super("%socket-stream", PACKAGE_SYS, false, "socket element-type");
+        super("%socket-stream", PACKAGE_SYS, false, "socket element-type external-format");
     }
 
-    public LispObject execute(LispObject first, LispObject second)
+    public LispObject execute(LispObject first, LispObject second, LispObject third)
         throws ConditionThrowable
     {
@@ -51 +51 @@
         try {
              Stream in =
-                 new Stream(socket.getInputStream(), elementType);
+                 new Stream(socket.getInputStream(), elementType, third);
              Stream out =
-                 new Stream(socket.getOutputStream(), elementType);
+                 new Stream(socket.getOutputStream(), elementType, third);
              return new SocketStream(socket, in, out);
         }