Add Stdio.readByteSync and Stdio.readLineSync.

sdk/lib/io/stdio.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.io;
 
 const int _STDIO_HANDLE_TYPE_TERMINAL = 0;
 const int _STDIO_HANDLE_TYPE_PIPE = 1;
 const int _STDIO_HANDLE_TYPE_FILE = 2;
 const int _STDIO_HANDLE_TYPE_SOCKET = 3;
 const int _STDIO_HANDLE_TYPE_OTHER = 4;
 
+
 class _StdStream extends Stream<List<int>> {
   final Stream<List<int>> _stream;
 
   _StdStream(Stream<List<int>> this._stream);
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {void onError(error),
                                         void onDone(),
                                         bool cancelOnError}) {
     return _stream.listen(
         onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: cancelOnError);
   }
 }
 
+
+class _StdinEventSink {
+  Function add;
+  Function addError;
+  Function close;
+  _StdinEventSink(this.add, this.addError, this.close);
+}
+
+/**
+ * [Stdin] allows both synchronous and asynchronous reads from the standard
+ * input stream.
+ *
+ * Mixing synchronous and asynchronous reads is undefined.
+ */
+class Stdin extends _StdStream {
+  Stdin._(Stream<List<int>> stream) : super(stream);
+
+  /**
+   * Synchronously read a line from stdin. This call will block until a full
+   * line is available. The line will contain the newline character(s).
+   *
+   * If end-of-file is reached, `null` is returned.
+   *
+   * If end-of-file is reached after some data has already been read, that data
+   * is returned.
+   */
+  String readLineSync({Encoding encoding: Encoding.SYSTEM,
+                       bool retainNewlines: false}) {
+    var decoder = new StringDecoder(encoding)._decoder;
+    var line = new StringBuffer();
+    bool end = false;
+    bool lastCharWasCR = false;
+    var sink = new _StdinEventSink(
+        (char) {
+          if (!retainNewlines && char == '\r') {

[Bill Hesse, 2013/07/02 13:08:27]

You need to output 'foo\r' for 'foo\r\r\n'.  Move the \r test below the
lastCharWasCT test.

if (char == '\n') ...
else {
if (lastCharWasCR) ...

if (!retainNewlines && char == '\r')

 return
}
line.write(char);

[Anders Johnsen, 2013/07/02 13:17:15]

Done.

+            lastCharWasCR = true;
+            return;
+          } else if (char == '\n') {
+            end = true;
+            if (!retainNewlines) return;
+          } else if (lastCharWasCR) {
+            lastCharWasCR = false;
+            line.write('\r');
+          }
+          line.write(char);
+        },
+        (error) {
+          throw error;
+        }, () {
+          if (lastCharWasCR) line.write('\r');
+        });
+
+    bool empty = true;
+    while (!end) {
+      int b = readByteSync();
+      if (b >= 0) {
+        empty = false;
+        decoder.handleData([b], sink);
+      } else {
+        decoder.handleDone(sink);
+        break;
+      }
+    }
+
+    if (empty) return null;
+    return line.toString();
+  }
+
+  /**
+   * Synchronously read a byte from stdin. This call will block until a byte is
+   * available.
+   *
+   * If at end of file, -1 is returned.
+   */
+  int readByteSync();
+}
+
+
 class _StdSink implements IOSink {
   final IOSink _sink;
 
   _StdSink(IOSink this._sink);
 
   Encoding get encoding => _sink.encoding;
   void set encoding(Encoding encoding) {
     _sink.encoding = encoding;
   }
   void write(object) => _sink.write(object);
@@ skipping 11 matching lines @@
   static const StdioType TERMINAL = const StdioType._("terminal");
   static const StdioType PIPE = const StdioType._("pipe");
   static const StdioType FILE = const StdioType._("file");
   static const StdioType OTHER = const StdioType._("other");
   final String name;
   const StdioType._(String this.name);
   String toString() => "StdioType: $name";
 }
 
 
-Stream<List<int>> _stdin;
+Stdin _stdin;
 IOSink _stdout;
 IOSink _stderr;
 
 
 Stream<List<int>> get stdin {
   if (_stdin == null) {
     _stdin = _StdIOUtils._getStdioInputStream();
   }
   return _stdin;
 }
@@ skipping 39 matching lines @@
     } catch (e) {
       // Only the interface implemented, _sink not available.
     }
   }
   return StdioType.OTHER;
 }
 
 
 class _StdIOUtils {
   external static IOSink _getStdioOutputStream(int fd);
-  external static Stream<List<int>> _getStdioInputStream();
+  external static Stdio _getStdioInputStream();
   external static int _socketType(nativeSocket);
 }