Ticket #353: RawCoutFilter.d

import tango.core.Exception : IOException;
import tango.io.Conduit     : OutputFilter;
import tango.io.Console     : Cout, Cerr;
import tango.math.Math      : min;
import tango.sys.Common;

// a capturing filter on Stdout and Stderr to disable Unicode translation on console output
// Win32 code from Tango's (0.98 RC2) Console.Conduit, changed to to use WriteConsoleA
// Posix code from DeviceConduit

class RawCoutFilter(bool stderr) : OutputFilter {

    private void error() {
        throw new IOException("RawCoutFilter error: " ~ SysError.lastMsg);
    }

    private typeof(Cout.stream()) superArgs() {
        return stderr ? Cerr.stream : Cout.stream;
    }

    version (Win32) {
        private HANDLE handle;
        private bool redirected;

        public this() {
            reopen();

            super(superArgs());
        }

        private void reopen() {
            handle = GetStdHandle(stderr ? cast(DWORD)-12 : cast(DWORD)-11);

            if (handle is null) {
                handle = CreateFileA(
                    "CONOUT$",
                    GENERIC_READ    | GENERIC_WRITE,
                    FILE_SHARE_READ | FILE_SHARE_WRITE,
                    null,
                    OPEN_EXISTING,
                    0,
                    null
                );

                if (handle is null)
                    error();
            }

            DWORD dummy;
            redirected = !GetConsoleMode(handle, &dummy);
        }

        public override size_t write(void[] src) {
            if (redirected) {
                DWORD written;

                            if (!WriteFile(handle, src.ptr, src.length, &written, null))
                                    error();

                            return written;
            } else {
                DWORD i = src.length;

                if (i == 0)
                    return 0;

                for (auto p = src.ptr, end = src.ptr + i; p < end; p += i)
                    // avoid console buffer size limitations, write in smaller chunks
                    if (!WriteConsoleA(handle, p, min(end - p, 16 * 1024), &i, null))
                        error();

                return src.length;
            }
        }
    } else { // Posix

        // stdout is 1, stderr is 2
        private const int handle = cast(int)stderr + 1;

        public this() { super(superArgs()); }

        public override size_t write(void[] src) {
            ptrdiff_t written = posix.write(handle, src.ptr, src.length);
            if (written < 0)
                error();
            return written;
        }
    }
}