aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/undead/stream.d
diff options
context:
space:
mode:
authorRalph Amissah <ralph@amissah.com>2016-08-22 10:31:34 -0400
committerRalph Amissah <ralph@amissah.com>2019-04-04 14:53:41 -0400
commit39b78293cbab8ce9df020a6754d3aae6624dab71 (patch)
tree319fb68bbea334377dde13644247153ff20315d7 /src/undead/stream.d
parentstep 0.6.3 includes fixes (diff)
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/
Diffstat (limited to 'src/undead/stream.d')
-rw-r--r--src/undead/stream.d3071
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.");
+ }
+}