| // 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(this._stream); |
| |
| StreamSubscription<List<int>> listen(void onData(List<int> event), |
| {Function onError, |
| void onDone(), |
| bool cancelOnError}) { |
| return _stream.listen( |
| onData, |
| onError: onError, |
| onDone: onDone, |
| cancelOnError: cancelOnError); |
| } |
| } |
| |
| |
| /** |
| * [Stdin] allows both synchronous and asynchronous reads from the standard |
| * input stream. |
| * |
| * Mixing synchronous and asynchronous reads is undefined. |
| */ |
| class Stdin extends _StdStream implements Stream<List<int>> { |
| Stdin._(Stream<List<int>> stream) : super(stream); |
| |
| /** |
| * Synchronously read a line from stdin. This call will block until a full |
| * line is available. |
| * |
| * The argument [encoding] can be used to changed how the input should be |
| * decoded. Default is [SYSTEM_ENCODING]. |
| * |
| * If [retainNewlines] is `false`, the returned String will not contain the |
| * final newline. If `true`, the returned String will contain the line |
| * terminator. Default is `false`. |
| * |
| * If end-of-file is reached after any bytes have been read from stdin, |
| * that data is returned. |
| * Returns `null` if no bytes preceeded the end of input. |
| */ |
| String readLineSync({Encoding encoding: SYSTEM_ENCODING, |
| bool retainNewlines: false}) { |
| const CR = 13; |
| const LF = 10; |
| final List line = []; |
| // On Windows, if lineMode is disabled, only CR is received. |
| bool crIsNewline = Platform.isWindows && |
| (stdioType(stdin) == StdioType.TERMINAL) && |
| !lineMode; |
| if (retainNewlines) { |
| int byte; |
| do { |
| byte = readByteSync(); |
| if (byte < 0) { |
| break; |
| } |
| line.add(byte); |
| } while (byte != LF && !(byte == CR && crIsNewline)); |
| if (line.isEmpty) { |
| return null; |
| } |
| } else if (crIsNewline) { |
| // CR and LF are both line terminators, neither is retained. |
| while (true) { |
| int byte = readByteSync(); |
| if (byte < 0) { |
| if (line.isEmpty) return null; |
| break; |
| } |
| if (byte == LF || byte == CR) break; |
| line.add(byte); |
| } |
| } else { |
| // Case having to hande CR LF as a single unretained line terminator. |
| outer: while (true) { |
| int byte = readByteSync(); |
| if (byte == LF) break; |
| if (byte == CR) { |
| do { |
| byte = readByteSync(); |
| if (byte == LF) break outer; |
| |
| line.add(CR); |
| } while (byte == CR); |
| // Fall through and handle non-CR character. |
| } |
| if (byte < 0) { |
| if (line.isEmpty) return null; |
| break; |
| } |
| line.add(byte); |
| } |
| } |
| return encoding.decode(line); |
| } |
| |
| /** |
| * Check if echo mode is enabled on [stdin]. |
| */ |
| external bool get echoMode; |
| |
| /** |
| * Enable or disable echo mode on [stdin]. |
| * |
| * If disabled, input from to console will not be echoed. |
| * |
| * Default depends on the parent process, but usually enabled. |
| */ |
| external void set echoMode(bool enabled); |
| |
| /** |
| * Check if line mode is enabled on [stdin]. |
| */ |
| external bool get lineMode; |
| |
| /** |
| * Enable or disable line mode on [stdin]. |
| * |
| * If enabled, characters are delayed until a new-line character is entered. |
| * If disabled, characters will be available as typed. |
| * |
| * Default depends on the parent process, but usually enabled. |
| */ |
| external void set lineMode(bool enabled); |
| |
| /** |
| * Synchronously read a byte from stdin. This call will block until a byte is |
| * available. |
| * |
| * If at end of file, -1 is returned. |
| */ |
| external int readByteSync(); |
| } |
| |
| |
| /** |
| * [Stdout] represents the [IOSink] for either `stdout` or `stderr`. |
| * |
| * It provides a *blocking* `IOSink`, so using this to write will block until |
| * the output is written. |
| * |
| * In some situations this blocking behavior is undesirable as it does not |
| * provide the same non-blocking behavior as dart:io in general exposes. |
| * Use the property [nonBlocking] to get an `IOSink` which has the non-blocking |
| * behavior. |
| * |
| * This class can also be used to check whether `stdout` or `stderr` is |
| * connected to a terminal and query some terminal properties. |
| */ |
| class Stdout extends _StdSink implements IOSink { |
| final int _fd; |
| IOSink _nonBlocking; |
| |
| Stdout._(IOSink sink, this._fd) : super(sink); |
| |
| /** |
| * Returns true if there is a terminal attached to stdout. |
| */ |
| bool get hasTerminal => _hasTerminal(_fd); |
| |
| /** |
| * Get the number of columns of the terminal. |
| * |
| * If no terminal is attached to stdout, a [StdoutException] is thrown. See |
| * [hasTerminal] for more info. |
| */ |
| int get terminalColumns => _terminalColumns(_fd); |
| |
| /** |
| * Get the number of lines of the terminal. |
| * |
| * If no terminal is attached to stdout, a [StdoutException] is thrown. See |
| * [hasTerminal] for more info. |
| */ |
| int get terminalLines => _terminalLines(_fd); |
| |
| external bool _hasTerminal(int fd); |
| external int _terminalColumns(int fd); |
| external int _terminalLines(int fd); |
| |
| /** |
| * Get a non-blocking `IOSink`. |
| */ |
| IOSink get nonBlocking { |
| if (_nonBlocking == null) { |
| _nonBlocking = new IOSink(new _FileStreamConsumer.fromStdio(_fd)); |
| } |
| return _nonBlocking; |
| } |
| } |
| |
| |
| class StdoutException implements IOException { |
| final String message; |
| final OSError osError; |
| |
| const StdoutException(this.message, [this.osError]); |
| |
| String toString() { |
| return "StdoutException: $message${osError == null ? "" : ", $osError"}"; |
| } |
| } |
| |
| class _StdConsumer implements StreamConsumer<List<int>> { |
| final _file; |
| |
| _StdConsumer(int fd) : _file = _File._openStdioSync(fd); |
| |
| Future addStream(Stream<List<int>> stream) { |
| var completer = new Completer(); |
| var sub; |
| sub = stream.listen( |
| (data) { |
| try { |
| _file.writeFromSync(data); |
| } catch (e, s) { |
| sub.cancel(); |
| completer.completeError(e, s); |
| } |
| }, |
| onError: completer.completeError, |
| onDone: completer.complete, |
| cancelOnError: true); |
| return completer.future; |
| } |
| |
| Future close() { |
| _file.closeSync(); |
| return new Future.value(); |
| } |
| } |
| |
| class _StdSink implements IOSink { |
| final IOSink _sink; |
| |
| _StdSink(this._sink); |
| |
| Encoding get encoding => _sink.encoding; |
| void set encoding(Encoding encoding) { |
| _sink.encoding = encoding; |
| } |
| void write(object) => _sink.write(object); |
| void writeln([object = "" ]) => _sink.writeln(object); |
| void writeAll(objects, [sep = ""]) => _sink.writeAll(objects, sep); |
| void add(List<int> data) => _sink.add(data); |
| void addError(error, [StackTrace stackTrace]) => |
| _sink.addError(error, stackTrace); |
| void writeCharCode(int charCode) => _sink.writeCharCode(charCode); |
| Future addStream(Stream<List<int>> stream) => _sink.addStream(stream); |
| Future flush() => _sink.flush(); |
| Future close() => _sink.close(); |
| Future get done => _sink.done; |
| } |
| |
| /// The type of object a standard IO stream is attached to. |
| class StdioType { |
| 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._(this.name); |
| String toString() => "StdioType: $name"; |
| } |
| |
| |
| Stdin _stdin; |
| Stdout _stdout; |
| Stdout _stderr; |
| |
| |
| /// The standard input stream of data read by this program. |
| Stdin get stdin { |
| if (_stdin == null) { |
| _stdin = _StdIOUtils._getStdioInputStream(); |
| } |
| return _stdin; |
| } |
| |
| |
| /// The standard output stream of data written by this program. |
| Stdout get stdout { |
| if (_stdout == null) { |
| _stdout = _StdIOUtils._getStdioOutputStream(1); |
| } |
| return _stdout; |
| } |
| |
| |
| /// The standard output stream of errors written by this program. |
| Stdout get stderr { |
| if (_stderr == null) { |
| _stderr = _StdIOUtils._getStdioOutputStream(2); |
| } |
| return _stderr; |
| } |
| |
| |
| /// For a stream, returns whether it is attached to a file, pipe, terminal, or |
| /// something else. |
| StdioType stdioType(object) { |
| if (object is _StdStream) { |
| object = object._stream; |
| } else if (object == stdout || object == stderr) { |
| switch (_StdIOUtils._getStdioHandleType(object == stdout ? 1 : 2)) { |
| case _STDIO_HANDLE_TYPE_TERMINAL: return StdioType.TERMINAL; |
| case _STDIO_HANDLE_TYPE_PIPE: return StdioType.PIPE; |
| case _STDIO_HANDLE_TYPE_FILE: return StdioType.FILE; |
| } |
| } |
| if (object is _FileStream) { |
| return StdioType.FILE; |
| } |
| if (object is Socket) { |
| switch (_StdIOUtils._socketType(object._nativeSocket)) { |
| case _STDIO_HANDLE_TYPE_TERMINAL: return StdioType.TERMINAL; |
| case _STDIO_HANDLE_TYPE_PIPE: return StdioType.PIPE; |
| case _STDIO_HANDLE_TYPE_FILE: return StdioType.FILE; |
| } |
| } |
| if (object is IOSink) { |
| try { |
| if (object._target is _FileStreamConsumer) { |
| return StdioType.FILE; |
| } |
| } catch (e) { |
| // Only the interface implemented, _sink not available. |
| } |
| } |
| return StdioType.OTHER; |
| } |
| |
| |
| class _StdIOUtils { |
| external static _getStdioOutputStream(int fd); |
| external static Stdin _getStdioInputStream(); |
| external static int _socketType(nativeSocket); |
| external static _getStdioHandleType(int fd); |
| } |