Implement FileHandle.readline.

Author: jnthn

src/vm/jvm/runtime/org/perl6/nqp/io/FileHandle.java

@@ -20,6 +20,7 @@ public class FileHandle implements IIOClosable, IIOSeekable, IIOEncodable, IIOSy
     private CharsetEncoder enc;
     private CharsetDecoder dec;
     private boolean eof = false;
+    private ByteBuffer readBuffer;
 
     public FileHandle(ThreadContext tc, String filename, String mode) {
         try {
@@ -86,34 +87,88 @@ public void setEncoding(ThreadContext tc, Charset cs) {
         dec = cs.newDecoder();
     }
 
-    public String slurp(ThreadContext tc) {
+    public synchronized String slurp(ThreadContext tc) {
         try {
             // Read in file.
             ArrayList<ByteBuffer> buffers = new ArrayList<ByteBuffer>();
             ByteBuffer curBuffer = ByteBuffer.allocate(32768);
             int total = 0;
             int read;
+            if (readBuffer != null) {
+                buffers.add(ByteBuffer.wrap(readBuffer.array(), readBuffer.position(),
+                    readBuffer.limit() - readBuffer.position()));
+                readBuffer = null;
+            }
             while ((read = chan.read(curBuffer)) != -1) {
+                curBuffer.flip();
                 buffers.add(curBuffer);
                 curBuffer = ByteBuffer.allocate(32768);
                 total += read;
             }
             eof = true;
 
-            // Copy to a single buffer and decode (could be smarter, but need
-            // to be wary as UTF-8 chars may span a buffer boundary).
-            ByteBuffer allBytes = ByteBuffer.allocate(total);
-            for (ByteBuffer bb : buffers)
-                allBytes.put(bb.array(), 0, bb.position());
-            allBytes.rewind();
-            return dec.decode(allBytes).toString();
+            return decodeBuffers(buffers, total);
+        } catch (IOException e) {
+            throw ExceptionHandling.dieInternal(tc, e);
+        }
+    }
+    
+    public synchronized String readline(ThreadContext tc) {
+        try {
+            boolean foundLine = false;
+            ArrayList<ByteBuffer> lineChunks = new ArrayList<ByteBuffer>();
+            int total = 0;
+            
+            while (!foundLine) {
+                /* Ensure we have a buffer available. */
+                if (readBuffer == null) {
+                    readBuffer = ByteBuffer.allocate(32768);
+                    if (chan.read(readBuffer) == -1) {
+                        /* End of file, so what we have is fine. */
+                        eof = true;
+                        foundLine = true;
+                        break;
+                    }
+                    readBuffer.flip();
+                }
+            
+                /* Look for a line end. */
+                int start = readBuffer.position();
+                int end = start;
+                while (!foundLine && end < readBuffer.limit()) {
+                    if (readBuffer.get(end) == '\n')
+                        foundLine = true;
+                    end++;
+                }
+                
+                /* Copy what we found into the results. */
+                byte[] lineBytes = new byte[end - start];
+                readBuffer.get(lineBytes);
+                lineChunks.add(ByteBuffer.wrap(lineBytes));
+                total += lineBytes.length;
+                
+                /* If we didn't find a line, will cross chunk boundary. */
+                if (!foundLine)
+                    readBuffer = null;
+            }
+            
+            if (lineChunks.size() == 1)
+                return dec.decode(lineChunks.get(0)).toString();
+            else
+                return decodeBuffers(lineChunks, total);
         } catch (IOException e) {
             throw ExceptionHandling.dieInternal(tc, e);
         }
     }
 
-    public String readline(ThreadContext tc) {
-        throw new RuntimeException("FileHandle.readline() NYI");
+    private String decodeBuffers(ArrayList<ByteBuffer> buffers, int total) throws IOException {
+        // Copy to a single buffer and decode (could be smarter, but need
+        // to be wary as UTF-8 chars may span a buffer boundary).
+        ByteBuffer allBytes = ByteBuffer.allocate(total);
+        for (ByteBuffer bb : buffers)
+            allBytes.put(bb.array(), 0, bb.limit());
+        allBytes.rewind();
+        return dec.decode(allBytes).toString();
     }
 
     public boolean eof(ThreadContext tc) {