Make nqp::{write,print,say}fh on JVM return number of bytes written.

arnsholt · arnsholt · commit 0713cbbe11f8 · 2013-11-25T21:27:27.000+01:00
This brings NQP/JVM in line with the Parrot and Moar backends, and fixes three
failing tests in t/nqp/19-file-ops.t
diff --git a/src/vm/jvm/QAST/Compiler.nqp b/src/vm/jvm/QAST/Compiler.nqp
@@ -1901,9 +1901,9 @@ QAST::OperationsJAST.map_classlib_core_op('setencoding', $TYPE_OPS, 'setencoding
 QAST::OperationsJAST.map_classlib_core_op('setinputlinesep', $TYPE_OPS, 'setinputlinesep', [$RT_OBJ, $RT_STR], $RT_OBJ, :tc);
 QAST::OperationsJAST.map_classlib_core_op('tellfh', $TYPE_OPS, 'tellfh', [$RT_OBJ], $RT_INT, :tc);
 QAST::OperationsJAST.map_classlib_core_op('readfh', $TYPE_OPS, 'readfh', [$RT_OBJ, $RT_OBJ, $RT_INT], $RT_OBJ, :tc);
-QAST::OperationsJAST.map_classlib_core_op('writefh', $TYPE_OPS, 'writefh', [$RT_OBJ, $RT_OBJ], $RT_OBJ, :tc);
-QAST::OperationsJAST.map_classlib_core_op('printfh', $TYPE_OPS, 'printfh', [$RT_OBJ, $RT_STR], $RT_STR, :tc);
-QAST::OperationsJAST.map_classlib_core_op('sayfh', $TYPE_OPS, 'sayfh', [$RT_OBJ, $RT_STR], $RT_STR, :tc);QAST::OperationsJAST.map_classlib_core_op('sayfh', $TYPE_OPS, 'sayfh', [$RT_OBJ, $RT_STR], $RT_STR, :tc);
+QAST::OperationsJAST.map_classlib_core_op('writefh', $TYPE_OPS, 'writefh', [$RT_OBJ, $RT_OBJ], $RT_INT, :tc);
+QAST::OperationsJAST.map_classlib_core_op('printfh', $TYPE_OPS, 'printfh', [$RT_OBJ, $RT_STR], $RT_INT, :tc);
+QAST::OperationsJAST.map_classlib_core_op('sayfh', $TYPE_OPS, 'sayfh', [$RT_OBJ, $RT_STR], $RT_INT, :tc);QAST::OperationsJAST.map_classlib_core_op('sayfh', $TYPE_OPS, 'sayfh', [$RT_OBJ, $RT_STR], $RT_STR, :tc);
 QAST::OperationsJAST.map_classlib_core_op('flushfh', $TYPE_OPS, 'flushfh', [$RT_OBJ], $RT_OBJ, :tc);QAST::OperationsJAST.map_classlib_core_op('sayfh', $TYPE_OPS, 'sayfh', [$RT_OBJ, $RT_STR], $RT_STR, :tc);
 QAST::OperationsJAST.map_classlib_core_op('readlinefh', $TYPE_OPS, 'readlinefh', [$RT_OBJ], $RT_STR, :tc);
 QAST::OperationsJAST.map_classlib_core_op('readlineintfh', $TYPE_OPS, 'readlineintfh', [$RT_OBJ, $RT_STR], $RT_STR, :tc);
diff --git a/src/vm/jvm/runtime/org/perl6/nqp/io/IIOSyncWritable.java b/src/vm/jvm/runtime/org/perl6/nqp/io/IIOSyncWritable.java
@@ -3,8 +3,8 @@
 import org.perl6.nqp.runtime.ThreadContext;
 
 public interface IIOSyncWritable {
-    public void print(ThreadContext tc, String s);
-    public void say(ThreadContext tc, String s);
-    public void write(ThreadContext tc, byte[] bytes);
+    public long print(ThreadContext tc, String s);
+    public long say(ThreadContext tc, String s);
+    public long write(ThreadContext tc, byte[] bytes);
     public void flush(ThreadContext tc);
 }
diff --git a/src/vm/jvm/runtime/org/perl6/nqp/io/StandardWriteHandle.java b/src/vm/jvm/runtime/org/perl6/nqp/io/StandardWriteHandle.java
@@ -40,23 +40,26 @@ public void setEncoding(ThreadContext tc, Charset cs) {
         dec = cs.newDecoder();
     }
     
-    public void write(ThreadContext tc, byte[] bytes) {
+    public long write(ThreadContext tc, byte[] bytes) {
     	ps.write(bytes, 0, bytes.length);
+        return bytes.length;
     }
     
-    public void print(ThreadContext tc, String s) {
+    public long print(ThreadContext tc, String s) {
         try {
             ByteBuffer buffer = enc.encode(CharBuffer.wrap(s));
             byte[] bytes = buffer.array();
             ps.write(bytes, 0, buffer.limit());
+            return bytes.length;
         } catch (IOException e) {
             throw ExceptionHandling.dieInternal(tc, e);
         }
     }
     
-    public void say(ThreadContext tc, String s) {
-        print(tc, s);
-        print(tc, System.lineSeparator());
+    public long say(ThreadContext tc, String s) {
+        long bytes = print(tc, s);
+        bytes += print(tc, System.lineSeparator());
+        return bytes;
     }
     
     public void flush(ThreadContext tc) {
diff --git a/src/vm/jvm/runtime/org/perl6/nqp/io/SyncHandle.java b/src/vm/jvm/runtime/org/perl6/nqp/io/SyncHandle.java
@@ -199,35 +199,37 @@ public byte[] read(ThreadContext tc, int bytes) {
         }
     }
     
-    public void write(ThreadContext tc, byte[] array) {
+    public long write(ThreadContext tc, byte[] array) {
         ByteBuffer buffer = ByteBuffer.wrap(array);
-        write(tc, buffer);
+        return write(tc, buffer);
     }
      
-    protected void write(ThreadContext tc, ByteBuffer buffer) {
+    protected long write(ThreadContext tc, ByteBuffer buffer) {
         try {
             int toWrite = buffer.limit();
             int written = 0;
             while (written < toWrite) {
                 written += chan.write(buffer);
             }
+            return written;
         } catch (IOException e) {
             throw ExceptionHandling.dieInternal(tc, e);
         }       
     }
     
-    public void print(ThreadContext tc, String s) {
+    public long print(ThreadContext tc, String s) {
         try {
             ByteBuffer buffer = enc.encode(CharBuffer.wrap(s));
-            write(tc, buffer);
+            return write(tc, buffer);
         } catch (IOException e) {
             throw ExceptionHandling.dieInternal(tc, e);
         }
     }
     
-    public void say(ThreadContext tc, String s) {
-        print(tc, s);
-        print(tc, System.lineSeparator());
+    public long say(ThreadContext tc, String s) {
+        long bytes = print(tc, s);
+        bytes += print(tc, System.lineSeparator());
+        return bytes;
     }
 
     public void setInputLineSeparator(ThreadContext tc, String sep) {
diff --git a/src/vm/jvm/runtime/org/perl6/nqp/runtime/Ops.java b/src/vm/jvm/runtime/org/perl6/nqp/runtime/Ops.java
@@ -517,14 +517,15 @@ public static SixModelObject readfh(SixModelObject io, SixModelObject res, long
         }
     }
     
-    public static SixModelObject writefh(SixModelObject obj, SixModelObject buf, ThreadContext tc) {
+    public static long writefh(SixModelObject obj, SixModelObject buf, ThreadContext tc) {
         ByteBuffer bb = decode8(buf, tc);
+        long written;
         if (obj instanceof IOHandleInstance) {
             IOHandleInstance h = (IOHandleInstance)obj;
             byte[] bytesToWrite = new byte[bb.limit()];
             bb.get(bytesToWrite);
             if (h.handle instanceof IIOSyncWritable)
-                ((IIOSyncWritable)h.handle).write(tc, bytesToWrite);
+                written = ((IIOSyncWritable)h.handle).write(tc, bytesToWrite);
             else
                 throw ExceptionHandling.dieInternal(tc,
                     "This handle does not support write");
@@ -533,14 +534,15 @@ public static SixModelObject writefh(SixModelObject obj, SixModelObject buf, Thr
             throw ExceptionHandling.dieInternal(tc,
                 "writefh requires an object with the IOHandle REPR");
         }
-        return buf;
+        return written;
     }
     
-    public static String printfh(SixModelObject obj, String data, ThreadContext tc) {
+    public static long printfh(SixModelObject obj, String data, ThreadContext tc) {
+        long written;
         if (obj instanceof IOHandleInstance) {
             IOHandleInstance h = (IOHandleInstance)obj;
             if (h.handle instanceof IIOSyncWritable)
-                ((IIOSyncWritable)h.handle).print(tc, data);
+                written = ((IIOSyncWritable)h.handle).print(tc, data);
             else
                 throw ExceptionHandling.dieInternal(tc,
                     "This handle does not support print");
@@ -549,14 +551,15 @@ public static String printfh(SixModelObject obj, String data, ThreadContext tc)
             throw ExceptionHandling.dieInternal(tc,
                 "printfh requires an object with the IOHandle REPR");
         }
-        return data;
+        return written;
     }
     
-    public static String sayfh(SixModelObject obj, String data, ThreadContext tc) {
+    public static long sayfh(SixModelObject obj, String data, ThreadContext tc) {
+        long written;
         if (obj instanceof IOHandleInstance) {
             IOHandleInstance h = (IOHandleInstance)obj;
             if (h.handle instanceof IIOSyncWritable)
-                ((IIOSyncWritable)h.handle).say(tc, data);
+                written = ((IIOSyncWritable)h.handle).say(tc, data);
             else
                 throw ExceptionHandling.dieInternal(tc,
                     "This handle does not support say");
@@ -565,7 +568,7 @@ public static String sayfh(SixModelObject obj, String data, ThreadContext tc) {
             throw ExceptionHandling.dieInternal(tc,
                 "sayfh requires an object with the IOHandle REPR");
         }
-        return data;
+        return written;
     }
     
     public static SixModelObject flushfh(SixModelObject obj, ThreadContext tc) {

Original file line number	Diff line number	Diff line change
`@@ -40,23 +40,26 @@ public void setEncoding(ThreadContext tc, Charset cs) {`
`40`	`40`	`dec = cs.newDecoder();`
`41`	`41`	`}`
`42`	`42`
`43`		`- public void write(ThreadContext tc, byte[] bytes) {`
	`43`	`+ public long write(ThreadContext tc, byte[] bytes) {`
`44`	`44`	`ps.write(bytes, 0, bytes.length);`
	`45`	`+ return bytes.length;`
`45`	`46`	`}`
`46`	`47`
`47`		`- public void print(ThreadContext tc, String s) {`
	`48`	`+ public long print(ThreadContext tc, String s) {`
`48`	`49`	`try {`
`49`	`50`	`ByteBuffer buffer = enc.encode(CharBuffer.wrap(s));`
`50`	`51`	`byte[] bytes = buffer.array();`
`51`	`52`	`ps.write(bytes, 0, buffer.limit());`
	`53`	`+ return bytes.length;`
`52`	`54`	`} catch (IOException e) {`
`53`	`55`	`throw ExceptionHandling.dieInternal(tc, e);`
`54`	`56`	`}`
`55`	`57`	`}`
`56`	`58`
`57`		`- public void say(ThreadContext tc, String s) {`
`58`		`- print(tc, s);`
`59`		`- print(tc, System.lineSeparator());`
	`59`	`+ public long say(ThreadContext tc, String s) {`
	`60`	`+ long bytes = print(tc, s);`
	`61`	`+ bytes += print(tc, System.lineSeparator());`
	`62`	`+ return bytes;`
`60`	`63`	`}`
`61`	`64`
`62`	`65`	`public void flush(ThreadContext tc) {`
Original file line number	Diff line number	Diff line change
`@@ -199,35 +199,37 @@ public byte[] read(ThreadContext tc, int bytes) {`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`
`202`		`- public void write(ThreadContext tc, byte[] array) {`
	`202`	`+ public long write(ThreadContext tc, byte[] array) {`
`203`	`203`	`ByteBuffer buffer = ByteBuffer.wrap(array);`
`204`		`- write(tc, buffer);`
	`204`	`+ return write(tc, buffer);`
`205`	`205`	`}`
`206`	`206`
`207`		`- protected void write(ThreadContext tc, ByteBuffer buffer) {`
	`207`	`+ protected long write(ThreadContext tc, ByteBuffer buffer) {`
`208`	`208`	`try {`
`209`	`209`	`int toWrite = buffer.limit();`
`210`	`210`	`int written = 0;`
`211`	`211`	`while (written < toWrite) {`
`212`	`212`	`written += chan.write(buffer);`
`213`	`213`	`}`
	`214`	`+ return written;`
`214`	`215`	`} catch (IOException e) {`
`215`	`216`	`throw ExceptionHandling.dieInternal(tc, e);`
`216`	`217`	`}`
`217`	`218`	`}`
`218`	`219`
`219`		`- public void print(ThreadContext tc, String s) {`
	`220`	`+ public long print(ThreadContext tc, String s) {`
`220`	`221`	`try {`
`221`	`222`	`ByteBuffer buffer = enc.encode(CharBuffer.wrap(s));`
`222`		`- write(tc, buffer);`
	`223`	`+ return write(tc, buffer);`
`223`	`224`	`} catch (IOException e) {`
`224`	`225`	`throw ExceptionHandling.dieInternal(tc, e);`
`225`	`226`	`}`
`226`	`227`	`}`
`227`	`228`
`228`		`- public void say(ThreadContext tc, String s) {`
`229`		`- print(tc, s);`
`230`		`- print(tc, System.lineSeparator());`
	`229`	`+ public long say(ThreadContext tc, String s) {`
	`230`	`+ long bytes = print(tc, s);`
	`231`	`+ bytes += print(tc, System.lineSeparator());`
	`232`	`+ return bytes;`
`231`	`233`	`}`
`232`	`234`
`233`	`235`	`public void setInputLineSeparator(ThreadContext tc, String sep) {`