sdlang uses lexer.d which uses stream.d which phobos is to drop 2016-10

* stream & its depends:
  src/undead/stream.d
  src/undead/internal/file.d
  src/undead/doformat.d

* https://github.com/DigitalMars/undeaD/blob/master/src/undead/

1 files changed, 3071 insertions, 0 deletions

diff --git a/src/undead/stream.d b/src/undead/stream.d
new file mode 100644
index 0000000..e31b381
--- /dev/null
+++ b/src/undead/stream.d
@@ -0,0 +1,3071 @@
+// Written in the D programming language
+
+/**
+ * $(RED Deprecated: This module is considered out-dated and not up to Phobos'
+ *       current standards.)
+ *
+ * Source:    $(PHOBOSSRC std/_stream.d)
+ * Macros:
+ *      WIKI = Phobos/StdStream
+ */
+
+/*
+ * Copyright (c) 2001-2005
+ * Pavel "EvilOne" Minayev
+ *  with buffering and endian support added by Ben Hinkle
+ *  with buffered readLine performance improvements by Dave Fladebo
+ *  with opApply inspired by (and mostly copied from) Regan Heath
+ *  with bug fixes and MemoryStream/SliceStream enhancements by Derick Eddington
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Author makes no representations about
+ * the suitability of this software for any purpose. It is provided
+ * "as is" without express or implied warranty.
+ */
+module undead.stream;
+
+import std.internal.cstring;
+
+/* Class structure:
+ *  InputStream       interface for reading
+ *  OutputStream      interface for writing
+ *  Stream            abstract base of stream implementations
+ *    File            an OS file stream
+ *    FilterStream    a base-class for wrappers around another stream
+ *      BufferedStream  a buffered stream wrapping another stream
+ *        BufferedFile  a buffered File
+ *      EndianStream    a wrapper stream for swapping byte order and BOMs
+ *      SliceStream     a portion of another stream
+ *    MemoryStream    a stream entirely stored in main memory
+ *    TArrayStream    a stream wrapping an array-like buffer
+ */
+
+/// A base class for stream exceptions.
+class StreamException: Exception {
+  /// Construct a StreamException with given error message.
+  this(string msg) { super(msg); }
+}
+
+/// Thrown when unable to read data from Stream.
+class ReadException: StreamException {
+  /// Construct a ReadException with given error message.
+  this(string msg) { super(msg); }
+}
+
+/// Thrown when unable to write data to Stream.
+class WriteException: StreamException {
+  /// Construct a WriteException with given error message.
+  this(string msg) { super(msg); }
+}
+
+/// Thrown when unable to move Stream pointer.
+class SeekException: StreamException {
+  /// Construct a SeekException with given error message.
+  this(string msg) { super(msg); }
+}
+
+// seek whence...
+enum SeekPos {
+  Set,
+  Current,
+  End
+}
+
+private {
+  import std.conv;
+  import std.algorithm;
+  import std.ascii;
+  //import std.format;
+  import std.system;    // for Endian enumeration
+  import std.utf;
+  import core.bitop; // for bswap
+  import core.vararg;
+  import std.file;
+  import undead.internal.file;
+  import undead.doformat;
+}
+
+/// InputStream is the interface for readable streams.
+
+interface InputStream {
+
+  /***
+   * Read exactly size bytes into the buffer.
+   *
+   * Throws a ReadException if it is not correct.
+   */
+  void readExact(void* buffer, size_t size);
+
+  /***
+   * Read a block of data big enough to fill the given array buffer.
+   *
+   * Returns: the actual number of bytes read. Unfilled bytes are not modified.
+   */
+  size_t read(ubyte[] buffer);
+
+  /***
+   * Read a basic type or counted string.
+   *
+   * Throw a ReadException if it could not be read.
+   * Outside of byte, ubyte, and char, the format is
+   * implementation-specific and should not be used except as opposite actions
+   * to write.
+   */
+  void read(out byte x);
+  void read(out ubyte x);       /// ditto
+  void read(out short x);       /// ditto
+  void read(out ushort x);      /// ditto
+  void read(out int x);         /// ditto
+  void read(out uint x);        /// ditto
+  void read(out long x);        /// ditto
+  void read(out ulong x);       /// ditto
+  void read(out float x);       /// ditto
+  void read(out double x);      /// ditto
+  void read(out real x);        /// ditto
+  void read(out ifloat x);      /// ditto
+  void read(out idouble x);     /// ditto
+  void read(out ireal x);       /// ditto
+  void read(out cfloat x);      /// ditto
+  void read(out cdouble x);     /// ditto
+  void read(out creal x);       /// ditto
+  void read(out char x);        /// ditto
+  void read(out wchar x);       /// ditto
+  void read(out dchar x);       /// ditto
+
+  // reads a string, written earlier by write()
+  void read(out char[] s);      /// ditto
+
+  // reads a Unicode string, written earlier by write()
+  void read(out wchar[] s);     /// ditto
+
+  /***
+   * Read a line that is terminated with some combination of carriage return and
+   * line feed or end-of-file.
+   *
+   * The terminators are not included. The wchar version
+   * is identical. The optional buffer parameter is filled (reallocating
+   * it if necessary) and a slice of the result is returned.
+   */
+  char[] readLine();
+  char[] readLine(char[] result);       /// ditto
+  wchar[] readLineW();                  /// ditto
+  wchar[] readLineW(wchar[] result);    /// ditto
+
+  /***
+   * Overload foreach statements to read the stream line by line and call the
+   * supplied delegate with each line or with each line with line number.
+   *
+   * The string passed in line may be reused between calls to the delegate.
+   * Line numbering starts at 1.
+   * Breaking out of the foreach will leave the stream
+   * position at the beginning of the next line to be read.
+   * For example, to echo a file line-by-line with line numbers run:
+   * ------------------------------------
+   * Stream file = new BufferedFile("sample.txt");
+   * foreach(ulong n, char[] line; file)
+   * {
+   *     writefln("line %d: %s", n, line);
+   * }
+   * file.close();
+   * ------------------------------------
+   */
+
+  // iterate through the stream line-by-line
+  int opApply(scope int delegate(ref char[] line) dg);
+  int opApply(scope int delegate(ref ulong n, ref char[] line) dg);  /// ditto
+  int opApply(scope int delegate(ref wchar[] line) dg);            /// ditto
+  int opApply(scope int delegate(ref ulong n, ref wchar[] line) dg); /// ditto
+
+  /// Read a string of the given length,
+  /// throwing ReadException if there was a problem.
+  char[] readString(size_t length);
+
+  /***
+   * Read a string of the given length, throwing ReadException if there was a
+   * problem.
+   *
+   * The file format is implementation-specific and should not be used
+   * except as opposite actions to <b>write</b>.
+   */
+
+  wchar[] readStringW(size_t length);
+
+
+  /***
+   * Read and return the next character in the stream.
+   *
+   * This is the only method that will handle ungetc properly.
+   * getcw's format is implementation-specific.
+   * If EOF is reached then getc returns char.init and getcw returns wchar.init.
+   */
+
+  char getc();
+  wchar getcw(); /// ditto
+
+  /***
+   * Push a character back onto the stream.
+   *
+   * They will be returned in first-in last-out order from getc/getcw.
+   * Only has effect on further calls to getc() and getcw().
+   */
+  char ungetc(char c);
+  wchar ungetcw(wchar c); /// ditto
+
+  /***
+   * Scan a string from the input using a similar form to C's scanf
+   * and <a href="std_format.html">std.format</a>.
+   *
+   * An argument of type string is interpreted as a format string.
+   * All other arguments must be pointer types.
+   * If a format string is not present a default will be supplied computed from
+   * the base type of the pointer type. An argument of type string* is filled
+   * (possibly with appending characters) and a slice of the result is assigned
+   * back into the argument. For example the following readf statements
+   * are equivalent:
+   * --------------------------
+   * int x;
+   * double y;
+   * string s;
+   * file.readf(&x, " hello ", &y, &s);
+   * file.readf("%d hello %f %s", &x, &y, &s);
+   * file.readf("%d hello %f", &x, &y, "%s", &s);
+   * --------------------------
+   */
+  int vreadf(TypeInfo[] arguments, va_list args);
+  int readf(...); /// ditto
+
+  /// Retrieve the number of bytes available for immediate reading.
+  @property size_t available();
+
+  /***
+   * Return whether the current file position is the same as the end of the
+   * file.
+   *
+   * This does not require actually reading past the end, as with stdio. For
+   * non-seekable streams this might only return true after attempting to read
+   * past the end.
+   */
+
+  @property bool eof();
+
+  @property bool isOpen();        /// Return true if the stream is currently open.
+}
+
+/// Interface for writable streams.
+interface OutputStream {
+
+  /***
+   * Write exactly size bytes from buffer, or throw a WriteException if that
+   * could not be done.
+   */
+  void writeExact(const void* buffer, size_t size);
+
+  /***
+   * Write as much of the buffer as possible,
+   * returning the number of bytes written.
+   */
+  size_t write(const(ubyte)[] buffer);
+
+  /***
+   * Write a basic type.
+   *
+   * Outside of byte, ubyte, and char, the format is implementation-specific
+   * and should only be used in conjunction with read.
+   * Throw WriteException on error.
+   */
+  void write(byte x);
+  void write(ubyte x);          /// ditto
+  void write(short x);          /// ditto
+  void write(ushort x);         /// ditto
+  void write(int x);            /// ditto
+  void write(uint x);           /// ditto
+  void write(long x);           /// ditto
+  void write(ulong x);          /// ditto
+  void write(float x);          /// ditto
+  void write(double x);         /// ditto
+  void write(real x);           /// ditto
+  void write(ifloat x);         /// ditto
+  void write(idouble x);        /// ditto
+  void write(ireal x);          /// ditto
+  void write(cfloat x);         /// ditto
+  void write(cdouble x);        /// ditto
+  void write(creal x);          /// ditto
+  void write(char x);           /// ditto
+  void write(wchar x);          /// ditto
+  void write(dchar x);          /// ditto
+
+  /***
+   * Writes a string, together with its length.
+   *
+   * The format is implementation-specific
+   * and should only be used in conjunction with read.
+   * Throw WriteException on error.
+   */
+    void write(const(char)[] s);
+    void write(const(wchar)[] s); /// ditto
+
+  /***
+   * Write a line of text,
+   * appending the line with an operating-system-specific line ending.
+   *
+   * Throws WriteException on error.
+   */
+  void writeLine(const(char)[] s);
+
+  /***
+   * Write a line of text,
+   * appending the line with an operating-system-specific line ending.
+   *
+   * The format is implementation-specific.
+   * Throws WriteException on error.
+   */
+    void writeLineW(const(wchar)[] s);
+
+  /***
+   * Write a string of text.
+   *
+   * Throws WriteException if it could not be fully written.
+   */
+    void writeString(const(char)[] s);
+
+  /***
+   * Write a string of text.
+   *
+   * The format is implementation-specific.
+   * Throws WriteException if it could not be fully written.
+   */
+  void writeStringW(const(wchar)[] s);
+
+  /***
+   * Print a formatted string into the stream using printf-style syntax,
+   * returning the number of bytes written.
+   */
+  size_t vprintf(const(char)[] format, va_list args);
+  size_t printf(const(char)[] format, ...);    /// ditto
+
+  /***
+   * Print a formatted string into the stream using writef-style syntax.
+   * References: <a href="std_format.html">std.format</a>.
+   * Returns: self to chain with other stream commands like flush.
+   */
+  OutputStream writef(...);
+  OutputStream writefln(...); /// ditto
+  OutputStream writefx(TypeInfo[] arguments, va_list argptr, int newline = false);  /// ditto
+
+  void flush(); /// Flush pending output if appropriate.
+  void close(); /// Close the stream, flushing output if appropriate.
+  @property bool isOpen(); /// Return true if the stream is currently open.
+}
+
+
+/***
+ * Stream is the base abstract class from which the other stream classes derive.
+ *
+ * Stream's byte order is the format native to the computer.
+ *
+ * Reading:
+ * These methods require that the readable flag be set.
+ * Problems with reading result in a ReadException being thrown.
+ * Stream implements the InputStream interface in addition to the
+ * readBlock method.
+ *
+ * Writing:
+ * These methods require that the writeable flag be set. Problems with writing
+ * result in a WriteException being thrown. Stream implements the OutputStream
+ * interface in addition to the following methods:
+ * writeBlock
+ * copyFrom
+ * copyFrom
+ *
+ * Seeking:
+ * These methods require that the seekable flag be set.
+ * Problems with seeking result in a SeekException being thrown.
+ * seek, seekSet, seekCur, seekEnd, position, size, toString, toHash
+ */
+
+// not really abstract, but its instances will do nothing useful
+class Stream : InputStream, OutputStream {
+  private import std.string, std.digest.crc, core.stdc.stdlib, core.stdc.stdio;
+
+  // stream abilities
+  bool readable = false;        /// Indicates whether this stream can be read from.
+  bool writeable = false;       /// Indicates whether this stream can be written to.
+  bool seekable = false;        /// Indicates whether this stream can be seeked within.
+  protected bool isopen = true; /// Indicates whether this stream is open.
+
+  protected bool readEOF = false; /** Indicates whether this stream is at eof
+                                   * after the last read attempt.
+                                   */
+
+  protected bool prevCr = false; /** For a non-seekable stream indicates that
+                                  * the last readLine or readLineW ended on a
+                                  * '\r' character.
+                                  */
+
+  this() {}
+
+  /***
+   * Read up to size bytes into the buffer and return the number of bytes
+   * actually read. A return value of 0 indicates end-of-file.
+   */
+  abstract size_t readBlock(void* buffer, size_t size);
+
+  // reads block of data of specified size,
+  // throws ReadException on error
+  void readExact(void* buffer, size_t size) {
+    for(;;) {
+      if (!size) return;
+      size_t readsize = readBlock(buffer, size); // return 0 on eof
+      if (readsize == 0) break;
+      buffer += readsize;
+      size -= readsize;
+    }
+    if (size != 0)
+      throw new ReadException("not enough data in stream");
+  }
+
+  // reads block of data big enough to fill the given
+  // array, returns actual number of bytes read
+  size_t read(ubyte[] buffer) {
+    return readBlock(buffer.ptr, buffer.length);
+  }
+
+  // read a single value of desired type,
+  // throw ReadException on error
+  void read(out byte x) { readExact(&x, x.sizeof); }
+  void read(out ubyte x) { readExact(&x, x.sizeof); }
+  void read(out short x) { readExact(&x, x.sizeof); }
+  void read(out ushort x) { readExact(&x, x.sizeof); }
+  void read(out int x) { readExact(&x, x.sizeof); }
+  void read(out uint x) { readExact(&x, x.sizeof); }
+  void read(out long x) { readExact(&x, x.sizeof); }
+  void read(out ulong x) { readExact(&x, x.sizeof); }
+  void read(out float x) { readExact(&x, x.sizeof); }
+  void read(out double x) { readExact(&x, x.sizeof); }
+  void read(out real x) { readExact(&x, x.sizeof); }
+  void read(out ifloat x) { readExact(&x, x.sizeof); }
+  void read(out idouble x) { readExact(&x, x.sizeof); }
+  void read(out ireal x) { readExact(&x, x.sizeof); }
+  void read(out cfloat x) { readExact(&x, x.sizeof); }
+  void read(out cdouble x) { readExact(&x, x.sizeof); }
+  void read(out creal x) { readExact(&x, x.sizeof); }
+  void read(out char x) { readExact(&x, x.sizeof); }
+  void read(out wchar x) { readExact(&x, x.sizeof); }
+  void read(out dchar x) { readExact(&x, x.sizeof); }
+
+  // reads a string, written earlier by write()
+  void read(out char[] s) {
+    size_t len;
+    read(len);
+    s = readString(len);
+  }
+
+  // reads a Unicode string, written earlier by write()
+  void read(out wchar[] s) {
+    size_t len;
+    read(len);
+    s = readStringW(len);
+  }
+
+  // reads a line, terminated by either CR, LF, CR/LF, or EOF
+  char[] readLine() {
+    return readLine(null);
+  }
+
+  // reads a line, terminated by either CR, LF, CR/LF, or EOF
+  // reusing the memory in buffer if result will fit and otherwise
+  // allocates a new string
+  char[] readLine(char[] result) {
+    size_t strlen = 0;
+    char ch = getc();
+    while (readable) {
+      switch (ch) {
+      case '\r':
+        if (seekable) {
+          ch = getc();
+          if (ch != '\n')
+            ungetc(ch);
+        } else {
+          prevCr = true;
+        }
+        goto case;
+      case '\n':
+      case char.init:
+        result.length = strlen;
+        return result;
+
+      default:
+        if (strlen < result.length) {
+          result[strlen] = ch;
+        } else {
+          result ~= ch;
+        }
+        strlen++;
+      }
+      ch = getc();
+    }
+    result.length = strlen;
+    return result;
+  }
+
+  // reads a Unicode line, terminated by either CR, LF, CR/LF,
+  // or EOF; pretty much the same as the above, working with
+  // wchars rather than chars
+  wchar[] readLineW() {
+    return readLineW(null);
+  }
+
+  // reads a Unicode line, terminated by either CR, LF, CR/LF,
+  // or EOF;
+  // fills supplied buffer if line fits and otherwise allocates a new string.
+  wchar[] readLineW(wchar[] result) {
+    size_t strlen = 0;
+    wchar c = getcw();
+    while (readable) {
+      switch (c) {
+      case '\r':
+        if (seekable) {
+          c = getcw();
+          if (c != '\n')
+            ungetcw(c);
+        } else {
+          prevCr = true;
+        }
+        goto case;
+      case '\n':
+      case wchar.init:
+        result.length = strlen;
+        return result;
+
+      default:
+        if (strlen < result.length) {
+          result[strlen] = c;
+        } else {
+          result ~= c;
+        }
+        strlen++;
+      }
+      c = getcw();
+    }
+    result.length = strlen;
+    return result;
+  }
+
+  // iterate through the stream line-by-line - due to Regan Heath
+  int opApply(scope int delegate(ref char[] line) dg) {
+    int res = 0;
+    char[128] buf;
+    while (!eof) {
+      char[] line = readLine(buf);
+      res = dg(line);
+      if (res) break;
+    }
+    return res;
+  }
+
+  // iterate through the stream line-by-line with line count and string
+  int opApply(scope int delegate(ref ulong n, ref char[] line) dg) {
+    int res = 0;
+    ulong n = 1;
+    char[128] buf;
+    while (!eof) {
+      auto line = readLine(buf);
+      res = dg(n,line);
+      if (res) break;
+      n++;
+    }
+    return res;
+  }
+
+  // iterate through the stream line-by-line with wchar[]
+  int opApply(scope int delegate(ref wchar[] line) dg) {
+    int res = 0;
+    wchar[128] buf;
+    while (!eof) {
+      auto line = readLineW(buf);
+      res = dg(line);
+      if (res) break;
+    }
+    return res;
+  }
+
+  // iterate through the stream line-by-line with line count and wchar[]
+  int opApply(scope int delegate(ref ulong n, ref wchar[] line) dg) {
+    int res = 0;
+    ulong n = 1;
+    wchar[128] buf;
+    while (!eof) {
+      auto line = readLineW(buf);
+      res = dg(n,line);
+      if (res) break;
+      n++;
+    }
+    return res;
+  }
+
+  // reads a string of given length, throws
+  // ReadException on error
+  char[] readString(size_t length) {
+    char[] result = new char[length];
+    readExact(result.ptr, length);
+    return result;
+  }
+
+  // reads a Unicode string of given length, throws
+  // ReadException on error
+  wchar[] readStringW(size_t length) {
+    auto result = new wchar[length];
+    readExact(result.ptr, result.length * wchar.sizeof);
+    return result;
+  }
+
+  // unget buffer
+  private wchar[] unget;
+  final bool ungetAvailable() { return unget.length > 1; }
+
+  // reads and returns next character from the stream,
+  // handles characters pushed back by ungetc()
+  // returns char.init on eof.
+  char getc() {
+    char c;
+    if (prevCr) {
+      prevCr = false;
+      c = getc();
+      if (c != '\n')
+        return c;
+    }
+    if (unget.length > 1) {
+      c = cast(char)unget[unget.length - 1];
+      unget.length = unget.length - 1;
+    } else {
+      readBlock(&c,1);
+    }
+    return c;
+  }
+
+  // reads and returns next Unicode character from the
+  // stream, handles characters pushed back by ungetc()
+  // returns wchar.init on eof.
+  wchar getcw() {
+    wchar c;
+    if (prevCr) {
+      prevCr = false;
+      c = getcw();
+      if (c != '\n')
+        return c;
+    }
+    if (unget.length > 1) {
+      c = unget[unget.length - 1];
+      unget.length = unget.length - 1;
+    } else {
+      void* buf = &c;
+      size_t n = readBlock(buf,2);
+      if (n == 1 && readBlock(buf+1,1) == 0)
+          throw new ReadException("not enough data in stream");
+    }
+    return c;
+  }
+
+  // pushes back character c into the stream; only has
+  // effect on further calls to getc() and getcw()
+  char ungetc(char c) {
+    if (c == c.init) return c;
+    // first byte is a dummy so that we never set length to 0
+    if (unget.length == 0)
+      unget.length = 1;
+    unget ~= c;
+    return c;
+  }
+
+  // pushes back Unicode character c into the stream; only
+  // has effect on further calls to getc() and getcw()
+  wchar ungetcw(wchar c) {
+    if (c == c.init) return c;
+    // first byte is a dummy so that we never set length to 0
+    if (unget.length == 0)
+      unget.length = 1;
+    unget ~= c;
+    return c;
+  }
+
+  int vreadf(TypeInfo[] arguments, va_list args) {
+    string fmt;
+    int j = 0;
+    int count = 0, i = 0;
+    char c;
+    bool firstCharacter = true;
+    while ((j < arguments.length || i < fmt.length) && !eof) {
+      if(firstCharacter) {
+        c = getc();
+        firstCharacter = false;
+      }
+      if (fmt.length == 0 || i == fmt.length) {
+        i = 0;
+        if (arguments[j] is typeid(string) || arguments[j] is typeid(char[])
+            || arguments[j] is typeid(const(char)[])) {
+          fmt = va_arg!(string)(args);
+          j++;
+          continue;
+        } else if (arguments[j] is typeid(int*) ||
+                   arguments[j] is typeid(byte*) ||
+                   arguments[j] is typeid(short*) ||
+                   arguments[j] is typeid(long*)) {
+          fmt = "%d";
+        } else if (arguments[j] is typeid(uint*) ||
+                   arguments[j] is typeid(ubyte*) ||
+                   arguments[j] is typeid(ushort*) ||
+                   arguments[j] is typeid(ulong*)) {
+          fmt = "%d";
+        } else if (arguments[j] is typeid(float*) ||
+                   arguments[j] is typeid(double*) ||
+                   arguments[j] is typeid(real*)) {
+          fmt = "%f";
+        } else if (arguments[j] is typeid(char[]*) ||
+                   arguments[j] is typeid(wchar[]*) ||
+                   arguments[j] is typeid(dchar[]*)) {
+          fmt = "%s";
+        } else if (arguments[j] is typeid(char*)) {
+          fmt = "%c";
+        }
+      }
+      if (fmt[i] == '%') {      // a field
+        i++;
+        bool suppress = false;
+        if (fmt[i] == '*') {    // suppress assignment
+          suppress = true;
+          i++;
+        }
+        // read field width
+        int width = 0;
+        while (isDigit(fmt[i])) {
+          width = width * 10 + (fmt[i] - '0');
+          i++;
+        }
+        if (width == 0)
+          width = -1;
+        // skip any modifier if present
+        if (fmt[i] == 'h' || fmt[i] == 'l' || fmt[i] == 'L')
+          i++;
+        // check the typechar and act accordingly
+        switch (fmt[i]) {
+        case 'd':       // decimal/hexadecimal/octal integer
+        case 'D':
+        case 'u':
+        case 'U':
+        case 'o':
+        case 'O':
+        case 'x':
+        case 'X':
+        case 'i':
+        case 'I':
+          {
+            while (isWhite(c)) {
+              c = getc();
+              count++;
+            }
+            bool neg = false;
+            if (c == '-') {
+              neg = true;
+              c = getc();
+              count++;
+            } else if (c == '+') {
+              c = getc();
+              count++;
+            }
+            char ifmt = cast(char)(fmt[i] | 0x20);
+            if (ifmt == 'i')    { // undetermined base
+              if (c == '0')     { // octal or hex
+                c = getc();
+                count++;
+                if (c == 'x' || c == 'X')       { // hex
+                  ifmt = 'x';
+                  c = getc();
+                  count++;
+                } else {        // octal
+                  ifmt = 'o';
+                }
+              }
+              else      // decimal
+                ifmt = 'd';
+            }
+            long n = 0;
+            switch (ifmt)
+            {
+                case 'd':       // decimal
+                case 'u': {
+                  while (isDigit(c) && width) {
+                    n = n * 10 + (c - '0');
+                    width--;
+                    c = getc();
+                    count++;
+                  }
+                } break;
+
+                case 'o': {     // octal
+                  while (isOctalDigit(c) && width) {
+                    n = n * 8 + (c - '0');
+                    width--;
+                    c = getc();
+                    count++;
+                  }
+                } break;
+
+                case 'x': {     // hexadecimal
+                  while (isHexDigit(c) && width) {
+                    n *= 0x10;
+                    if (isDigit(c))
+                      n += c - '0';
+                    else
+                      n += 0xA + (c | 0x20) - 'a';
+                    width--;
+                    c = getc();
+                    count++;
+                  }
+                } break;
+
+                default:
+                    assert(0);
+            }
+            if (neg)
+              n = -n;
+            if (arguments[j] is typeid(int*)) {
+              int* p = va_arg!(int*)(args);
+              *p = cast(int)n;
+            } else if (arguments[j] is typeid(short*)) {
+              short* p = va_arg!(short*)(args);
+              *p = cast(short)n;
+            } else if (arguments[j] is typeid(byte*)) {
+              byte* p = va_arg!(byte*)(args);
+              *p = cast(byte)n;
+            } else if (arguments[j] is typeid(long*)) {
+              long* p = va_arg!(long*)(args);
+              *p = n;
+            } else if (arguments[j] is typeid(uint*)) {
+              uint* p = va_arg!(uint*)(args);
+              *p = cast(uint)n;
+            } else if (arguments[j] is typeid(ushort*)) {
+              ushort* p = va_arg!(ushort*)(args);
+              *p = cast(ushort)n;
+            } else if (arguments[j] is typeid(ubyte*)) {
+              ubyte* p = va_arg!(ubyte*)(args);
+              *p = cast(ubyte)n;
+            } else if (arguments[j] is typeid(ulong*)) {
+              ulong* p = va_arg!(ulong*)(args);
+              *p = cast(ulong)n;
+            }
+            j++;
+            i++;
+          } break;
+
+        case 'f':       // float
+        case 'F':
+        case 'e':
+        case 'E':
+        case 'g':
+        case 'G':
+          {
+            while (isWhite(c)) {
+              c = getc();
+              count++;
+            }
+            bool neg = false;
+            if (c == '-') {
+              neg = true;
+              c = getc();
+              count++;
+            } else if (c == '+') {
+              c = getc();
+              count++;
+            }
+            real r = 0;
+            while (isDigit(c) && width) {
+              r = r * 10 + (c - '0');
+              width--;
+              c = getc();
+              count++;
+            }
+            if (width && c == '.') {
+              width--;
+              c = getc();
+              count++;
+              double frac = 1;
+              while (isDigit(c) && width) {
+                r = r * 10 + (c - '0');
+                frac *= 10;
+                width--;
+                c = getc();
+                count++;
+              }
+              r /= frac;
+            }
+            if (width && (c == 'e' || c == 'E')) {
+              width--;
+              c = getc();
+              count++;
+              if (width) {
+                bool expneg = false;
+                if (c == '-') {
+                  expneg = true;
+                  width--;
+                  c = getc();
+                  count++;
+                } else if (c == '+') {
+                  width--;
+                  c = getc();
+                  count++;
+                }
+                real exp = 0;
+                while (isDigit(c) && width) {
+                  exp = exp * 10 + (c - '0');
+                  width--;
+                  c = getc();
+                  count++;
+                }
+                if (expneg) {
+                  while (exp--)
+                    r /= 10;
+                } else {
+                  while (exp--)
+                    r *= 10;
+                }
+              }
+            }
+            if(width && (c == 'n' || c == 'N')) {
+              width--;
+              c = getc();
+              count++;
+              if(width && (c == 'a' || c == 'A')) {
+                width--;
+                c = getc();
+                count++;
+                if(width && (c == 'n' || c == 'N')) {
+                  width--;
+                  c = getc();
+                  count++;
+                  r = real.nan;
+                }
+              }
+            }
+            if(width && (c == 'i' || c == 'I')) {
+              width--;
+              c = getc();
+              count++;
+              if(width && (c == 'n' || c == 'N')) {
+                width--;
+                c = getc();
+                count++;
+                if(width && (c == 'f' || c == 'F')) {
+                  width--;
+                  c = getc();
+                  count++;
+                  r = real.infinity;
+                }
+              }
+            }
+            if (neg)
+              r = -r;
+            if (arguments[j] is typeid(float*)) {
+              float* p = va_arg!(float*)(args);
+              *p = r;
+            } else if (arguments[j] is typeid(double*)) {
+              double* p = va_arg!(double*)(args);
+              *p = r;
+            } else if (arguments[j] is typeid(real*)) {
+              real* p = va_arg!(real*)(args);
+              *p = r;
+            }
+            j++;
+            i++;
+          } break;
+
+        case 's': {     // string
+          while (isWhite(c)) {
+            c = getc();
+            count++;
+          }
+          char[] s;
+          char[]* p;
+          size_t strlen;
+          if (arguments[j] is typeid(char[]*)) {
+            p = va_arg!(char[]*)(args);
+            s = *p;
+          }
+          while (!isWhite(c) && c != char.init) {
+            if (strlen < s.length) {
+              s[strlen] = c;
+            } else {
+              s ~= c;
+            }
+            strlen++;
+            c = getc();
+            count++;
+          }
+          s = s[0 .. strlen];
+          if (arguments[j] is typeid(char[]*)) {
+            *p = s;
+          } else if (arguments[j] is typeid(char*)) {
+            s ~= 0;
+            auto q = va_arg!(char*)(args);
+            q[0 .. s.length] = s[];
+          } else if (arguments[j] is typeid(wchar[]*)) {
+            auto q = va_arg!(const(wchar)[]*)(args);
+            *q = toUTF16(s);
+          } else if (arguments[j] is typeid(dchar[]*)) {
+            auto q = va_arg!(const(dchar)[]*)(args);
+            *q = toUTF32(s);
+          }
+          j++;
+          i++;
+        } break;
+
+        case 'c': {     // character(s)
+          char* s = va_arg!(char*)(args);
+          if (width < 0)
+            width = 1;
+          else
+            while (isWhite(c)) {
+            c = getc();
+            count++;
+          }
+          while (width-- && !eof) {
+            *(s++) = c;
+            c = getc();
+            count++;
+          }
+          j++;
+          i++;
+        } break;
+
+        case 'n': {     // number of chars read so far
+          int* p = va_arg!(int*)(args);
+          *p = count;
+          j++;
+          i++;
+        } break;
+
+        default:        // read character as is
+          goto nws;
+        }
+      } else if (isWhite(fmt[i])) {     // skip whitespace
+        while (isWhite(c))
+          c = getc();
+        i++;
+      } else {  // read character as is
+      nws:
+        if (fmt[i] != c)
+          break;
+        c = getc();
+        i++;
+      }
+    }
+    ungetc(c);
+    return count;
+  }
+
+  int readf(...) {
+    return vreadf(_arguments, _argptr);
+  }
+
+  // returns estimated number of bytes available for immediate reading
+  @property size_t available() { return 0; }
+
+  /***
+   * Write up to size bytes from buffer in the stream, returning the actual
+   * number of bytes that were written.
+   */
+  abstract size_t writeBlock(const void* buffer, size_t size);
+
+  // writes block of data of specified size,
+  // throws WriteException on error
+  void writeExact(const void* buffer, size_t size) {
+    const(void)* p = buffer;
+    for(;;) {
+      if (!size) return;
+      size_t writesize = writeBlock(p, size);
+      if (writesize == 0) break;
+      p += writesize;
+      size -= writesize;
+    }
+    if (size != 0)
+      throw new WriteException("unable to write to stream");
+  }
+
+  // writes the given array of bytes, returns
+  // actual number of bytes written
+  size_t write(const(ubyte)[] buffer) {
+    return writeBlock(buffer.ptr, buffer.length);
+  }
+
+  // write a single value of desired type,
+  // throw WriteException on error
+  void write(byte x) { writeExact(&x, x.sizeof); }
+  void write(ubyte x) { writeExact(&x, x.sizeof); }
+  void write(short x) { writeExact(&x, x.sizeof); }
+  void write(ushort x) { writeExact(&x, x.sizeof); }
+  void write(int x) { writeExact(&x, x.sizeof); }
+  void write(uint x) { writeExact(&x, x.sizeof); }
+  void write(long x) { writeExact(&x, x.sizeof); }
+  void write(ulong x) { writeExact(&x, x.sizeof); }
+  void write(float x) { writeExact(&x, x.sizeof); }
+  void write(double x) { writeExact(&x, x.sizeof); }
+  void write(real x) { writeExact(&x, x.sizeof); }
+  void write(ifloat x) { writeExact(&x, x.sizeof); }
+  void write(idouble x) { writeExact(&x, x.sizeof); }
+  void write(ireal x) { writeExact(&x, x.sizeof); }
+  void write(cfloat x) { writeExact(&x, x.sizeof); }
+  void write(cdouble x) { writeExact(&x, x.sizeof); }
+  void write(creal x) { writeExact(&x, x.sizeof); }
+  void write(char x) { writeExact(&x, x.sizeof); }
+  void write(wchar x) { writeExact(&x, x.sizeof); }
+  void write(dchar x) { writeExact(&x, x.sizeof); }
+
+  // writes a string, together with its length
+  void write(const(char)[] s) {
+    write(s.length);
+    writeString(s);
+  }
+
+  // writes a Unicode string, together with its length
+  void write(const(wchar)[] s) {
+    write(s.length);
+    writeStringW(s);
+  }
+
+  // writes a line, throws WriteException on error
+  void writeLine(const(char)[] s) {
+    writeString(s);
+    version (Windows)
+      writeString("\r\n");
+    else version (Mac)
+      writeString("\r");
+    else
+      writeString("\n");
+  }
+
+  // writes a Unicode line, throws WriteException on error
+  void writeLineW(const(wchar)[] s) {
+    writeStringW(s);
+    version (Windows)
+      writeStringW("\r\n");
+    else version (Mac)
+      writeStringW("\r");
+    else
+      writeStringW("\n");
+  }
+
+  // writes a string, throws WriteException on error
+  void writeString(const(char)[] s) {
+    writeExact(s.ptr, s.length);
+  }
+
+  // writes a Unicode string, throws WriteException on error
+  void writeStringW(const(wchar)[] s) {
+    writeExact(s.ptr, s.length * wchar.sizeof);
+  }
+
+  // writes data to stream using vprintf() syntax,
+  // returns number of bytes written
+  size_t vprintf(const(char)[] format, va_list args) {
+    // shamelessly stolen from OutBuffer,
+    // by Walter's permission
+    char[1024] buffer;
+    char* p = buffer.ptr;
+    // Can't use `tempCString()` here as it will result in compilation error:
+    // "cannot mix core.std.stdlib.alloca() and exception handling".
+    auto f = toStringz(format);
+    size_t psize = buffer.length;
+    size_t count;
+    while (true) {
+      version (Windows) {
+        count = vsnprintf(p, psize, f, args);
+        if (count != -1)
+          break;
+        psize *= 2;
+        p = cast(char*) alloca(psize);
+      } else version (Posix) {
+        count = vsnprintf(p, psize, f, args);
+        if (count == -1)
+          psize *= 2;
+        else if (count >= psize)
+          psize = count + 1;
+        else
+          break;
+        p = cast(char*) alloca(psize);
+      } else
+          throw new Exception("unsupported platform");
+    }
+    writeString(p[0 .. count]);
+    return count;
+  }
+
+  // writes data to stream using printf() syntax,
+  // returns number of bytes written
+  size_t printf(const(char)[] format, ...) {
+    va_list ap;
+    va_start(ap, format);
+    auto result = vprintf(format, ap);
+    va_end(ap);
+    return result;
+  }
+
+  private void doFormatCallback(dchar c) {
+    char[4] buf;
+    auto b = std.utf.toUTF8(buf, c);
+    writeString(b);
+  }
+
+  // writes data to stream using writef() syntax,
+  OutputStream writef(...) {
+    return writefx(_arguments,_argptr,0);
+  }
+
+  // writes data with trailing newline
+  OutputStream writefln(...) {
+    return writefx(_arguments,_argptr,1);
+  }
+
+  // writes data with optional trailing newline
+  OutputStream writefx(TypeInfo[] arguments, va_list argptr, int newline=false) {
+    doFormat(&doFormatCallback,arguments,argptr);
+    if (newline)
+      writeLine("");
+    return this;
+  }
+
+  /***
+   * Copies all data from s into this stream.
+   * This may throw ReadException or WriteException on failure.
+   * This restores the file position of s so that it is unchanged.
+   */
+  void copyFrom(Stream s) {
+    if (seekable) {
+      ulong pos = s.position;
+      s.position = 0;
+      copyFrom(s, s.size);
+      s.position = pos;
+    } else {
+      ubyte[128] buf;
+      while (!s.eof) {
+        size_t m = s.readBlock(buf.ptr, buf.length);
+        writeExact(buf.ptr, m);
+      }
+    }
+  }
+
+  /***
+   * Copy a specified number of bytes from the given stream into this one.
+   * This may throw ReadException or WriteException on failure.
+   * Unlike the previous form, this doesn't restore the file position of s.
+   */
+  void copyFrom(Stream s, ulong count) {
+    ubyte[128] buf;
+    while (count > 0) {
+      size_t n = cast(size_t)(count<buf.length ? count : buf.length);
+      s.readExact(buf.ptr, n);
+      writeExact(buf.ptr, n);
+      count -= n;
+    }
+  }
+
+  /***
+   * Change the current position of the stream. whence is either SeekPos.Set, in
+   which case the offset is an absolute index from the beginning of the stream,
+   SeekPos.Current, in which case the offset is a delta from the current
+   position, or SeekPos.End, in which case the offset is a delta from the end of
+   the stream (negative or zero offsets only make sense in that case). This
+   returns the new file position.
+   */
+  abstract ulong seek(long offset, SeekPos whence);
+
+  /***
+   * Aliases for their normal seek counterparts.
+   */
+  ulong seekSet(long offset) { return seek (offset, SeekPos.Set); }
+  ulong seekCur(long offset) { return seek (offset, SeekPos.Current); } /// ditto
+  ulong seekEnd(long offset) { return seek (offset, SeekPos.End); }     /// ditto
+
+  /***
+   * Sets file position. Equivalent to calling seek(pos, SeekPos.Set).
+   */
+  @property void position(ulong pos) { seek(cast(long)pos, SeekPos.Set); }
+
+  /***
+   * Returns current file position. Equivalent to seek(0, SeekPos.Current).
+   */
+  @property ulong position() { return seek(0, SeekPos.Current); }
+
+  /***
+   * Retrieve the size of the stream in bytes.
+   * The stream must be seekable or a SeekException is thrown.
+   */
+  @property ulong size() {
+    assertSeekable();
+    ulong pos = position, result = seek(0, SeekPos.End);
+    position = pos;
+    return result;
+  }
+
+  // returns true if end of stream is reached, false otherwise
+  @property bool eof() {
+    // for unseekable streams we only know the end when we read it
+    if (readEOF && !ungetAvailable())
+      return true;
+    else if (seekable)
+      return position == size;
+    else
+      return false;
+  }
+
+  // returns true if the stream is open
+  @property bool isOpen() { return isopen; }
+
+  // flush the buffer if writeable
+  void flush() {
+    if (unget.length > 1)
+      unget.length = 1; // keep at least 1 so that data ptr stays
+  }
+
+  // close the stream somehow; the default just flushes the buffer
+  void close() {
+    if (isopen)
+      flush();
+    readEOF = prevCr = isopen = readable = writeable = seekable = false;
+  }
+
+  /***
+   * Read the entire stream and return it as a string.
+   * If the stream is not seekable the contents from the current position to eof
+   * is read and returned.
+   */
+  override string toString() {
+    if (!readable)
+      return super.toString();
+    try
+    {
+        size_t pos;
+        size_t rdlen;
+        size_t blockSize;
+        char[] result;
+        if (seekable) {
+          ulong orig_pos = position;
+          scope(exit) position = orig_pos;
+          position = 0;
+          blockSize = cast(size_t)size;
+          result = new char[blockSize];
+          while (blockSize > 0) {
+            rdlen = readBlock(&result[pos], blockSize);
+            pos += rdlen;
+            blockSize -= rdlen;
+          }
+        } else {
+          blockSize = 4096;
+          result = new char[blockSize];
+          while ((rdlen = readBlock(&result[pos], blockSize)) > 0) {
+            pos += rdlen;
+            blockSize += rdlen;
+            result.length = result.length + blockSize;
+          }
+        }
+        return cast(string) result[0 .. pos];
+    }
+    catch (Throwable)
+    {
+        return super.toString();
+    }
+  }
+
+  /***
+   * Get a hash of the stream by reading each byte and using it in a CRC-32
+   * checksum.
+   */
+  override size_t toHash() @trusted {
+    if (!readable || !seekable)
+      return super.toHash();
+    try
+    {
+        ulong pos = position;
+        scope(exit) position = pos;
+        CRC32 crc;
+        crc.start();
+        position = 0;
+        ulong len = size;
+        for (ulong i = 0; i < len; i++)
+        {
+          ubyte c;
+          read(c);
+          crc.put(c);
+        }
+
+        union resUnion
+        {
+            size_t hash;
+            ubyte[4] crcVal;
+        }
+        resUnion res;
+        res.crcVal = crc.finish();
+        return res.hash;
+    }
+    catch (Throwable)
+    {
+        return super.toHash();
+    }
+  }
+
+  // helper for checking that the stream is readable
+  final protected void assertReadable() {
+    if (!readable)
+      throw new ReadException("Stream is not readable");
+  }
+  // helper for checking that the stream is writeable
+  final protected void assertWriteable() {
+    if (!writeable)
+      throw new WriteException("Stream is not writeable");
+  }
+  // helper for checking that the stream is seekable
+  final protected void assertSeekable() {
+    if (!seekable)
+      throw new SeekException("Stream is not seekable");
+  }
+
+  unittest { // unit test for Issue 3363
+    import std.stdio;
+    immutable fileName = undead.internal.file.deleteme ~ "-issue3363.txt";
+    auto w = File(fileName, "w");
+    scope (exit) remove(fileName.ptr);
+    w.write("one two three");
+    w.close();
+    auto r = File(fileName, "r");
+    const(char)[] constChar;
+    string str;
+    char[] chars;
+    r.readf("%s %s %s", &constChar, &str, &chars);
+    assert (constChar == "one", constChar);
+    assert (str == "two", str);
+    assert (chars == "three", chars);
+  }
+
+  unittest { //unit tests for Issue 1668
+    void tryFloatRoundtrip(float x, string fmt = "", string pad = "") {
+      auto s = new MemoryStream();
+      s.writef(fmt, x, pad);
+      s.position = 0;
+
+      float f;
+      assert(s.readf(&f));
+      assert(x == f || (x != x && f != f)); //either equal or both NaN
+    }
+
+    tryFloatRoundtrip(1.0);
+    tryFloatRoundtrip(1.0, "%f");
+    tryFloatRoundtrip(1.0, "", " ");
+    tryFloatRoundtrip(1.0, "%f", " ");
+
+    tryFloatRoundtrip(3.14);
+    tryFloatRoundtrip(3.14, "%f");
+    tryFloatRoundtrip(3.14, "", " ");
+    tryFloatRoundtrip(3.14, "%f", " ");
+
+    float nan = float.nan;
+    tryFloatRoundtrip(nan);
+    tryFloatRoundtrip(nan, "%f");
+    tryFloatRoundtrip(nan, "", " ");
+    tryFloatRoundtrip(nan, "%f", " ");
+
+    float inf = 1.0/0.0;
+    tryFloatRoundtrip(inf);
+    tryFloatRoundtrip(inf, "%f");
+    tryFloatRoundtrip(inf, "", " ");
+    tryFloatRoundtrip(inf, "%f", " ");
+
+    tryFloatRoundtrip(-inf);
+    tryFloatRoundtrip(-inf,"%f");
+    tryFloatRoundtrip(-inf, "", " ");
+    tryFloatRoundtrip(-inf, "%f", " ");
+  }
+}
+
+/***
+ * A base class for streams that wrap a source stream with additional
+ * functionality.
+ *
+ * The method implementations forward read/write/seek calls to the
+ * source stream. A FilterStream can change the position of the source stream
+ * arbitrarily and may not keep the source stream state in sync with the
+ * FilterStream, even upon flushing and closing the FilterStream. It is
+ * recommended to not make any assumptions about the state of the source position
+ * and read/write state after a FilterStream has acted upon it. Specifc subclasses
+ * of FilterStream should document how they modify the source stream and if any
+ * invariants hold true between the source and filter.
+ */
+class FilterStream : Stream {
+  private Stream s;              // source stream
+
+  /// Property indicating when this stream closes to close the source stream as
+  /// well.
+  /// Defaults to true.
+  bool nestClose = true;
+
+  /// Construct a FilterStream for the given source.
+  this(Stream source) {
+    s = source;
+    resetSource();
+  }
+
+  // source getter/setter
+
+  /***
+   * Get the current source stream.
+   */
+  final Stream source(){return s;}
+
+  /***
+   * Set the current source stream.
+   *
+   * Setting the source stream closes this stream before attaching the new
+   * source. Attaching an open stream reopens this stream and resets the stream
+   * state.
+   */
+  void source(Stream s) {
+    close();
+    this.s = s;
+    resetSource();
+  }
+
+  /***
+   * Indicates the source stream changed state and that this stream should reset
+   * any readable, writeable, seekable, isopen and buffering flags.
+   */
+  void resetSource() {
+    if (s !is null) {
+      readable = s.readable;
+      writeable = s.writeable;
+      seekable = s.seekable;
+      isopen = s.isOpen;
+    } else {
+      readable = writeable = seekable = false;
+      isopen = false;
+    }
+    readEOF = prevCr = false;
+  }
+
+  // read from source
+  override size_t readBlock(void* buffer, size_t size) {
+    size_t res = s.readBlock(buffer,size);
+    readEOF = res == 0;
+    return res;
+  }
+
+  // write to source
+  override size_t writeBlock(const void* buffer, size_t size) {
+    return s.writeBlock(buffer,size);
+  }
+
+  // close stream
+  override void close() {
+    if (isopen) {
+      super.close();
+      if (nestClose)
+        s.close();
+    }
+  }
+
+  // seek on source
+  override ulong seek(long offset, SeekPos whence) {
+    readEOF = false;
+    return s.seek(offset,whence);
+  }
+
+  override @property size_t available() { return s.available; }
+  override void flush() { super.flush(); s.flush(); }
+}
+
+/***
+ * This subclass is for buffering a source stream.
+ *
+ * A buffered stream must be
+ * closed explicitly to ensure the final buffer content is written to the source
+ * stream. The source stream position is changed according to the block size so
+ * reading or writing to the BufferedStream may not change the source stream
+ * position by the same amount.
+ */
+class BufferedStream : FilterStream {
+  ubyte[] buffer;       // buffer, if any
+  size_t bufferCurPos;    // current position in buffer
+  size_t bufferLen;       // amount of data in buffer
+  bool bufferDirty = false;
+  size_t bufferSourcePos; // position in buffer of source stream position
+  ulong streamPos;      // absolute position in source stream
+
+  /* Example of relationship between fields:
+   *
+   *  s             ...01234567890123456789012EOF
+   *  buffer                |--                     --|
+   *  bufferCurPos                       |
+   *  bufferLen             |--            --|
+   *  bufferSourcePos                        |
+   *
+   */
+
+  invariant() {
+    assert(bufferSourcePos <= bufferLen);
+    assert(bufferCurPos <= bufferLen);
+    assert(bufferLen <= buffer.length);
+  }
+
+  enum size_t DefaultBufferSize = 8192;
+
+  /***
+   * Create a buffered stream for the stream source with the buffer size
+   * bufferSize.
+   */
+  this(Stream source, size_t bufferSize = DefaultBufferSize) {
+    super(source);
+    if (bufferSize)
+      buffer = new ubyte[bufferSize];
+  }
+
+  override protected void resetSource() {
+    super.resetSource();
+    streamPos = 0;
+    bufferLen = bufferSourcePos = bufferCurPos = 0;
+    bufferDirty = false;
+  }
+
+  // reads block of data of specified size using any buffered data
+  // returns actual number of bytes read
+  override size_t readBlock(void* result, size_t len) {
+    if (len == 0) return 0;
+
+    assertReadable();
+
+    ubyte* outbuf = cast(ubyte*)result;
+    size_t readsize = 0;
+
+    if (bufferCurPos + len < bufferLen) {
+      // buffer has all the data so copy it
+      outbuf[0 .. len] = buffer[bufferCurPos .. bufferCurPos+len];
+      bufferCurPos += len;
+      readsize = len;
+      goto ExitRead;
+    }
+
+    readsize = bufferLen - bufferCurPos;
+    if (readsize > 0) {
+      // buffer has some data so copy what is left
+      outbuf[0 .. readsize] = buffer[bufferCurPos .. bufferLen];
+      outbuf += readsize;
+      bufferCurPos += readsize;
+      len -= readsize;
+    }
+
+    flush();
+
+    if (len >= buffer.length) {
+      // buffer can't hold the data so fill output buffer directly
+      size_t siz = super.readBlock(outbuf, len);
+      readsize += siz;
+      streamPos += siz;
+    } else {
+      // read a new block into buffer
+        bufferLen = super.readBlock(buffer.ptr, buffer.length);
+        if (bufferLen < len) len = bufferLen;
+        outbuf[0 .. len] = buffer[0 .. len];
+        bufferSourcePos = bufferLen;
+        streamPos += bufferLen;
+        bufferCurPos = len;
+        readsize += len;
+    }
+
+  ExitRead:
+    return readsize;
+  }
+
+  // write block of data of specified size
+  // returns actual number of bytes written
+  override size_t writeBlock(const void* result, size_t len) {
+    assertWriteable();
+
+    ubyte* buf = cast(ubyte*)result;
+    size_t writesize = 0;
+
+    if (bufferLen == 0) {
+      // buffer is empty so fill it if possible
+      if ((len < buffer.length) && (readable)) {
+        // read in data if the buffer is currently empty
+        bufferLen = s.readBlock(buffer.ptr, buffer.length);
+        bufferSourcePos = bufferLen;
+        streamPos += bufferLen;
+
+      } else if (len >= buffer.length) {
+        // buffer can't hold the data so write it directly and exit
+        writesize = s.writeBlock(buf,len);
+        streamPos += writesize;
+        goto ExitWrite;
+      }
+    }
+
+    if (bufferCurPos + len <= buffer.length) {
+      // buffer has space for all the data so copy it and exit
+      buffer[bufferCurPos .. bufferCurPos+len] = buf[0 .. len];
+      bufferCurPos += len;
+      bufferLen = bufferCurPos > bufferLen ? bufferCurPos : bufferLen;
+      writesize = len;
+      bufferDirty = true;
+      goto ExitWrite;
+    }
+
+    writesize = buffer.length - bufferCurPos;
+    if (writesize > 0) {
+      // buffer can take some data
+      buffer[bufferCurPos .. buffer.length] = buf[0 .. writesize];
+      bufferCurPos = bufferLen = buffer.length;
+      buf += writesize;
+      len -= writesize;
+      bufferDirty = true;
+    }
+
+    assert(bufferCurPos == buffer.length);
+    assert(bufferLen == buffer.length);
+
+    flush();
+
+    writesize += writeBlock(buf,len);
+
+  ExitWrite:
+    return writesize;
+  }
+
+  override ulong seek(long offset, SeekPos whence) {
+    assertSeekable();
+
+    if ((whence != SeekPos.Current) ||
+        (offset + bufferCurPos < 0) ||
+        (offset + bufferCurPos >= bufferLen)) {
+      flush();
+      streamPos = s.seek(offset,whence);
+    } else {
+      bufferCurPos += offset;
+    }
+    readEOF = false;
+    return streamPos-bufferSourcePos+bufferCurPos;
+  }
+
+  // Buffered readLine - Dave Fladebo
+  // reads a line, terminated by either CR, LF, CR/LF, or EOF
+  // reusing the memory in buffer if result will fit, otherwise
+  // will reallocate (using concatenation)
+  template TreadLine(T) {
+      T[] readLine(T[] inBuffer)
+      {
+          size_t    lineSize = 0;
+          bool    haveCR = false;
+          T       c = '\0';
+          size_t    idx = 0;
+          ubyte*  pc = cast(ubyte*)&c;
+
+        L0:
+          for(;;) {
+              size_t start = bufferCurPos;
+            L1:
+              foreach(ubyte b; buffer[start .. bufferLen]) {
+                  bufferCurPos++;
+                  pc[idx] = b;
+                  if(idx < T.sizeof - 1) {
+                      idx++;
+                      continue L1;
+                  } else {
+                      idx = 0;
+                  }
+                  if(c == '\n' || haveCR) {
+                      if(haveCR && c != '\n') bufferCurPos--;
+                      break L0;
+                  } else {
+                      if(c == '\r') {
+                          haveCR = true;
+                      } else {
+                          if(lineSize < inBuffer.length) {
+                              inBuffer[lineSize] = c;
+                          } else {
+                              inBuffer ~= c;
+                          }
+                          lineSize++;
+                      }
+                  }
+              }
+              flush();
+              size_t res = super.readBlock(buffer.ptr, buffer.length);
+              if(!res) break L0; // EOF
+              bufferSourcePos = bufferLen = res;
+              streamPos += res;
+          }
+          return inBuffer[0 .. lineSize];
+      }
+  } // template TreadLine(T)
+
+  override char[] readLine(char[] inBuffer) {
+    if (ungetAvailable())
+      return super.readLine(inBuffer);
+    else
+      return TreadLine!(char).readLine(inBuffer);
+  }
+  alias readLine = Stream.readLine;
+
+  override wchar[] readLineW(wchar[] inBuffer) {
+    if (ungetAvailable())
+      return super.readLineW(inBuffer);
+    else
+      return TreadLine!(wchar).readLine(inBuffer);
+  }
+  alias readLineW = Stream.readLineW;
+
+  override void flush()
+  out {
+    assert(bufferCurPos == 0);
+    assert(bufferSourcePos == 0);
+    assert(bufferLen == 0);
+  }
+  body {
+    if (writeable && bufferDirty) {
+      if (bufferSourcePos != 0 && seekable) {
+        // move actual file pointer to front of buffer
+        streamPos = s.seek(-bufferSourcePos, SeekPos.Current);
+      }
+      // write buffer out
+      bufferSourcePos = s.writeBlock(buffer.ptr, bufferLen);
+      if (bufferSourcePos != bufferLen) {
+        throw new WriteException("Unable to write to stream");
+      }
+    }
+    super.flush();
+    long diff = cast(long)bufferCurPos-bufferSourcePos;
+    if (diff != 0 && seekable) {
+      // move actual file pointer to current position
+      streamPos = s.seek(diff, SeekPos.Current);
+    }
+    // reset buffer data to be empty
+    bufferSourcePos = bufferCurPos = bufferLen = 0;
+    bufferDirty = false;
+  }
+
+  // returns true if end of stream is reached, false otherwise
+  override @property bool eof() {
+    if ((buffer.length == 0) || !readable) {
+      return super.eof;
+    }
+    // some simple tests to avoid flushing
+    if (ungetAvailable() || bufferCurPos != bufferLen)
+      return false;
+    if (bufferLen == buffer.length)
+      flush();
+    size_t res = super.readBlock(&buffer[bufferLen],buffer.length-bufferLen);
+    bufferSourcePos +=  res;
+    bufferLen += res;
+    streamPos += res;
+    return readEOF;
+  }
+
+  // returns size of stream
+  override @property ulong size() {
+    if (bufferDirty) flush();
+    return s.size;
+  }
+
+  // returns estimated number of bytes available for immediate reading
+  override @property size_t available() {
+    return bufferLen - bufferCurPos;
+  }
+}
+
+/// An exception for File errors.
+class StreamFileException: StreamException {
+  /// Construct a StreamFileException with given error message.
+  this(string msg) { super(msg); }
+}
+
+/// An exception for errors during File.open.
+class OpenException: StreamFileException {
+  /// Construct an OpenFileException with given error message.
+  this(string msg) { super(msg); }
+}
+
+/// Specifies the $(LREF File) access mode used when opening the file.
+enum FileMode {
+  In = 1,     /// Opens the file for reading.
+  Out = 2,    /// Opens the file for writing.
+  OutNew = 6, /// Opens the file for writing, creates a new file if it doesn't exist.
+  Append = 10 /// Opens the file for writing, appending new data to the end of the file.
+}
+
+version (Windows) {
+  private import core.sys.windows.windows;
+  extern (Windows) {
+    void FlushFileBuffers(HANDLE hFile);
+    DWORD  GetFileType(HANDLE hFile);
+  }
+}
+version (Posix) {
+  private import core.sys.posix.fcntl;
+  private import core.sys.posix.unistd;
+  alias HANDLE = int;
+}
+
+/// This subclass is for unbuffered file system streams.
+class File: Stream {
+
+  version (Windows) {
+    private HANDLE hFile;
+  }
+  version (Posix) {
+    private HANDLE hFile = -1;
+  }
+
+  this() {
+    super();
+    version (Windows) {
+      hFile = null;
+    }
+    version (Posix) {
+      hFile = -1;
+    }
+    isopen = false;
+  }
+
+  // opens existing handle; use with care!
+  this(HANDLE hFile, FileMode mode) {
+    super();
+    this.hFile = hFile;
+    readable = cast(bool)(mode & FileMode.In);
+    writeable = cast(bool)(mode & FileMode.Out);
+    version(Windows) {
+      seekable = GetFileType(hFile) == 1; // FILE_TYPE_DISK
+    } else {
+      auto result = lseek(hFile, 0, 0);
+      seekable = (result != ~0);
+    }
+  }
+
+  /***
+   * Create the stream with no open file, an open file in read mode, or an open
+   * file with explicit file mode.
+   * mode, if given, is a combination of FileMode.In
+   * (indicating a file that can be read) and FileMode.Out (indicating a file
+   * that can be written).
+   * Opening a file for reading that doesn't exist will error.
+   * Opening a file for writing that doesn't exist will create the file.
+   * The FileMode.OutNew mode will open the file for writing and reset the
+   * length to zero.
+   * The FileMode.Append mode will open the file for writing and move the
+   * file position to the end of the file.
+   */
+  this(string filename, FileMode mode = FileMode.In)
+  {
+      this();
+      open(filename, mode);
+  }
+
+
+  /***
+   * Open a file for the stream, in an identical manner to the constructors.
+   * If an error occurs an OpenException is thrown.
+   */
+  void open(string filename, FileMode mode = FileMode.In) {
+    close();
+    int access, share, createMode;
+    parseMode(mode, access, share, createMode);
+    seekable = true;
+    readable = cast(bool)(mode & FileMode.In);
+    writeable = cast(bool)(mode & FileMode.Out);
+    version (Windows) {
+      hFile = CreateFileW(filename.tempCStringW(), access, share,
+                          null, createMode, 0, null);
+      isopen = hFile != INVALID_HANDLE_VALUE;
+    }
+    version (Posix) {
+      hFile = core.sys.posix.fcntl.open(filename.tempCString(), access | createMode, share);
+      isopen = hFile != -1;
+    }
+    if (!isopen)
+      throw new OpenException(cast(string) ("Cannot open or create file '"
+                                            ~ filename ~ "'"));
+    else if ((mode & FileMode.Append) == FileMode.Append)
+      seekEnd(0);
+  }
+
+  private void parseMode(int mode,
+                         out int access,
+                         out int share,
+                         out int createMode) {
+    version (Windows) {
+      share |= FILE_SHARE_READ | FILE_SHARE_WRITE;
+      if (mode & FileMode.In) {
+        access |= GENERIC_READ;
+        createMode = OPEN_EXISTING;
+      }
+      if (mode & FileMode.Out) {
+        access |= GENERIC_WRITE;
+        createMode = OPEN_ALWAYS; // will create if not present
+      }
+      if ((mode & FileMode.OutNew) == FileMode.OutNew) {
+        createMode = CREATE_ALWAYS; // resets file
+      }
+    }
+    version (Posix) {
+      share = octal!666;
+      if (mode & FileMode.In) {
+        access = O_RDONLY;
+      }
+      if (mode & FileMode.Out) {
+        createMode = O_CREAT; // will create if not present
+        access = O_WRONLY;
+      }
+      if (access == (O_WRONLY | O_RDONLY)) {
+        access = O_RDWR;
+      }
+      if ((mode & FileMode.OutNew) == FileMode.OutNew) {
+        access |= O_TRUNC; // resets file
+      }
+    }
+  }
+
+  /// Create a file for writing.
+  void create(string filename) {
+    create(filename, FileMode.OutNew);
+  }
+
+  /// ditto
+  void create(string filename, FileMode mode) {
+    close();
+    open(filename, mode | FileMode.OutNew);
+  }
+
+  /// Close the current file if it is open; otherwise it does nothing.
+  override void close() {
+    if (isopen) {
+      super.close();
+      if (hFile) {
+        version (Windows) {
+          CloseHandle(hFile);
+          hFile = null;
+        } else version (Posix) {
+          core.sys.posix.unistd.close(hFile);
+          hFile = -1;
+        }
+      }
+    }
+  }
+
+  // destructor, closes file if still opened
+  ~this() { close(); }
+
+  version (Windows) {
+    // returns size of stream
+    override @property ulong size() {
+      assertSeekable();
+      uint sizehi;
+      uint sizelow = GetFileSize(hFile,&sizehi);
+      return (cast(ulong)sizehi << 32) + sizelow;
+    }
+  }
+
+  override size_t readBlock(void* buffer, size_t size) {
+    assertReadable();
+    version (Windows) {
+      auto dwSize = to!DWORD(size);
+      ReadFile(hFile, buffer, dwSize, &dwSize, null);
+      size = dwSize;
+    } else version (Posix) {
+      size = core.sys.posix.unistd.read(hFile, buffer, size);
+      if (size == -1)
+        size = 0;
+    }
+    readEOF = (size == 0);
+    return size;
+  }
+
+  override size_t writeBlock(const void* buffer, size_t size) {
+    assertWriteable();
+    version (Windows) {
+      auto dwSize = to!DWORD(size);
+      WriteFile(hFile, buffer, dwSize, &dwSize, null);
+      size = dwSize;
+    } else version (Posix) {
+      size = core.sys.posix.unistd.write(hFile, buffer, size);
+      if (size == -1)
+        size = 0;
+    }
+    return size;
+  }
+
+  override ulong seek(long offset, SeekPos rel) {
+    assertSeekable();
+    version (Windows) {
+      int hi = cast(int)(offset>>32);
+      uint low = SetFilePointer(hFile, cast(int)offset, &hi, rel);
+      if ((low == INVALID_SET_FILE_POINTER) && (GetLastError() != 0))
+        throw new SeekException("unable to move file pointer");
+      ulong result = (cast(ulong)hi << 32) + low;
+    } else version (Posix) {
+      auto result = lseek(hFile, cast(off_t)offset, rel);
+      if (result == cast(typeof(result))-1)
+        throw new SeekException("unable to move file pointer");
+    }
+    readEOF = false;
+    return cast(ulong)result;
+  }
+
+  /***
+   * For a seekable file returns the difference of the size and position and
+   * otherwise returns 0.
+   */
+
+  override @property size_t available() {
+    if (seekable) {
+      ulong lavail = size - position;
+      if (lavail > size_t.max) lavail = size_t.max;
+      return cast(size_t)lavail;
+    }
+    return 0;
+  }
+
+  // OS-specific property, just in case somebody wants
+  // to mess with underlying API
+  HANDLE handle() { return hFile; }
+
+  // run a few tests
+  unittest {
+    import std.internal.cstring : tempCString;
+
+    File file = new File;
+    int i = 666;
+    auto stream_file = undead.internal.file.deleteme ~ "-stream.$$$";
+    file.create(stream_file);
+    // should be ok to write
+    assert(file.writeable);
+    file.writeLine("Testing stream.d:");
+    file.writeString("Hello, world!");
+    file.write(i);
+    // string#1 + string#2 + int should give exacly that
+    version (Windows)
+      assert(file.position == 19 + 13 + 4);
+    version (Posix)
+      assert(file.position == 18 + 13 + 4);
+    // we must be at the end of file
+    assert(file.eof);
+    file.close();
+    // no operations are allowed when file is closed
+    assert(!file.readable && !file.writeable && !file.seekable);
+    file.open(stream_file);
+    // should be ok to read
+    assert(file.readable);
+    assert(file.available == file.size);
+    char[] line = file.readLine();
+    char[] exp = "Testing stream.d:".dup;
+    assert(line[0] == 'T');
+    assert(line.length == exp.length);
+    assert(!std.algorithm.cmp(line, "Testing stream.d:"));
+    // jump over "Hello, "
+    file.seek(7, SeekPos.Current);
+    version (Windows)
+      assert(file.position == 19 + 7);
+    version (Posix)
+      assert(file.position == 18 + 7);
+    assert(!std.algorithm.cmp(file.readString(6), "world!"));
+    i = 0; file.read(i);
+    assert(i == 666);
+    // string#1 + string#2 + int should give exacly that
+    version (Windows)
+      assert(file.position == 19 + 13 + 4);
+    version (Posix)
+      assert(file.position == 18 + 13 + 4);
+    // we must be at the end of file
+    assert(file.eof);
+    file.close();
+    file.open(stream_file,FileMode.OutNew | FileMode.In);
+    file.writeLine("Testing stream.d:");
+    file.writeLine("Another line");
+    file.writeLine("");
+    file.writeLine("That was blank");
+    file.position = 0;
+    char[][] lines;
+    foreach(char[] line; file) {
+      lines ~= line.dup;
+    }
+    assert( lines.length == 4 );
+    assert( lines[0] == "Testing stream.d:");
+    assert( lines[1] == "Another line");
+    assert( lines[2] == "");
+    assert( lines[3] == "That was blank");
+    file.position = 0;
+    lines = new char[][4];
+    foreach(ulong n, char[] line; file) {
+      lines[cast(size_t)(n-1)] = line.dup;
+    }
+    assert( lines[0] == "Testing stream.d:");
+    assert( lines[1] == "Another line");
+    assert( lines[2] == "");
+    assert( lines[3] == "That was blank");
+    file.close();
+    remove(stream_file.tempCString());
+  }
+}
+
+/***
+ * This subclass is for buffered file system streams.
+ *
+ * It is a convenience class for wrapping a File in a BufferedStream.
+ * A buffered stream must be closed explicitly to ensure the final buffer
+ * content is written to the file.
+ */
+class BufferedFile: BufferedStream {
+
+  /// opens file for reading
+  this() { super(new File()); }
+
+  /// opens file in requested mode and buffer size
+  this(string filename, FileMode mode = FileMode.In,
+       size_t bufferSize = DefaultBufferSize) {
+    super(new File(filename,mode),bufferSize);
+  }
+
+  /// opens file for reading with requested buffer size
+  this(File file, size_t bufferSize = DefaultBufferSize) {
+    super(file,bufferSize);
+  }
+
+  /// opens existing handle; use with care!
+  this(HANDLE hFile, FileMode mode, size_t buffersize = DefaultBufferSize) {
+    super(new File(hFile,mode),buffersize);
+  }
+
+  /// opens file in requested mode
+  void open(string filename, FileMode mode = FileMode.In) {
+    File sf = cast(File)s;
+    sf.open(filename,mode);
+    resetSource();
+  }
+
+  /// creates file in requested mode
+  void create(string filename, FileMode mode = FileMode.OutNew) {
+    File sf = cast(File)s;
+    sf.create(filename,mode);
+    resetSource();
+  }
+
+  // run a few tests same as File
+  unittest {
+    import std.internal.cstring : tempCString;
+
+    BufferedFile file = new BufferedFile;
+    int i = 666;
+    auto stream_file = undead.internal.file.deleteme ~ "-stream.$$$";
+    file.create(stream_file);
+    // should be ok to write
+    assert(file.writeable);
+    file.writeLine("Testing stream.d:");
+    file.writeString("Hello, world!");
+    file.write(i);
+    // string#1 + string#2 + int should give exacly that
+    version (Windows)
+      assert(file.position == 19 + 13 + 4);
+    version (Posix)
+      assert(file.position == 18 + 13 + 4);
+    // we must be at the end of file
+    assert(file.eof);
+    long oldsize = cast(long)file.size;
+    file.close();
+    // no operations are allowed when file is closed
+    assert(!file.readable && !file.writeable && !file.seekable);
+    file.open(stream_file);
+    // should be ok to read
+    assert(file.readable);
+    // test getc/ungetc and size
+    char c1 = file.getc();
+    file.ungetc(c1);
+    assert( file.size == oldsize );
+    assert(!std.algorithm.cmp(file.readLine(), "Testing stream.d:"));
+    // jump over "Hello, "
+    file.seek(7, SeekPos.Current);
+    version (Windows)
+      assert(file.position == 19 + 7);
+    version (Posix)
+      assert(file.position == 18 + 7);
+    assert(!std.algorithm.cmp(file.readString(6), "world!"));
+    i = 0; file.read(i);
+    assert(i == 666);
+    // string#1 + string#2 + int should give exacly that
+    version (Windows)
+      assert(file.position == 19 + 13 + 4);
+    version (Posix)
+      assert(file.position == 18 + 13 + 4);
+    // we must be at the end of file
+    assert(file.eof);
+    file.close();
+    remove(stream_file.tempCString());
+  }
+
+}
+
+/// UTF byte-order-mark signatures
+enum BOM {
+        UTF8,           /// UTF-8
+        UTF16LE,        /// UTF-16 Little Endian
+        UTF16BE,        /// UTF-16 Big Endian
+        UTF32LE,        /// UTF-32 Little Endian
+        UTF32BE,        /// UTF-32 Big Endian
+}
+
+private enum int NBOMS = 5;
+immutable Endian[NBOMS] BOMEndian =
+[ std.system.endian,
+  Endian.littleEndian, Endian.bigEndian,
+  Endian.littleEndian, Endian.bigEndian
+  ];
+
+immutable ubyte[][NBOMS] ByteOrderMarks =
+[ [0xEF, 0xBB, 0xBF],
+  [0xFF, 0xFE],
+  [0xFE, 0xFF],
+  [0xFF, 0xFE, 0x00, 0x00],
+  [0x00, 0x00, 0xFE, 0xFF]
+  ];
+
+
+/***
+ * This subclass wraps a stream with big-endian or little-endian byte order
+ * swapping.
+ *
+ * UTF Byte-Order-Mark (BOM) signatures can be read and deduced or
+ * written.
+ * Note that an EndianStream should not be used as the source of another
+ * FilterStream since a FilterStream call the source with byte-oriented
+ * read/write requests and the EndianStream will not perform any byte swapping.
+ * The EndianStream reads and writes binary data (non-getc functions) in a
+ * one-to-one
+ * manner with the source stream so the source stream's position and state will be
+ * kept in sync with the EndianStream if only non-getc functions are called.
+ */
+class EndianStream : FilterStream {
+
+  Endian endian;        /// Endianness property of the source stream.
+
+  /***
+   * Create the endian stream for the source stream source with endianness end.
+   * The default endianness is the native byte order.
+   * The Endian type is defined
+   * in the std.system module.
+   */
+  this(Stream source, Endian end = std.system.endian) {
+    super(source);
+    endian = end;
+  }
+
+  /***
+   * Return -1 if no BOM and otherwise read the BOM and return it.
+   *
+   * If there is no BOM or if bytes beyond the BOM are read then the bytes read
+   * are pushed back onto the ungetc buffer or ungetcw buffer.
+   * Pass ungetCharSize == 2 to use
+   * ungetcw instead of ungetc when no BOM is present.
+   */
+  int readBOM(int ungetCharSize = 1) {
+    ubyte[4] BOM_buffer;
+    int n = 0;       // the number of read bytes
+    int result = -1; // the last match or -1
+    for (int i=0; i < NBOMS; ++i) {
+      int j;
+      immutable ubyte[] bom = ByteOrderMarks[i];
+      for (j=0; j < bom.length; ++j) {
+        if (n <= j) { // have to read more
+          if (eof)
+            break;
+          readExact(&BOM_buffer[n++],1);
+        }
+        if (BOM_buffer[j] != bom[j])
+          break;
+      }
+      if (j == bom.length) // found a match
+        result = i;
+    }
+    ptrdiff_t m = 0;
+    if (result != -1) {
+      endian = BOMEndian[result]; // set stream endianness
+      m = ByteOrderMarks[result].length;
+    }
+    if ((ungetCharSize == 1 && result == -1) || (result == BOM.UTF8)) {
+      while (n-- > m)
+        ungetc(BOM_buffer[n]);
+    } else { // should eventually support unget for dchar as well
+      if (n & 1) // make sure we have an even number of bytes
+        readExact(&BOM_buffer[n++],1);
+      while (n > m) {
+        n -= 2;
+        wchar cw = *(cast(wchar*)&BOM_buffer[n]);
+        fixBO(&cw,2);
+        ungetcw(cw);
+      }
+    }
+    return result;
+  }
+
+  /***
+   * Correct the byte order of buffer to match native endianness.
+   * size must be even.
+   */
+  final void fixBO(const(void)* buffer, size_t size) {
+    if (endian != std.system.endian) {
+      ubyte* startb = cast(ubyte*)buffer;
+      uint* start = cast(uint*)buffer;
+      switch (size) {
+      case 0: break;
+      case 2: {
+        ubyte x = *startb;
+        *startb = *(startb+1);
+        *(startb+1) = x;
+        break;
+      }
+      case 4: {
+        *start = bswap(*start);
+        break;
+      }
+      default: {
+        uint* end = cast(uint*)(buffer + size - uint.sizeof);
+        while (start < end) {
+          uint x = bswap(*start);
+          *start = bswap(*end);
+          *end = x;
+          ++start;
+          --end;
+        }
+        startb = cast(ubyte*)start;
+        ubyte* endb = cast(ubyte*)end;
+        auto len = uint.sizeof - (startb - endb);
+        if (len > 0)
+          fixBO(startb,len);
+      }
+      }
+    }
+  }
+
+  /***
+   * Correct the byte order of the given buffer in blocks of the given size and
+   * repeated the given number of times.
+   * size must be even.
+   */
+  final void fixBlockBO(void* buffer, uint size, size_t repeat) {
+    while (repeat--) {
+      fixBO(buffer,size);
+      buffer += size;
+    }
+  }
+
+  override void read(out byte x) { readExact(&x, x.sizeof); }
+  override void read(out ubyte x) { readExact(&x, x.sizeof); }
+  override void read(out short x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out ushort x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out int x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out uint x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out long x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out ulong x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out float x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out double x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out real x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out ifloat x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out idouble x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out ireal x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out cfloat x) { readExact(&x, x.sizeof); fixBlockBO(&x,float.sizeof,2); }
+  override void read(out cdouble x) { readExact(&x, x.sizeof); fixBlockBO(&x,double.sizeof,2); }
+  override void read(out creal x) { readExact(&x, x.sizeof); fixBlockBO(&x,real.sizeof,2); }
+  override void read(out char x) { readExact(&x, x.sizeof); }
+  override void read(out wchar x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+  override void read(out dchar x) { readExact(&x, x.sizeof); fixBO(&x,x.sizeof); }
+
+  override wchar getcw() {
+    wchar c;
+    if (prevCr) {
+      prevCr = false;
+      c = getcw();
+      if (c != '\n')
+        return c;
+    }
+    if (unget.length > 1) {
+      c = unget[unget.length - 1];
+      unget.length = unget.length - 1;
+    } else {
+      void* buf = &c;
+      size_t n = readBlock(buf,2);
+      if (n == 1 && readBlock(buf+1,1) == 0)
+          throw new ReadException("not enough data in stream");
+      fixBO(&c,c.sizeof);
+    }
+    return c;
+  }
+
+  override wchar[] readStringW(size_t length) {
+    wchar[] result = new wchar[length];
+    readExact(result.ptr, length * wchar.sizeof);
+    fixBlockBO(result.ptr, wchar.sizeof, length);
+    return result;
+  }
+
+  /// Write the specified BOM b to the source stream.
+  void writeBOM(BOM b) {
+    immutable ubyte[] bom = ByteOrderMarks[b];
+    writeBlock(bom.ptr, bom.length);
+  }
+
+  override void write(byte x) { writeExact(&x, x.sizeof); }
+  override void write(ubyte x) { writeExact(&x, x.sizeof); }
+  override void write(short x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(ushort x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(int x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(uint x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(long x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(ulong x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(float x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(double x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(real x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(ifloat x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(idouble x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(ireal x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(cfloat x) { fixBlockBO(&x,float.sizeof,2); writeExact(&x, x.sizeof); }
+  override void write(cdouble x) { fixBlockBO(&x,double.sizeof,2); writeExact(&x, x.sizeof); }
+  override void write(creal x) { fixBlockBO(&x,real.sizeof,2); writeExact(&x, x.sizeof);  }
+  override void write(char x) { writeExact(&x, x.sizeof); }
+  override void write(wchar x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+  override void write(dchar x) { fixBO(&x,x.sizeof); writeExact(&x, x.sizeof); }
+
+  override void writeStringW(const(wchar)[] str) {
+    foreach(wchar cw;str) {
+      fixBO(&cw,2);
+      s.writeExact(&cw, 2);
+    }
+  }
+
+  override @property bool eof() { return s.eof && !ungetAvailable();  }
+  override @property ulong size() { return s.size;  }
+
+  unittest {
+    MemoryStream m;
+    m = new MemoryStream ();
+    EndianStream em = new EndianStream(m,Endian.bigEndian);
+    uint x = 0x11223344;
+    em.write(x);
+    assert( m.data[0] == 0x11 );
+    assert( m.data[1] == 0x22 );
+    assert( m.data[2] == 0x33 );
+    assert( m.data[3] == 0x44 );
+    em.position = 0;
+    ushort x2 = 0x5566;
+    em.write(x2);
+    assert( m.data[0] == 0x55 );
+    assert( m.data[1] == 0x66 );
+    em.position = 0;
+    static ubyte[12] x3 = [1,2,3,4,5,6,7,8,9,10,11,12];
+    em.fixBO(x3.ptr,12);
+    if (std.system.endian == Endian.littleEndian) {
+      assert( x3[0] == 12 );
+      assert( x3[1] == 11 );
+      assert( x3[2] == 10 );
+      assert( x3[4] == 8 );
+      assert( x3[5] == 7 );
+      assert( x3[6] == 6 );
+      assert( x3[8] == 4 );
+      assert( x3[9] == 3 );
+      assert( x3[10] == 2 );
+      assert( x3[11] == 1 );
+    }
+    em.endian = Endian.littleEndian;
+    em.write(x);
+    assert( m.data[0] == 0x44 );
+    assert( m.data[1] == 0x33 );
+    assert( m.data[2] == 0x22 );
+    assert( m.data[3] == 0x11 );
+    em.position = 0;
+    em.write(x2);
+    assert( m.data[0] == 0x66 );
+    assert( m.data[1] == 0x55 );
+    em.position = 0;
+    em.fixBO(x3.ptr,12);
+    if (std.system.endian == Endian.bigEndian) {
+      assert( x3[0] == 12 );
+      assert( x3[1] == 11 );
+      assert( x3[2] == 10 );
+      assert( x3[4] == 8 );
+      assert( x3[5] == 7 );
+      assert( x3[6] == 6 );
+      assert( x3[8] == 4 );
+      assert( x3[9] == 3 );
+      assert( x3[10] == 2 );
+      assert( x3[11] == 1 );
+    }
+    em.writeBOM(BOM.UTF8);
+    assert( m.position == 3 );
+    assert( m.data[0] == 0xEF );
+    assert( m.data[1] == 0xBB );
+    assert( m.data[2] == 0xBF );
+    em.writeString ("Hello, world");
+    em.position = 0;
+    assert( m.position == 0 );
+    assert( em.readBOM() == BOM.UTF8 );
+    assert( m.position == 3 );
+    assert( em.getc() == 'H' );
+    em.position = 0;
+    em.writeBOM(BOM.UTF16BE);
+    assert( m.data[0] == 0xFE );
+    assert( m.data[1] == 0xFF );
+    em.position = 0;
+    em.writeBOM(BOM.UTF16LE);
+    assert( m.data[0] == 0xFF );
+    assert( m.data[1] == 0xFE );
+    em.position = 0;
+    em.writeString ("Hello, world");
+    em.position = 0;
+    assert( em.readBOM() == -1 );
+    assert( em.getc() == 'H' );
+    assert( em.getc() == 'e' );
+    assert( em.getc() == 'l' );
+    assert( em.getc() == 'l' );
+    em.position = 0;
+  }
+}
+
+/***
+ * Parameterized subclass that wraps an array-like buffer with a stream
+ * interface.
+ *
+ * The type Buffer must support the length property, opIndex and opSlice.
+ * Compile in release mode when directly instantiating a TArrayStream to avoid
+ * link errors.
+ */
+class TArrayStream(Buffer): Stream {
+  Buffer buf; // current data
+  ulong len;  // current data length
+  ulong cur;  // current file position
+
+  /// Create the stream for the the buffer buf. Non-copying.
+  this(Buffer buf) {
+    super ();
+    this.buf = buf;
+    this.len = buf.length;
+    readable = writeable = seekable = true;
+  }
+
+  // ensure subclasses don't violate this
+  invariant() {
+    assert(len <= buf.length);
+    assert(cur <= len);
+  }
+
+  override size_t readBlock(void* buffer, size_t size) {
+    assertReadable();
+    ubyte* cbuf = cast(ubyte*) buffer;
+    if (len - cur < size)
+      size = cast(size_t)(len - cur);
+    ubyte[] ubuf = cast(ubyte[])buf[cast(size_t)cur .. cast(size_t)(cur + size)];
+    cbuf[0 .. size] = ubuf[];
+    cur += size;
+    return size;
+  }
+
+  override size_t writeBlock(const void* buffer, size_t size) {
+    assertWriteable();
+    ubyte* cbuf = cast(ubyte*) buffer;
+    ulong blen = buf.length;
+    if (cur + size > blen)
+      size = cast(size_t)(blen - cur);
+    ubyte[] ubuf = cast(ubyte[])buf[cast(size_t)cur .. cast(size_t)(cur + size)];
+    ubuf[] = cbuf[0 .. size];
+    cur += size;
+    if (cur > len)
+      len = cur;
+    return size;
+  }
+
+  override ulong seek(long offset, SeekPos rel) {
+    assertSeekable();
+    long scur; // signed to saturate to 0 properly
+
+    switch (rel) {
+    case SeekPos.Set: scur = offset; break;
+    case SeekPos.Current: scur = cast(long)(cur + offset); break;
+    case SeekPos.End: scur = cast(long)(len + offset); break;
+    default:
+        assert(0);
+    }
+
+    if (scur < 0)
+      cur = 0;
+    else if (scur > len)
+      cur = len;
+    else
+      cur = cast(ulong)scur;
+
+    return cur;
+  }
+
+  override @property size_t available () { return cast(size_t)(len - cur); }
+
+  /// Get the current memory data in total.
+  @property ubyte[] data() {
+    if (len > size_t.max)
+      throw new StreamException("Stream too big");
+    const(void)[] res = buf[0 .. cast(size_t)len];
+    return cast(ubyte[])res;
+  }
+
+  override string toString() {
+      // assume data is UTF8
+      return to!(string)(cast(char[])data);
+  }
+}
+
+/* Test the TArrayStream */
+unittest {
+  char[100] buf;
+  TArrayStream!(char[]) m;
+
+  m = new TArrayStream!(char[]) (buf);
+  assert (m.isOpen);
+  m.writeString ("Hello, world");
+  assert (m.position == 12);
+  assert (m.available == 88);
+  assert (m.seekSet (0) == 0);
+  assert (m.available == 100);
+  assert (m.seekCur (4) == 4);
+  assert (m.available == 96);
+  assert (m.seekEnd (-8) == 92);
+  assert (m.available == 8);
+  assert (m.size == 100);
+  assert (m.seekSet (4) == 4);
+  assert (m.readString (4) == "o, w");
+  m.writeString ("ie");
+  assert (buf[0..12] == "Hello, wield");
+  assert (m.position == 10);
+  assert (m.available == 90);
+  assert (m.size == 100);
+  m.seekSet (0);
+  assert (m.printf ("Answer is %d", 42) == 12);
+  assert (buf[0..12] == "Answer is 42");
+}
+
+/// This subclass reads and constructs an array of bytes in memory.
+class MemoryStream: TArrayStream!(ubyte[]) {
+
+  /// Create the output buffer and setup for reading, writing, and seeking.
+  // clear to an empty buffer.
+  this() { this(cast(ubyte[]) null); }
+
+  /***
+   * Create the output buffer and setup for reading, writing, and seeking.
+   * Load it with specific input data.
+   */
+  this(ubyte[] buf) { super (buf); }
+  this(byte[] buf) { this(cast(ubyte[]) buf); } /// ditto
+  this(char[] buf) { this(cast(ubyte[]) buf); } /// ditto
+
+  /// Ensure the stream can write count extra bytes from cursor position without an allocation.
+  void reserve(size_t count) {
+    if (cur + count > buf.length)
+      buf.length = cast(uint)((cur + count) * 2);
+  }
+
+  override size_t writeBlock(const void* buffer, size_t size) {
+    reserve(size);
+    return super.writeBlock(buffer,size);
+  }
+
+  unittest {
+    MemoryStream m;
+
+    m = new MemoryStream ();
+    assert (m.isOpen);
+    m.writeString ("Hello, world");
+    assert (m.position == 12);
+    assert (m.seekSet (0) == 0);
+    assert (m.available == 12);
+    assert (m.seekCur (4) == 4);
+    assert (m.available == 8);
+    assert (m.seekEnd (-8) == 4);
+    assert (m.available == 8);
+    assert (m.size == 12);
+    assert (m.readString (4) == "o, w");
+    m.writeString ("ie");
+    assert (cast(char[]) m.data == "Hello, wield");
+    m.seekEnd (0);
+    m.writeString ("Foo");
+    assert (m.position == 15);
+    assert (m.available == 0);
+    m.writeString ("Foo foo foo foo foo foo foo");
+    assert (m.position == 42);
+    m.position = 0;
+    assert (m.available == 42);
+    m.writef("%d %d %s",100,345,"hello");
+    auto str = m.toString();
+    assert (str[0..13] == "100 345 hello", str[0 .. 13]);
+    assert (m.available == 29);
+    assert (m.position == 13);
+
+    MemoryStream m2;
+    m.position = 3;
+    m2 = new MemoryStream ();
+    m2.writeString("before");
+    m2.copyFrom(m,10);
+    str = m2.toString();
+    assert (str[0..16] == "before 345 hello");
+    m2.position = 3;
+    m2.copyFrom(m);
+    auto str2 = m.toString();
+    str = m2.toString();
+    assert (str == ("bef" ~ str2));
+  }
+}
+
+import std.mmfile;
+
+/***
+ * This subclass wraps a memory-mapped file with the stream API.
+ * See std.mmfile module.
+ */
+class MmFileStream : TArrayStream!(MmFile) {
+
+  /// Create stream wrapper for file.
+  this(MmFile file) {
+    super (file);
+    MmFile.Mode mode = file.mode();
+    writeable = mode > MmFile.Mode.read;
+  }
+
+  override void flush() {
+    if (isopen) {
+      super.flush();
+      buf.flush();
+    }
+  }
+
+  override void close() {
+    if (isopen) {
+      super.close();
+      delete buf;
+      buf = null;
+    }
+  }
+}
+
+unittest {
+  auto test_file = undead.internal.file.deleteme ~ "-testing.txt";
+  MmFile mf = new MmFile(test_file,MmFile.Mode.readWriteNew,100,null);
+  MmFileStream m;
+  m = new MmFileStream (mf);
+  m.writeString ("Hello, world");
+  assert (m.position == 12);
+  assert (m.seekSet (0) == 0);
+  assert (m.seekCur (4) == 4);
+  assert (m.seekEnd (-8) == 92);
+  assert (m.size == 100);
+  assert (m.seekSet (4));
+  assert (m.readString (4) == "o, w");
+  m.writeString ("ie");
+  ubyte[] dd = m.data;
+  assert ((cast(char[]) dd)[0 .. 12] == "Hello, wield");
+  m.position = 12;
+  m.writeString ("Foo");
+  assert (m.position == 15);
+  m.writeString ("Foo foo foo foo foo foo foo");
+  assert (m.position == 42);
+  m.close();
+  mf = new MmFile(test_file);
+  m = new MmFileStream (mf);
+  assert (!m.writeable);
+  char[] str = m.readString(12);
+  assert (str == "Hello, wield");
+  m.close();
+  std.file.remove(test_file);
+}
+
+
+/***
+ * This subclass slices off a portion of another stream, making seeking relative
+ * to the boundaries of the slice.
+ *
+ * It could be used to section a large file into a
+ * set of smaller files, such as with tar archives. Reading and writing a
+ * SliceStream does not modify the position of the source stream if it is
+ * seekable.
+ */
+class SliceStream : FilterStream {
+  private {
+    ulong pos;  // our position relative to low
+    ulong low; // low stream offset.
+    ulong high; // high stream offset.
+    bool bounded; // upper-bounded by high.
+  }
+
+  /***
+   * Indicate both the source stream to use for reading from and the low part of
+   * the slice.
+   *
+   * The high part of the slice is dependent upon the end of the source
+   * stream, so that if you write beyond the end it resizes the stream normally.
+   */
+  this (Stream s, ulong low)
+  in {
+    assert (low <= s.size);
+  }
+  body {
+    super(s);
+    this.low = low;
+    this.high = 0;
+    this.bounded = false;
+  }
+
+  /***
+   * Indicate the high index as well.
+   *
+   * Attempting to read or write past the high
+   * index results in the end being clipped off.
+   */
+  this (Stream s, ulong low, ulong high)
+  in {
+    assert (low <= high);
+    assert (high <= s.size);
+  }
+  body {
+    super(s);
+    this.low = low;
+    this.high = high;
+    this.bounded = true;
+  }
+
+  invariant() {
+    if (bounded)
+      assert (pos <= high - low);
+    else
+      // size() does not appear to be const, though it should be
+      assert (pos <= (cast()s).size - low);
+  }
+
+  override size_t readBlock (void *buffer, size_t size) {
+    assertReadable();
+    if (bounded && size > high - low - pos)
+        size = cast(size_t)(high - low - pos);
+    ulong bp = s.position;
+    if (seekable)
+      s.position = low + pos;
+    size_t ret = super.readBlock(buffer, size);
+    if (seekable) {
+      pos = s.position - low;
+      s.position = bp;
+    }
+    return ret;
+  }
+
+  override size_t writeBlock (const void *buffer, size_t size) {
+    assertWriteable();
+    if (bounded && size > high - low - pos)
+        size = cast(size_t)(high - low - pos);
+    ulong bp = s.position;
+    if (seekable)
+      s.position = low + pos;
+    size_t ret = s.writeBlock(buffer, size);
+    if (seekable) {
+      pos = s.position - low;
+      s.position = bp;
+    }
+    return ret;
+  }
+
+  override ulong seek(long offset, SeekPos rel) {
+    assertSeekable();
+    long spos;
+
+    switch (rel) {
+      case SeekPos.Set:
+        spos = offset;
+        break;
+      case SeekPos.Current:
+        spos = cast(long)(pos + offset);
+        break;
+      case SeekPos.End:
+        if (bounded)
+          spos = cast(long)(high - low + offset);
+        else
+          spos = cast(long)(s.size - low + offset);
+        break;
+      default:
+        assert(0);
+    }
+
+    if (spos < 0)
+      pos = 0;
+    else if (bounded && spos > high - low)
+      pos = high - low;
+    else if (!bounded && spos > s.size - low)
+      pos = s.size - low;
+    else
+      pos = cast(ulong)spos;
+
+    readEOF = false;
+    return pos;
+  }
+
+  override @property size_t available() {
+    size_t res = s.available;
+    ulong bp = s.position;
+    if (bp <= pos+low && pos+low <= bp+res) {
+      if (!bounded || bp+res <= high)
+        return cast(size_t)(bp + res - pos - low);
+      else if (high <= bp+res)
+        return cast(size_t)(high - pos - low);
+    }
+    return 0;
+  }
+
+  unittest {
+    MemoryStream m;
+    SliceStream s;
+
+    m = new MemoryStream ((cast(char[])"Hello, world").dup);
+    s = new SliceStream (m, 4, 8);
+    assert (s.size == 4);
+    assert (m.position == 0);
+    assert (s.position == 0);
+    assert (m.available == 12);
+    assert (s.available == 4);
+
+    assert (s.writeBlock (cast(char *) "Vroom", 5) == 4);
+    assert (m.position == 0);
+    assert (s.position == 4);
+    assert (m.available == 12);
+    assert (s.available == 0);
+    assert (s.seekEnd (-2) == 2);
+    assert (s.available == 2);
+    assert (s.seekEnd (2) == 4);
+    assert (s.available == 0);
+    assert (m.position == 0);
+    assert (m.available == 12);
+
+    m.seekEnd(0);
+    m.writeString("\nBlaho");
+    assert (m.position == 18);
+    assert (m.available == 0);
+    assert (s.position == 4);
+    assert (s.available == 0);
+
+    s = new SliceStream (m, 4);
+    assert (s.size == 14);
+    assert (s.toString () == "Vrooorld\nBlaho");
+    s.seekEnd (0);
+    assert (s.available == 0);
+
+    s.writeString (", etcetera.");
+    assert (s.position == 25);
+    assert (s.seekSet (0) == 0);
+    assert (s.size == 25);
+    assert (m.position == 18);
+    assert (m.size == 29);
+    assert (m.toString() == "HellVrooorld\nBlaho, etcetera.");
+  }
+}