Converted tabs to spaces with tabconv.

255 files changed, 31317 insertions, 31317 deletions

diff --git a/autoconfig.cpp b/autoconfig.cpp
index c2649ad..28362ec 100644
--- a/autoconfig.cpp
+++ b/autoconfig.cpp
@@ -8,87 +8,87 @@ FILE *fOut = NULL;
 
 bool testCpp( const char *prog )
 {
-        FILE *pop = popen("g++ -x c++ - -o /dev/null", "w");
-        fwrite( prog, 1, strlen( prog ), pop );
-        return pclose(pop) == 0;
+    FILE *pop = popen("g++ -x c++ - -o /dev/null", "w");
+    fwrite( prog, 1, strlen( prog ), pop );
+    return pclose(pop) == 0;
 }
 
 void detectEndianness()
 {
-        printf("Detecting endian support...");
-        fflush( stdout );
-        if( testCpp("#include <endian.h>\n\nint main() { return BYTE_ORDER; }\n") )
-        {
-                fprintf( fOut, "#include <endian.h>\n\n");
-                printf("header file endian.h found, using that.\n");
-        }
-        else
-        {
-                uint16_t x=0x0100;
-                fprintf( fOut,
-                        "#define LITTLE_ENDIAN 0\n"
-                        "#define BIG_ENDIAN 1\n"
-                        "#define BYTE_ORDER %d\n\n",
-                        ((uint8_t *)&x)[0]
-                        );
-                printf("no header file found, faking it...\n"
-                        "\tArchetecture is: %s Endian\n",
-                        ((uint8_t *)&x)[0]?"Big":"Little"
-                        );
-        }
+    printf("Detecting endian support...");
+    fflush( stdout );
+    if( testCpp("#include <endian.h>\n\nint main() { return BYTE_ORDER; }\n") )
+    {
+        fprintf( fOut, "#include <endian.h>\n\n");
+        printf("header file endian.h found, using that.\n");
+    }
+    else
+    {
+        uint16_t x=0x0100;
+        fprintf( fOut,
+            "#define LITTLE_ENDIAN 0\n"
+            "#define BIG_ENDIAN 1\n"
+            "#define BYTE_ORDER %d\n\n",
+            ((uint8_t *)&x)[0]
+            );
+        printf("no header file found, faking it...\n"
+            "\tArchetecture is: %s Endian\n",
+            ((uint8_t *)&x)[0]?"Big":"Little"
+            );
+    }
 }
 
 int main( int argc, char *argv[] )
 {
-        if( argc == 1 )
-        {
-                fprintf( stderr,
-                        "Invalid usage: specify a file to generate:\n"
-                        "    src/autoconfig.h\n"
-                        "    src/version.h\n"
-                        "\n"
-                        );
-                return 127;
-        }
-        if( strcmp( argv[1], "src/autoconfig.h" ) == 0 )
-        {
-                fOut = fopen( argv[1], "w" );
-                fprintf( fOut,
-                        "#ifndef BU_AUTO_CONFIG_H\n"
-                        "#define BU_AUTO_CONFIG_H\n\n"
-                        );
+    if( argc == 1 )
+    {
+        fprintf( stderr,
+            "Invalid usage: specify a file to generate:\n"
+            "    src/autoconfig.h\n"
+            "    src/version.h\n"
+            "\n"
+            );
+        return 127;
+    }
+    if( strcmp( argv[1], "src/autoconfig.h" ) == 0 )
+    {
+        fOut = fopen( argv[1], "w" );
+        fprintf( fOut,
+            "#ifndef BU_AUTO_CONFIG_H\n"
+            "#define BU_AUTO_CONFIG_H\n\n"
+            );
 
-                detectEndianness();
+        detectEndianness();
 
-                fprintf( fOut, "#endif\n");
-        }
-        else if( strcmp( argv[1], "src/version.h" ) == 0 )
-        {
-                FILE *fVer = fopen("version", "rt");
-                char buf[1024];
-                buf[fread( buf, 1, 1024, fVer )] = '\0';
-                for( int j = 0; buf[j]; j++ )
-                        if( buf[j] == '\n' )
-                                buf[j] = '\0';
-                fclose( fVer );
+        fprintf( fOut, "#endif\n");
+    }
+    else if( strcmp( argv[1], "src/version.h" ) == 0 )
+    {
+        FILE *fVer = fopen("version", "rt");
+        char buf[1024];
+        buf[fread( buf, 1, 1024, fVer )] = '\0';
+        for( int j = 0; buf[j]; j++ )
+            if( buf[j] == '\n' )
+                buf[j] = '\0';
+        fclose( fVer );
 
-                fOut = fopen( argv[1], "w" );
-                fprintf( fOut,
-                        "#ifndef BU_VERSION_H\n"
-                        "#define BU_VERSION_H\n\n"
-                        "#define LIBBU_VERSION          0\n"
-                        "#define LIBBU_REVISION         1\n"
-                        "#define LIBBU_VERSION_STR      \"%s\"\n"
-                        "#define LIBBU_API              0\n"
-                        "#define LIBBU_VC_ID            \"",
+        fOut = fopen( argv[1], "w" );
+        fprintf( fOut,
+            "#ifndef BU_VERSION_H\n"
+            "#define BU_VERSION_H\n\n"
+            "#define LIBBU_VERSION              0\n"
+            "#define LIBBU_REVISION             1\n"
+            "#define LIBBU_VERSION_STR  \"%s\"\n"
+            "#define LIBBU_API          0\n"
+            "#define LIBBU_VC_ID                \"",
                         buf
                         );
                 FILE *psub = popen("svnversion -n", "r");
                 fwrite( buf, fread( buf, 1, 1024, psub ), 1, fOut );
                 pclose( psub );
                 fprintf( fOut, "\"\n\n#endif\n");
-        }
+    }
 
-        return 0;
+    return 0;
 }
 
diff --git a/default.bld b/default.bld
index d46662c..83d2717 100644
--- a/default.bld
+++ b/default.bld
@@ -19,117 +19,117 @@ CXXFLAGS += "-ggdb -W -Wall -I.";
 
 action "default"
 {
-        build: ["header-links", "libbu++.a",
-                targets("tools")];
+    build: ["header-links", "libbu++.a",
+        targets("tools")];
 }
 
 action "pkg"
 {
-        build: targets("pkg");
+    build: targets("pkg");
 }
 
 action "all"
 {
-        build: ["header-links", "libbu++.a",
-                targets("tools"), targets("tests")];
+    build: ["header-links", "libbu++.a",
+        targets("tools"), targets("tests")];
 }
 
 action "unit"
 {
-        build: targets("unit tests");
+    build: targets("unit tests");
 }
 
 action "myriadfs"
 {
-        build: "myriadfs";
+    build: "myriadfs";
 }
 
 target ["src/autoconfig.h", "src/version.h"]
 {
-        input "autoconfig";
-        display "autoconfig";
-        profile "build"
-        {
-                execute("./autoconfig ${OUTPUT}");
-        }
+    input "autoconfig";
+    display "autoconfig";
+    profile "build"
+    {
+        execute("./autoconfig ${OUTPUT}");
+    }
 }
 
 target "src/version.h"
 {
-        input ".svn";
+    input ".svn";
 }
 
 target "src/signals.h"
 {
-        input "gensigs.bld";
-        display "generate";
-        profile "build"
-        {
-                genSigs( OUTPUT );
-        }
+    input "gensigs.bld";
+    display "generate";
+    profile "build"
+    {
+        genSigs( OUTPUT );
+    }
 }
 
 target "autoconfig"
 {
-        rule "exe";
-        input "autoconfig.cpp";
+    rule "exe";
+    input "autoconfig.cpp";
 }
 
 for base in ["stable", "unstable", "experimental"] do
 {
-        target files("src/${base}/*.h").replace("src/${base}/", "bu/")
-        {
-                tag "header-links";
-                display "symlink";
-                input OUTPUT.replace("bu/","src/${base}/");
-                profile "build"
-                {
-                        DIR = OUTPUT.dirName();
-                        execute("mkdir -p ${DIR}; ln -s ../${INPUT} ${OUTPUT}");
-                }
-        }
+    target files("src/${base}/*.h").replace("src/${base}/", "bu/")
+    {
+        tag "header-links";
+        display "symlink";
+        input OUTPUT.replace("bu/","src/${base}/");
+        profile "build"
+        {
+            DIR = OUTPUT.dirName();
+            execute("mkdir -p ${DIR}; ln -s ../${INPUT} ${OUTPUT}");
+        }
+    }
 }
 
 target ["bu/config.h", "bu/autoconfig.h", "bu/version.h", "bu/signals.h"]
 {
-        tag "header-links";
-        display "symlink";
-        input OUTPUT.replace("bu/","src/");
-        profile "build"
-        {
-                DIR = OUTPUT.dirName();
-                execute("mkdir -p ${DIR}; ln -s ../${INPUT} ${OUTPUT}");
-        }
+    tag "header-links";
+    display "symlink";
+    input OUTPUT.replace("bu/","src/");
+    profile "build"
+    {
+        DIR = OUTPUT.dirName();
+        execute("mkdir -p ${DIR}; ln -s ../${INPUT} ${OUTPUT}");
+    }
 }
 
 target files("src/compat/*.h").replace("src/", "bu/")
 {
-        tag "header-links";
-        display "symlink";
-        input OUTPUT.replace("bu/","src/");
-        profile "build"
-        {
-                DIR = OUTPUT.dirName();
-                execute("mkdir -p ${DIR}; ln -s ../../${INPUT} ${OUTPUT}");
-        }
+    tag "header-links";
+    display "symlink";
+    input OUTPUT.replace("bu/","src/");
+    profile "build"
+    {
+        DIR = OUTPUT.dirName();
+        execute("mkdir -p ${DIR}; ln -s ../../${INPUT} ${OUTPUT}");
+    }
 }
 
 target "header-links"
 {
-        input targets("header-links");
-        display "symlinks";
-        profile "build"
-        {
-                condition always;
-        }
+    input targets("header-links");
+    display "symlinks";
+    profile "build"
+    {
+        condition always;
+    }
 }
 
 target "libbu++.a"
 {
-        input files("src/stable/*.cpp", "src/unstable/*.cpp",
-                "src/experimental/*.cpp", "src/compat/*.cpp");
-        rule "lib";
-        CXXFLAGS += "-I. -fPIC";
+    input files("src/stable/*.cpp", "src/unstable/*.cpp",
+        "src/experimental/*.cpp", "src/compat/*.cpp");
+    rule "lib";
+    CXXFLAGS += "-I. -fPIC";
 }
 
 //
@@ -138,31 +138,31 @@ target "libbu++.a"
 
 target files("src/tools/*.cpp").replace("src/tools/","").replace(".cpp","")
 {
-        input "src/tools/${OUTPUT}.cpp";
-        rule "exe";
-        requires "libbu++.a";
-        tag "tools";
-        CXXFLAGS += "-I.";
-        LDFLAGS += "-L. -lbu++";
+    input "src/tools/${OUTPUT}.cpp";
+    rule "exe";
+    requires "libbu++.a";
+    tag "tools";
+    CXXFLAGS += "-I.";
+    LDFLAGS += "-L. -lbu++";
 }
 
 target "viewcsv"
 {
-        LDFLAGS += "-lncurses";
+    LDFLAGS += "-lncurses";
 }
 
 target ["myriad", "myriadfs", "tests/myriad", "tests/myriadfs", "unit/myriad", "tests/bigmyriad", "tests/synchroqueue"]
 {
-        LDFLAGS += "-lpthread";
+    LDFLAGS += "-lpthread";
 }
 
 target files("src/extra/*.cpp").replace("src/extra/","").replace(".cpp","")
 {
-        input "src/extra/${OUTPUT}.cpp";
-        rule "exe";
-        requires "libbu++.a";
-        CXXFLAGS += "-I.";
-        LDFLAGS += "-L. -lbu++";
+    input "src/extra/${OUTPUT}.cpp";
+    rule "exe";
+    requires "libbu++.a";
+    CXXFLAGS += "-I.";
+    LDFLAGS += "-L. -lbu++";
 }
 
 //
@@ -173,17 +173,17 @@ target files("src/extra/*.cpp").replace("src/extra/","").replace(".cpp","")
 //
 target "src/extra/myriadfs.o"
 {
-        CXXFLAGS += "-D_FILE_OFFSET_BITS=64";
+    CXXFLAGS += "-D_FILE_OFFSET_BITS=64";
 }
 
 target "myriadfs"
 {
-        LDFLAGS += "-lfuse";
+    LDFLAGS += "-lfuse";
 }
 
 target "bin2cpp"
 {
-        LDFLAGS += "-lz -lbz2 -llzma";
+    LDFLAGS += "-lz -lbz2 -llzma";
 }
 
 //
@@ -192,34 +192,34 @@ target "bin2cpp"
 
 target files("src/tests/*.cpp").replace("src/","").replace(".cpp","")
 {
-        input "src/${OUTPUT}.cpp";
-        rule "exe";
-        requires "libbu++.a";
-        tag ["tests", "general tests"];
-        CXXFLAGS += "-I.";
-        LDFLAGS += "-L. -lbu++";
+    input "src/${OUTPUT}.cpp";
+    rule "exe";
+    requires "libbu++.a";
+    tag ["tests", "general tests"];
+    CXXFLAGS += "-I.";
+    LDFLAGS += "-L. -lbu++";
 }
 
 // Some tests need extra libs and whatnot, that goes here.
 
 target ["tests/bzip2", "tests/streamstack"]
 {
-        LDFLAGS += "-lbz2";
+    LDFLAGS += "-lbz2";
 }
 
 target ["tests/deflate", "tests/enc"]
 {
-        LDFLAGS += "-lz";
+    LDFLAGS += "-lz";
 }
 
 target ["tests/lzma"]
 {
-        LDFLAGS += "-llzma";
+    LDFLAGS += "-llzma";
 }
 
 target ["tests/threadid"]
 {
-        LDFLAGS += "-lpthread";
+    LDFLAGS += "-lpthread";
 }
 
 //
@@ -228,106 +228,106 @@ target ["tests/threadid"]
 
 target files("src/unit/*.unit").replace("src/","").replace(".unit","")
 {
-        input "src/${OUTPUT}.unit";
-        rule "exe";
-        requires "libbu++.a";
-        tag ["tests", "unit tests"];
-        CXXFLAGS += "-I.";
-        LDFLAGS += "-L. -lbu++";
+    input "src/${OUTPUT}.unit";
+    rule "exe";
+    requires "libbu++.a";
+    tag ["tests", "unit tests"];
+    CXXFLAGS += "-I.";
+    LDFLAGS += "-L. -lbu++";
 }
 
 PKG_BASE = "libbu++-$(cat version)-r$(svnversion "-n").tar";
 
 target PKG_BASE
 {
-        input [
-                "LICENSE",
-                "Doxyfile",
-                "Makefile",
-                "version",
-                files("*.bld"),
-                "support/vim/syntax/taf.vim",
-                "support/vim/ftdetect/taf.vim",
-                "support/vim/ftplugin/taf.vim",
-                files("*.sh"),
-                files("autoconfig.cpp"),
-                files("src/*.cpp"),
-                files("src/*.h"),
-                files("src/stable/*.cpp"),
-                files("src/stable/*.h"),
-                files("src/unstable/*.cpp"),
-                files("src/unstable/*.h"),
-                files("src/experimental/*.cpp"),
-                files("src/experimental/*.h"),
-                files("src/tests/*.cpp"),
-                files("src/tests*.h"),
-                files("src/tools/*.cpp"),
-                files("src/tools/*.h"),
-                files("src/unit/*.unit"),
-                files("src/doxy/*.dox"),
-                files("src/compat/*.cpp"),
-                files("src/compat/*.h"),
-                files("src/extra/*.cpp"),
-                files("src/extra/*.h"),
-                files("pregen/*"),
-                "api"
-                ];
-        rule "tarball";
-        tag "pkg";
+    input [
+        "LICENSE",
+        "Doxyfile",
+        "Makefile",
+        "version",
+        files("*.bld"),
+        "support/vim/syntax/taf.vim",
+        "support/vim/ftdetect/taf.vim",
+        "support/vim/ftplugin/taf.vim",
+        files("*.sh"),
+        files("autoconfig.cpp"),
+        files("src/*.cpp"),
+        files("src/*.h"),
+        files("src/stable/*.cpp"),
+        files("src/stable/*.h"),
+        files("src/unstable/*.cpp"),
+        files("src/unstable/*.h"),
+        files("src/experimental/*.cpp"),
+        files("src/experimental/*.h"),
+        files("src/tests/*.cpp"),
+        files("src/tests*.h"),
+        files("src/tools/*.cpp"),
+        files("src/tools/*.h"),
+        files("src/unit/*.unit"),
+        files("src/doxy/*.dox"),
+        files("src/compat/*.cpp"),
+        files("src/compat/*.h"),
+        files("src/extra/*.cpp"),
+        files("src/extra/*.h"),
+        files("pregen/*"),
+        "api"
+        ];
+    rule "tarball";
+    tag "pkg";
 }
 
 target PKG_BASE + ".gz"
 {
-        input PKG_BASE;
-        tag "pkg";
-        display "gzip";
-        profile "build"
-        {
-                execute("gzip -9 < ${INPUT} > ${OUTPUT}");
-        }
+    input PKG_BASE;
+    tag "pkg";
+    display "gzip";
+    profile "build"
+    {
+        execute("gzip -9 < ${INPUT} > ${OUTPUT}");
+    }
 }
 
 target PKG_BASE + ".bz2"
 {
-        input PKG_BASE;
-        tag "pkg";
-        display "bzip2";
-        profile "build"
-        {
-                execute("bzip2 -9 < ${INPUT} > ${OUTPUT}");
-        }
+    input PKG_BASE;
+    tag "pkg";
+    display "bzip2";
+    profile "build"
+    {
+        execute("bzip2 -9 < ${INPUT} > ${OUTPUT}");
+    }
 }
 
 target PKG_BASE + ".xz"
 {
-        input PKG_BASE;
-        tag "pkg";
-        display "xz";
-        profile "build"
-        {
-                execute("xz -9vv < ${INPUT} > ${OUTPUT}");
-        }
+    input PKG_BASE;
+    tag "pkg";
+    display "xz";
+    profile "build"
+    {
+        execute("xz -9vv < ${INPUT} > ${OUTPUT}");
+    }
 }
 
 rule "tarball"
 {
-        input matches("LICENSE", "Makefile", "*.cpp", "*.h", "*.conf", "*.bld",
-                "Doxyfile", "*.vim", "*.sh", "*.unit", "api", "version");
-        profile "build"
-        {
-                OUTDIR = OUTPUT.replace(".tar","");
-                execute("tar -f ./${OUTPUT} --transform=\"s@^@${OUTDIR}/@\" -c ${INPUT}");
-        }
+    input matches("LICENSE", "Makefile", "*.cpp", "*.h", "*.conf", "*.bld",
+        "Doxyfile", "*.vim", "*.sh", "*.unit", "api", "version");
+    profile "build"
+    {
+        OUTDIR = OUTPUT.replace(".tar","");
+        execute("tar -f ./${OUTPUT} --transform=\"s@^@${OUTDIR}/@\" -c ${INPUT}");
+    }
 }
 
 rule "unit"
 {
-        input "*.unit";
-        output INPUT.replace(".unit", ".cpp");
+    input "*.unit";
+    output INPUT.replace(".unit", ".cpp");
 
-        profile "build"
-        {
-                execute("./mkunit \"${INPUT}\" \"${OUTPUT}\"");
-        }
+    profile "build"
+    {
+        execute("./mkunit \"${INPUT}\" \"${OUTPUT}\"");
+    }
 }
 
diff --git a/mingw.bld b/mingw.bld
index fe2f763..6339df9 100644
--- a/mingw.bld
+++ b/mingw.bld
@@ -13,90 +13,90 @@ CXXFLAGS += "-ggdb -W -Wall";
 
 action "default"
 {
-        build: [targets("header-links"), "libbu++win.a"];
+    build: [targets("header-links"), "libbu++win.a"];
 }
 
 for base in ["stable", "unstable", "experimental"] do
 {
-        target files("src/${base}/*.h").replace("src/${base}/", "bu/")
-        {
-                tag "header-links";
-                display "symlink";
-                input OUTPUT.replace("bu/","src/${base}/");
-                profile "build"
-                {
-                        DIR = OUTPUT.dirName();
-                        execute("mkdir -p ${DIR}; ln -s ../${INPUT} ${OUTPUT}");
-                }
-        }
+    target files("src/${base}/*.h").replace("src/${base}/", "bu/")
+    {
+        tag "header-links";
+        display "symlink";
+        input OUTPUT.replace("bu/","src/${base}/");
+        profile "build"
+        {
+            DIR = OUTPUT.dirName();
+            execute("mkdir -p ${DIR}; ln -s ../${INPUT} ${OUTPUT}");
+        }
+    }
 }
 target files("src/compat/*.h").replace("src/", "bu/")
 {
-        tag "header-links";
-        display "symlink";
-        input OUTPUT.replace("bu/","src/");
-        profile "build"
-        {
-                execute("mkdir -p $(dirname ${OUTPUT}); ln -s ../../${INPUT} ${OUTPUT}");
-        }
+    tag "header-links";
+    display "symlink";
+    input OUTPUT.replace("bu/","src/");
+    profile "build"
+    {
+        execute("mkdir -p $(dirname ${OUTPUT}); ln -s ../../${INPUT} ${OUTPUT}");
+    }
 }
 target ["bu/config.h", "bu/autoconfig.h", "bu/version.h", "bu/signals.h"]
 {
-        tag "header-links";
-        display "symlink";
-        input OUTPUT.replace("bu/","src/");
-        profile "build"
-        {
-                DIR = OUTPUT.dirName();
-                execute("mkdir -p ${DIR}; ln -s ../${INPUT} ${OUTPUT}");
-        }
+    tag "header-links";
+    display "symlink";
+    input OUTPUT.replace("bu/","src/");
+    profile "build"
+    {
+        DIR = OUTPUT.dirName();
+        execute("mkdir -p ${DIR}; ln -s ../${INPUT} ${OUTPUT}");
+    }
 }
 
 target "libbu++win.a"
 {
-        input files("src/stable/*.cpp", "src/unstable/*.cpp",
-                "src/experimental/*.cpp", "src/compat/*.cpp");
-        rule "lib";
-        CXXFLAGS += "-I. -Isupport/windows";
+    input files("src/stable/*.cpp", "src/unstable/*.cpp",
+        "src/experimental/*.cpp", "src/compat/*.cpp");
+    rule "lib";
+    CXXFLAGS += "-I. -Isupport/windows";
 }
 
 target ["src/stable/lzma.win_o", "src/experimental/cachestorefiles.win_o", "src/experimental/regex.win_o"]
 {
-        profile "build"
-        {
-                execute("rm -f ${OUTPUT} && touch ${OUTPUT} && echo NOT BUILDING ${OUTPUT}");
-        }
+    profile "build"
+    {
+        execute("rm -f ${OUTPUT} && touch ${OUTPUT} && echo NOT BUILDING ${OUTPUT}");
+    }
 }
 
 function cppToWinObj()
 {
-        if OBJ_DIR == null then
-        {
-                return INPUT.regex("\\.cpp$", ".win_o");
-        }
-        else
-        {
-                return OBJ_DIR + "/" + INPUT.fileName().regex("\\.cpp$", ".win_o");
-        }
+    if OBJ_DIR == null then
+    {
+        return INPUT.regex("\\.cpp$", ".win_o");
+    }
+    else
+    {
+        return OBJ_DIR + "/" + INPUT.fileName().regex("\\.cpp$", ".win_o");
+    }
 
 }
 
 rule "lib"
 {
-        input "*.win_o";
-        profile "build"
-        {
-                execute("wine C:/MinGW/bin/ar.exe cr ${OUTPUT} ${INPUT}");
-        }
+    input "*.win_o";
+    profile "build"
+    {
+        execute("wine C:/MinGW/bin/ar.exe cr ${OUTPUT} ${INPUT}");
+    }
 }
 
 rule "wincpp"
 {
-        input "*.cpp";
-        output INPUT.cppToWinObj();
-        //requires getMakeDeps("wine C:/MinGW/bin/g++.exe ${CXXFLAGS} -M ${INPUT}");
-        profile "build"
-        {
-                execute("wine C:/MinGW/bin/g++.exe ${CXXFLAGS} -c -o ${OUTPUT} ${INPUT}", "g++");
-        }
+    input "*.cpp";
+    output INPUT.cppToWinObj();
+    //requires getMakeDeps("wine C:/MinGW/bin/g++.exe ${CXXFLAGS} -M ${INPUT}");
+    profile "build"
+    {
+        execute("wine C:/MinGW/bin/g++.exe ${CXXFLAGS} -c -o ${OUTPUT} ${INPUT}", "g++");
+    }
 }
diff --git a/misc/heap.cpp b/misc/heap.cpp
index a913ef8..d558b0c 100644
--- a/misc/heap.cpp
+++ b/misc/heap.cpp
@@ -3,117 +3,117 @@
 
 void printHeap( int *aiHeap, int iHeapFill )
 {
-        printf("graph G {\n");
-        for( int j = 0; j < iHeapFill; j++ )
-        {
-                if( j*2+1 < iHeapFill )
-                        printf("    %d -- %d;\n",
-                                        j, j*2+1
-                                  );
-                if( j*2+2 < iHeapFill )
-                        printf("    %d -- %d;\n",
-                                        j, j*2+2
-                                  );
-        }
-        for( int j = 0; j < iHeapFill; j++ )
-        {
-                printf("    %d [label=\"%d\"];\n",
-                                j, aiHeap[j]
-                          );
-        }
-        printf("}\n");
+    printf("graph G {\n");
+    for( int j = 0; j < iHeapFill; j++ )
+    {
+        if( j*2+1 < iHeapFill )
+            printf("    %d -- %d;\n",
+                    j, j*2+1
+                  );
+        if( j*2+2 < iHeapFill )
+            printf("    %d -- %d;\n",
+                    j, j*2+2
+                  );
+    }
+    for( int j = 0; j < iHeapFill; j++ )
+    {
+        printf("    %d [label=\"%d\"];\n",
+                j, aiHeap[j]
+              );
+    }
+    printf("}\n");
 }
 
 void heapPush( int iNum, int *aiHeap, int &iHeapFill )
 {
-        for( int j = 0; j < iHeapFill; )
-        {
-                if( iNum < aiHeap[j] )
-                {
-                        int iTmp = aiHeap[j];
-                        aiHeap[j] = iNum;
-                        iNum = iTmp;
-                }
+    for( int j = 0; j < iHeapFill; )
+    {
+        if( iNum < aiHeap[j] )
+        {
+            int iTmp = aiHeap[j];
+            aiHeap[j] = iNum;
+            iNum = iTmp;
+        }
 
-                if( iNum <= aiHeap[j*2+1] )
-                {
-                        j = j*2+1;
-                        continue;
-                }
-                else
-                {
-                        j = j*2+2;
-                        continue;
-                }
-        }
-        aiHeap[iHeapFill] = iNum;
-        for( int j = iHeapFill; j >= 0; )
-        {
-                int k = (j-1)/2;
-                if( aiHeap[k] <= aiHeap[j] )
-                        break;
-                
-                int iTmp = aiHeap[k];
-                aiHeap[k] = aiHeap[j];
-                aiHeap[j] = iTmp;
-                j = k;
-        }
-        iHeapFill++;
+        if( iNum <= aiHeap[j*2+1] )
+        {
+            j = j*2+1;
+            continue;
+        }
+        else
+        {
+            j = j*2+2;
+            continue;
+        }
+    }
+    aiHeap[iHeapFill] = iNum;
+    for( int j = iHeapFill; j >= 0; )
+    {
+        int k = (j-1)/2;
+        if( aiHeap[k] <= aiHeap[j] )
+            break;
+        
+        int iTmp = aiHeap[k];
+        aiHeap[k] = aiHeap[j];
+        aiHeap[j] = iTmp;
+        j = k;
+    }
+    iHeapFill++;
 }
 
 int heapPop( int *aiHeap, int &iHeapFill )
 {
-        int iRet = aiHeap[0];
+    int iRet = aiHeap[0];
 
-        int j;
-        for( j = 0; j < iHeapFill; )
-        {
-                if( aiHeap[j*2+1] >= aiHeap[j*2+2] && j*2+2 < iHeapFill )
-                {
-                        aiHeap[j] = aiHeap[j*2+2];
-                        j = j*2+2;
-                }
-                else if( j*2+1 < iHeapFill )
-                {
-                        aiHeap[j] = aiHeap[j*2+1];
-                        j = j*2+1;
-                }
-                else
-                        break;
-        }
-        aiHeap[j] = aiHeap[iHeapFill-1];
-        iHeapFill--;
-        return iRet;
+    int j;
+    for( j = 0; j < iHeapFill; )
+    {
+        if( aiHeap[j*2+1] >= aiHeap[j*2+2] && j*2+2 < iHeapFill )
+        {
+            aiHeap[j] = aiHeap[j*2+2];
+            j = j*2+2;
+        }
+        else if( j*2+1 < iHeapFill )
+        {
+            aiHeap[j] = aiHeap[j*2+1];
+            j = j*2+1;
+        }
+        else
+            break;
+    }
+    aiHeap[j] = aiHeap[iHeapFill-1];
+    iHeapFill--;
+    return iRet;
 }
 
 int main( int argc, char *argv[] )
 {
-        int *aiHeap = new int[40];
-        int iHeapFill = 0;
+    int *aiHeap = new int[40];
+    int iHeapFill = 0;
 
-        int iNums = atoi( argv[1] );
-        int iOffs = atoi( argv[2] );
-        char cDo = argv[3][0];
+    int iNums = atoi( argv[1] );
+    int iOffs = atoi( argv[2] );
+    char cDo = argv[3][0];
 
-        for( int j = 0; j < iNums; j++ )
-        {
-                int iNum = rand()%20;
-                if( cDo == 'y' ) printf("%d ", iNum );
-                heapPush( iNum, aiHeap, iHeapFill );
-        }
-        if( cDo == 'y' ) printf("\n");
+    for( int j = 0; j < iNums; j++ )
+    {
+        int iNum = rand()%20;
+        if( cDo == 'y' ) printf("%d ", iNum );
+        heapPush( iNum, aiHeap, iHeapFill );
+    }
+    if( cDo == 'y' ) printf("\n");
 
-        for( int j = 0; j < iOffs; j++ )
-        {
-                if( cDo == 'y' )
-                        printf("%d ", heapPop( aiHeap, iHeapFill ) );
-                else
-                        heapPop( aiHeap, iHeapFill );
-        }
-        if( cDo == 'y' ) printf("\n");
-        else printHeap( aiHeap, iHeapFill );
+    for( int j = 0; j < iOffs; j++ )
+    {
+        if( cDo == 'y' )
+            printf("%d ", heapPop( aiHeap, iHeapFill ) );
+        else
+            heapPop( aiHeap, iHeapFill );
+    }
+    if( cDo == 'y' ) printf("\n");
+    else printHeap( aiHeap, iHeapFill );
 
-        delete[] aiHeap;
-        return 0;
+    delete[] aiHeap;
+    return 0;
 }
 
diff --git a/pregen/signals.h b/pregen/signals.h
index 6020e59..27364da 100644
--- a/pregen/signals.h
+++ b/pregen/signals.h
@@ -13,1194 +13,1194 @@
 
 namespace Bu
 {
-        subExceptionDecl( SignalException );
+    subExceptionDecl( SignalException );
 
 #ifndef BU_SIGNAL_PARAM_COUNT_0
 #define BU_SIGNAL_PARAM_COUNT_0
-        //
-        // 0 Parameter(s)
-        //
-        template<typename ret>
-        class _Slot0
-        {
-        public:
-                _Slot0() { }
-                virtual ~_Slot0() { }
-                virtual ret operator()(  )=0;
-                virtual _Slot0<ret> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret>
-        class __Slot0 : public _Slot0<ret>
-        {
-        public:
-                __Slot0( cls *pCls, ret (cls::*pFnc)(  ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot0() { }
-        
-                virtual ret operator()(  )
-                {
-                        return (pCls->*pFnc)(  );
-                }
-        
-                virtual _Slot0<ret> *clone() const
-                {
-                        return new __Slot0<cls, ret>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)(  );
-        };
-        
-        template<typename ret>
-        class __Slot0F : public _Slot0<ret>
-        {
-        public:
-                __Slot0F( ret (*pFnc)(  ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot0F() { }
-        
-                virtual ret operator()(  )
-                {
-                        return (*pFnc)(  );
-                }
-        
-                virtual _Slot0<ret> *clone() const
-                {
-                        return new __Slot0F<ret>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)(  );
-        };
-        
-        template<typename ret>
-        class Signal0
-        {
-        public:
-                Signal0() : pCb( NULL ) { }
-                Signal0( _Slot0<ret> *pCb ) : pCb( pCb ) { }
-                Signal0( const Signal0<ret> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal0() { delete pCb; pCb = NULL; }
-        
-                ret operator()(  )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)(  );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal0<ret> &operator=( const Signal0<ret> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot0<ret> *pCb;
-        };
-        
-        template<typename cls, typename ret>
-        Signal0<ret> slot( cls *pCls, ret (cls::*pFnc)(  ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal0<ret>(
-                        new __Slot0<cls, ret>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret>
-        Signal0<ret> slot( ret (*pFnc)(  ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal0<ret>(
-                        new __Slot0F<ret>( pFnc )
-                        );
-        }
+    //
+    // 0 Parameter(s)
+    //
+    template<typename ret>
+    class _Slot0
+    {
+    public:
+        _Slot0() { }
+        virtual ~_Slot0() { }
+        virtual ret operator()(  )=0;
+        virtual _Slot0<ret> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret>
+    class __Slot0 : public _Slot0<ret>
+    {
+    public:
+        __Slot0( cls *pCls, ret (cls::*pFnc)(  ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot0() { }
+    
+        virtual ret operator()(  )
+        {
+            return (pCls->*pFnc)(  );
+        }
+    
+        virtual _Slot0<ret> *clone() const
+        {
+            return new __Slot0<cls, ret>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)(  );
+    };
+    
+    template<typename ret>
+    class __Slot0F : public _Slot0<ret>
+    {
+    public:
+        __Slot0F( ret (*pFnc)(  ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot0F() { }
+    
+        virtual ret operator()(  )
+        {
+            return (*pFnc)(  );
+        }
+    
+        virtual _Slot0<ret> *clone() const
+        {
+            return new __Slot0F<ret>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)(  );
+    };
+    
+    template<typename ret>
+    class Signal0
+    {
+    public:
+        Signal0() : pCb( NULL ) { }
+        Signal0( _Slot0<ret> *pCb ) : pCb( pCb ) { }
+        Signal0( const Signal0<ret> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal0() { delete pCb; pCb = NULL; }
+    
+        ret operator()(  )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)(  );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal0<ret> &operator=( const Signal0<ret> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot0<ret> *pCb;
+    };
+    
+    template<typename cls, typename ret>
+    Signal0<ret> slot( cls *pCls, ret (cls::*pFnc)(  ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal0<ret>(
+            new __Slot0<cls, ret>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret>
+    Signal0<ret> slot( ret (*pFnc)(  ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal0<ret>(
+            new __Slot0F<ret>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_0
 
 #ifndef BU_SIGNAL_PARAM_COUNT_1
 #define BU_SIGNAL_PARAM_COUNT_1
-        //
-        // 1 Parameter(s)
-        //
-        template<typename ret, typename p1t>
-        class _Slot1
-        {
-        public:
-                _Slot1() { }
-                virtual ~_Slot1() { }
-                virtual ret operator()( p1t p1 )=0;
-                virtual _Slot1<ret, p1t> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret, typename p1t>
-        class __Slot1 : public _Slot1<ret, p1t>
-        {
-        public:
-                __Slot1( cls *pCls, ret (cls::*pFnc)( p1t ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot1() { }
-        
-                virtual ret operator()( p1t p1 )
-                {
-                        return (pCls->*pFnc)( p1 );
-                }
-        
-                virtual _Slot1<ret, p1t> *clone() const
-                {
-                        return new __Slot1<cls, ret, p1t>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)( p1t );
-        };
-        
-        template<typename ret, typename p1t>
-        class __Slot1F : public _Slot1<ret, p1t>
-        {
-        public:
-                __Slot1F( ret (*pFnc)( p1t ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot1F() { }
-        
-                virtual ret operator()( p1t p1 )
-                {
-                        return (*pFnc)( p1 );
-                }
-        
-                virtual _Slot1<ret, p1t> *clone() const
-                {
-                        return new __Slot1F<ret, p1t>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)( p1t );
-        };
-        
-        template<typename ret, typename p1t>
-        class Signal1
-        {
-        public:
-                Signal1() : pCb( NULL ) { }
-                Signal1( _Slot1<ret, p1t> *pCb ) : pCb( pCb ) { }
-                Signal1( const Signal1<ret, p1t> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal1() { delete pCb; pCb = NULL; }
-        
-                ret operator()( p1t p1 )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)( p1 );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal1<ret, p1t> &operator=( const Signal1<ret, p1t> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot1<ret, p1t> *pCb;
-        };
-        
-        template<typename cls, typename ret, typename p1t>
-        Signal1<ret, p1t> slot( cls *pCls, ret (cls::*pFnc)( p1t ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal1<ret, p1t>(
-                        new __Slot1<cls, ret, p1t>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret, typename p1t>
-        Signal1<ret, p1t> slot( ret (*pFnc)( p1t ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal1<ret, p1t>(
-                        new __Slot1F<ret, p1t>( pFnc )
-                        );
-        }
+    //
+    // 1 Parameter(s)
+    //
+    template<typename ret, typename p1t>
+    class _Slot1
+    {
+    public:
+        _Slot1() { }
+        virtual ~_Slot1() { }
+        virtual ret operator()( p1t p1 )=0;
+        virtual _Slot1<ret, p1t> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret, typename p1t>
+    class __Slot1 : public _Slot1<ret, p1t>
+    {
+    public:
+        __Slot1( cls *pCls, ret (cls::*pFnc)( p1t ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot1() { }
+    
+        virtual ret operator()( p1t p1 )
+        {
+            return (pCls->*pFnc)( p1 );
+        }
+    
+        virtual _Slot1<ret, p1t> *clone() const
+        {
+            return new __Slot1<cls, ret, p1t>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)( p1t );
+    };
+    
+    template<typename ret, typename p1t>
+    class __Slot1F : public _Slot1<ret, p1t>
+    {
+    public:
+        __Slot1F( ret (*pFnc)( p1t ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot1F() { }
+    
+        virtual ret operator()( p1t p1 )
+        {
+            return (*pFnc)( p1 );
+        }
+    
+        virtual _Slot1<ret, p1t> *clone() const
+        {
+            return new __Slot1F<ret, p1t>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)( p1t );
+    };
+    
+    template<typename ret, typename p1t>
+    class Signal1
+    {
+    public:
+        Signal1() : pCb( NULL ) { }
+        Signal1( _Slot1<ret, p1t> *pCb ) : pCb( pCb ) { }
+        Signal1( const Signal1<ret, p1t> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal1() { delete pCb; pCb = NULL; }
+    
+        ret operator()( p1t p1 )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)( p1 );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal1<ret, p1t> &operator=( const Signal1<ret, p1t> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot1<ret, p1t> *pCb;
+    };
+    
+    template<typename cls, typename ret, typename p1t>
+    Signal1<ret, p1t> slot( cls *pCls, ret (cls::*pFnc)( p1t ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal1<ret, p1t>(
+            new __Slot1<cls, ret, p1t>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret, typename p1t>
+    Signal1<ret, p1t> slot( ret (*pFnc)( p1t ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal1<ret, p1t>(
+            new __Slot1F<ret, p1t>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_1
 
 #ifndef BU_SIGNAL_PARAM_COUNT_2
 #define BU_SIGNAL_PARAM_COUNT_2
-        //
-        // 2 Parameter(s)
-        //
-        template<typename ret, typename p1t, typename p2t>
-        class _Slot2
-        {
-        public:
-                _Slot2() { }
-                virtual ~_Slot2() { }
-                virtual ret operator()( p1t p1, p2t p2 )=0;
-                virtual _Slot2<ret, p1t, p2t> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t>
-        class __Slot2 : public _Slot2<ret, p1t, p2t>
-        {
-        public:
-                __Slot2( cls *pCls, ret (cls::*pFnc)( p1t, p2t ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot2() { }
-        
-                virtual ret operator()( p1t p1, p2t p2 )
-                {
-                        return (pCls->*pFnc)( p1, p2 );
-                }
-        
-                virtual _Slot2<ret, p1t, p2t> *clone() const
-                {
-                        return new __Slot2<cls, ret, p1t, p2t>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)( p1t, p2t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t>
-        class __Slot2F : public _Slot2<ret, p1t, p2t>
-        {
-        public:
-                __Slot2F( ret (*pFnc)( p1t, p2t ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot2F() { }
-        
-                virtual ret operator()( p1t p1, p2t p2 )
-                {
-                        return (*pFnc)( p1, p2 );
-                }
-        
-                virtual _Slot2<ret, p1t, p2t> *clone() const
-                {
-                        return new __Slot2F<ret, p1t, p2t>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)( p1t, p2t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t>
-        class Signal2
-        {
-        public:
-                Signal2() : pCb( NULL ) { }
-                Signal2( _Slot2<ret, p1t, p2t> *pCb ) : pCb( pCb ) { }
-                Signal2( const Signal2<ret, p1t, p2t> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal2() { delete pCb; pCb = NULL; }
-        
-                ret operator()( p1t p1, p2t p2 )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)( p1, p2 );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal2<ret, p1t, p2t> &operator=( const Signal2<ret, p1t, p2t> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot2<ret, p1t, p2t> *pCb;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t>
-        Signal2<ret, p1t, p2t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal2<ret, p1t, p2t>(
-                        new __Slot2<cls, ret, p1t, p2t>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret, typename p1t, typename p2t>
-        Signal2<ret, p1t, p2t> slot( ret (*pFnc)( p1t, p2t ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal2<ret, p1t, p2t>(
-                        new __Slot2F<ret, p1t, p2t>( pFnc )
-                        );
-        }
+    //
+    // 2 Parameter(s)
+    //
+    template<typename ret, typename p1t, typename p2t>
+    class _Slot2
+    {
+    public:
+        _Slot2() { }
+        virtual ~_Slot2() { }
+        virtual ret operator()( p1t p1, p2t p2 )=0;
+        virtual _Slot2<ret, p1t, p2t> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t>
+    class __Slot2 : public _Slot2<ret, p1t, p2t>
+    {
+    public:
+        __Slot2( cls *pCls, ret (cls::*pFnc)( p1t, p2t ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot2() { }
+    
+        virtual ret operator()( p1t p1, p2t p2 )
+        {
+            return (pCls->*pFnc)( p1, p2 );
+        }
+    
+        virtual _Slot2<ret, p1t, p2t> *clone() const
+        {
+            return new __Slot2<cls, ret, p1t, p2t>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)( p1t, p2t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t>
+    class __Slot2F : public _Slot2<ret, p1t, p2t>
+    {
+    public:
+        __Slot2F( ret (*pFnc)( p1t, p2t ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot2F() { }
+    
+        virtual ret operator()( p1t p1, p2t p2 )
+        {
+            return (*pFnc)( p1, p2 );
+        }
+    
+        virtual _Slot2<ret, p1t, p2t> *clone() const
+        {
+            return new __Slot2F<ret, p1t, p2t>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)( p1t, p2t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t>
+    class Signal2
+    {
+    public:
+        Signal2() : pCb( NULL ) { }
+        Signal2( _Slot2<ret, p1t, p2t> *pCb ) : pCb( pCb ) { }
+        Signal2( const Signal2<ret, p1t, p2t> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal2() { delete pCb; pCb = NULL; }
+    
+        ret operator()( p1t p1, p2t p2 )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)( p1, p2 );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal2<ret, p1t, p2t> &operator=( const Signal2<ret, p1t, p2t> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot2<ret, p1t, p2t> *pCb;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t>
+    Signal2<ret, p1t, p2t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal2<ret, p1t, p2t>(
+            new __Slot2<cls, ret, p1t, p2t>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret, typename p1t, typename p2t>
+    Signal2<ret, p1t, p2t> slot( ret (*pFnc)( p1t, p2t ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal2<ret, p1t, p2t>(
+            new __Slot2F<ret, p1t, p2t>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_2
 
 #ifndef BU_SIGNAL_PARAM_COUNT_3
 #define BU_SIGNAL_PARAM_COUNT_3
-        //
-        // 3 Parameter(s)
-        //
-        template<typename ret, typename p1t, typename p2t, typename p3t>
-        class _Slot3
-        {
-        public:
-                _Slot3() { }
-                virtual ~_Slot3() { }
-                virtual ret operator()( p1t p1, p2t p2, p3t p3 )=0;
-                virtual _Slot3<ret, p1t, p2t, p3t> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t>
-        class __Slot3 : public _Slot3<ret, p1t, p2t, p3t>
-        {
-        public:
-                __Slot3( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot3() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3 )
-                {
-                        return (pCls->*pFnc)( p1, p2, p3 );
-                }
-        
-                virtual _Slot3<ret, p1t, p2t, p3t> *clone() const
-                {
-                        return new __Slot3<cls, ret, p1t, p2t, p3t>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)( p1t, p2t, p3t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t>
-        class __Slot3F : public _Slot3<ret, p1t, p2t, p3t>
-        {
-        public:
-                __Slot3F( ret (*pFnc)( p1t, p2t, p3t ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot3F() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3 )
-                {
-                        return (*pFnc)( p1, p2, p3 );
-                }
-        
-                virtual _Slot3<ret, p1t, p2t, p3t> *clone() const
-                {
-                        return new __Slot3F<ret, p1t, p2t, p3t>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)( p1t, p2t, p3t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t>
-        class Signal3
-        {
-        public:
-                Signal3() : pCb( NULL ) { }
-                Signal3( _Slot3<ret, p1t, p2t, p3t> *pCb ) : pCb( pCb ) { }
-                Signal3( const Signal3<ret, p1t, p2t, p3t> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal3() { delete pCb; pCb = NULL; }
-        
-                ret operator()( p1t p1, p2t p2, p3t p3 )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)( p1, p2, p3 );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal3<ret, p1t, p2t, p3t> &operator=( const Signal3<ret, p1t, p2t, p3t> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot3<ret, p1t, p2t, p3t> *pCb;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t>
-        Signal3<ret, p1t, p2t, p3t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal3<ret, p1t, p2t, p3t>(
-                        new __Slot3<cls, ret, p1t, p2t, p3t>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t>
-        Signal3<ret, p1t, p2t, p3t> slot( ret (*pFnc)( p1t, p2t, p3t ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal3<ret, p1t, p2t, p3t>(
-                        new __Slot3F<ret, p1t, p2t, p3t>( pFnc )
-                        );
-        }
+    //
+    // 3 Parameter(s)
+    //
+    template<typename ret, typename p1t, typename p2t, typename p3t>
+    class _Slot3
+    {
+    public:
+        _Slot3() { }
+        virtual ~_Slot3() { }
+        virtual ret operator()( p1t p1, p2t p2, p3t p3 )=0;
+        virtual _Slot3<ret, p1t, p2t, p3t> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t>
+    class __Slot3 : public _Slot3<ret, p1t, p2t, p3t>
+    {
+    public:
+        __Slot3( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot3() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3 )
+        {
+            return (pCls->*pFnc)( p1, p2, p3 );
+        }
+    
+        virtual _Slot3<ret, p1t, p2t, p3t> *clone() const
+        {
+            return new __Slot3<cls, ret, p1t, p2t, p3t>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)( p1t, p2t, p3t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t>
+    class __Slot3F : public _Slot3<ret, p1t, p2t, p3t>
+    {
+    public:
+        __Slot3F( ret (*pFnc)( p1t, p2t, p3t ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot3F() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3 )
+        {
+            return (*pFnc)( p1, p2, p3 );
+        }
+    
+        virtual _Slot3<ret, p1t, p2t, p3t> *clone() const
+        {
+            return new __Slot3F<ret, p1t, p2t, p3t>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)( p1t, p2t, p3t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t>
+    class Signal3
+    {
+    public:
+        Signal3() : pCb( NULL ) { }
+        Signal3( _Slot3<ret, p1t, p2t, p3t> *pCb ) : pCb( pCb ) { }
+        Signal3( const Signal3<ret, p1t, p2t, p3t> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal3() { delete pCb; pCb = NULL; }
+    
+        ret operator()( p1t p1, p2t p2, p3t p3 )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)( p1, p2, p3 );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal3<ret, p1t, p2t, p3t> &operator=( const Signal3<ret, p1t, p2t, p3t> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot3<ret, p1t, p2t, p3t> *pCb;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t>
+    Signal3<ret, p1t, p2t, p3t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal3<ret, p1t, p2t, p3t>(
+            new __Slot3<cls, ret, p1t, p2t, p3t>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t>
+    Signal3<ret, p1t, p2t, p3t> slot( ret (*pFnc)( p1t, p2t, p3t ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal3<ret, p1t, p2t, p3t>(
+            new __Slot3F<ret, p1t, p2t, p3t>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_3
 
 #ifndef BU_SIGNAL_PARAM_COUNT_4
 #define BU_SIGNAL_PARAM_COUNT_4
-        //
-        // 4 Parameter(s)
-        //
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
-        class _Slot4
-        {
-        public:
-                _Slot4() { }
-                virtual ~_Slot4() { }
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )=0;
-                virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
-        class __Slot4 : public _Slot4<ret, p1t, p2t, p3t, p4t>
-        {
-        public:
-                __Slot4( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot4() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )
-                {
-                        return (pCls->*pFnc)( p1, p2, p3, p4 );
-                }
-        
-                virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const
-                {
-                        return new __Slot4<cls, ret, p1t, p2t, p3t, p4t>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)( p1t, p2t, p3t, p4t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
-        class __Slot4F : public _Slot4<ret, p1t, p2t, p3t, p4t>
-        {
-        public:
-                __Slot4F( ret (*pFnc)( p1t, p2t, p3t, p4t ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot4F() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )
-                {
-                        return (*pFnc)( p1, p2, p3, p4 );
-                }
-        
-                virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const
-                {
-                        return new __Slot4F<ret, p1t, p2t, p3t, p4t>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)( p1t, p2t, p3t, p4t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
-        class Signal4
-        {
-        public:
-                Signal4() : pCb( NULL ) { }
-                Signal4( _Slot4<ret, p1t, p2t, p3t, p4t> *pCb ) : pCb( pCb ) { }
-                Signal4( const Signal4<ret, p1t, p2t, p3t, p4t> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal4() { delete pCb; pCb = NULL; }
-        
-                ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)( p1, p2, p3, p4 );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal4<ret, p1t, p2t, p3t, p4t> &operator=( const Signal4<ret, p1t, p2t, p3t, p4t> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot4<ret, p1t, p2t, p3t, p4t> *pCb;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
-        Signal4<ret, p1t, p2t, p3t, p4t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal4<ret, p1t, p2t, p3t, p4t>(
-                        new __Slot4<cls, ret, p1t, p2t, p3t, p4t>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
-        Signal4<ret, p1t, p2t, p3t, p4t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal4<ret, p1t, p2t, p3t, p4t>(
-                        new __Slot4F<ret, p1t, p2t, p3t, p4t>( pFnc )
-                        );
-        }
+    //
+    // 4 Parameter(s)
+    //
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+    class _Slot4
+    {
+    public:
+        _Slot4() { }
+        virtual ~_Slot4() { }
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )=0;
+        virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+    class __Slot4 : public _Slot4<ret, p1t, p2t, p3t, p4t>
+    {
+    public:
+        __Slot4( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot4() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )
+        {
+            return (pCls->*pFnc)( p1, p2, p3, p4 );
+        }
+    
+        virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const
+        {
+            return new __Slot4<cls, ret, p1t, p2t, p3t, p4t>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)( p1t, p2t, p3t, p4t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+    class __Slot4F : public _Slot4<ret, p1t, p2t, p3t, p4t>
+    {
+    public:
+        __Slot4F( ret (*pFnc)( p1t, p2t, p3t, p4t ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot4F() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )
+        {
+            return (*pFnc)( p1, p2, p3, p4 );
+        }
+    
+        virtual _Slot4<ret, p1t, p2t, p3t, p4t> *clone() const
+        {
+            return new __Slot4F<ret, p1t, p2t, p3t, p4t>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)( p1t, p2t, p3t, p4t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+    class Signal4
+    {
+    public:
+        Signal4() : pCb( NULL ) { }
+        Signal4( _Slot4<ret, p1t, p2t, p3t, p4t> *pCb ) : pCb( pCb ) { }
+        Signal4( const Signal4<ret, p1t, p2t, p3t, p4t> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal4() { delete pCb; pCb = NULL; }
+    
+        ret operator()( p1t p1, p2t p2, p3t p3, p4t p4 )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)( p1, p2, p3, p4 );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal4<ret, p1t, p2t, p3t, p4t> &operator=( const Signal4<ret, p1t, p2t, p3t, p4t> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot4<ret, p1t, p2t, p3t, p4t> *pCb;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+    Signal4<ret, p1t, p2t, p3t, p4t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal4<ret, p1t, p2t, p3t, p4t>(
+            new __Slot4<cls, ret, p1t, p2t, p3t, p4t>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t>
+    Signal4<ret, p1t, p2t, p3t, p4t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal4<ret, p1t, p2t, p3t, p4t>(
+            new __Slot4F<ret, p1t, p2t, p3t, p4t>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_4
 
 #ifndef BU_SIGNAL_PARAM_COUNT_5
 #define BU_SIGNAL_PARAM_COUNT_5
-        //
-        // 5 Parameter(s)
-        //
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
-        class _Slot5
-        {
-        public:
-                _Slot5() { }
-                virtual ~_Slot5() { }
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )=0;
-                virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
-        class __Slot5 : public _Slot5<ret, p1t, p2t, p3t, p4t, p5t>
-        {
-        public:
-                __Slot5( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot5() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
-                {
-                        return (pCls->*pFnc)( p1, p2, p3, p4, p5 );
-                }
-        
-                virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const
-                {
-                        return new __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
-        class __Slot5F : public _Slot5<ret, p1t, p2t, p3t, p4t, p5t>
-        {
-        public:
-                __Slot5F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot5F() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
-                {
-                        return (*pFnc)( p1, p2, p3, p4, p5 );
-                }
-        
-                virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const
-                {
-                        return new __Slot5F<ret, p1t, p2t, p3t, p4t, p5t>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)( p1t, p2t, p3t, p4t, p5t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
-        class Signal5
-        {
-        public:
-                Signal5() : pCb( NULL ) { }
-                Signal5( _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *pCb ) : pCb( pCb ) { }
-                Signal5( const Signal5<ret, p1t, p2t, p3t, p4t, p5t> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal5() { delete pCb; pCb = NULL; }
-        
-                ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)( p1, p2, p3, p4, p5 );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal5<ret, p1t, p2t, p3t, p4t, p5t> &operator=( const Signal5<ret, p1t, p2t, p3t, p4t, p5t> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *pCb;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
-        Signal5<ret, p1t, p2t, p3t, p4t, p5t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal5<ret, p1t, p2t, p3t, p4t, p5t>(
-                        new __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
-        Signal5<ret, p1t, p2t, p3t, p4t, p5t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal5<ret, p1t, p2t, p3t, p4t, p5t>(
-                        new __Slot5F<ret, p1t, p2t, p3t, p4t, p5t>( pFnc )
-                        );
-        }
+    //
+    // 5 Parameter(s)
+    //
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+    class _Slot5
+    {
+    public:
+        _Slot5() { }
+        virtual ~_Slot5() { }
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )=0;
+        virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+    class __Slot5 : public _Slot5<ret, p1t, p2t, p3t, p4t, p5t>
+    {
+    public:
+        __Slot5( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot5() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
+        {
+            return (pCls->*pFnc)( p1, p2, p3, p4, p5 );
+        }
+    
+        virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const
+        {
+            return new __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+    class __Slot5F : public _Slot5<ret, p1t, p2t, p3t, p4t, p5t>
+    {
+    public:
+        __Slot5F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot5F() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
+        {
+            return (*pFnc)( p1, p2, p3, p4, p5 );
+        }
+    
+        virtual _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *clone() const
+        {
+            return new __Slot5F<ret, p1t, p2t, p3t, p4t, p5t>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)( p1t, p2t, p3t, p4t, p5t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+    class Signal5
+    {
+    public:
+        Signal5() : pCb( NULL ) { }
+        Signal5( _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *pCb ) : pCb( pCb ) { }
+        Signal5( const Signal5<ret, p1t, p2t, p3t, p4t, p5t> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal5() { delete pCb; pCb = NULL; }
+    
+        ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)( p1, p2, p3, p4, p5 );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal5<ret, p1t, p2t, p3t, p4t, p5t> &operator=( const Signal5<ret, p1t, p2t, p3t, p4t, p5t> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot5<ret, p1t, p2t, p3t, p4t, p5t> *pCb;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+    Signal5<ret, p1t, p2t, p3t, p4t, p5t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal5<ret, p1t, p2t, p3t, p4t, p5t>(
+            new __Slot5<cls, ret, p1t, p2t, p3t, p4t, p5t>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t>
+    Signal5<ret, p1t, p2t, p3t, p4t, p5t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal5<ret, p1t, p2t, p3t, p4t, p5t>(
+            new __Slot5F<ret, p1t, p2t, p3t, p4t, p5t>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_5
 
 #ifndef BU_SIGNAL_PARAM_COUNT_6
 #define BU_SIGNAL_PARAM_COUNT_6
-        //
-        // 6 Parameter(s)
-        //
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
-        class _Slot6
-        {
-        public:
-                _Slot6() { }
-                virtual ~_Slot6() { }
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )=0;
-                virtual _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
-        class __Slot6 : public _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t>
-        {
-        public:
-                __Slot6( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot6() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )
-                {
-                        return (pCls->*pFnc)( p1, p2, p3, p4, p5, p6 );
-                }
-        
-                virtual _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *clone() const
-                {
-                        return new __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
-        class __Slot6F : public _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t>
-        {
-        public:
-                __Slot6F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot6F() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )
-                {
-                        return (*pFnc)( p1, p2, p3, p4, p5, p6 );
-                }
-        
-                virtual _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *clone() const
-                {
-                        return new __Slot6F<ret, p1t, p2t, p3t, p4t, p5t, p6t>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
-        class Signal6
-        {
-        public:
-                Signal6() : pCb( NULL ) { }
-                Signal6( _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *pCb ) : pCb( pCb ) { }
-                Signal6( const Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal6() { delete pCb; pCb = NULL; }
-        
-                ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)( p1, p2, p3, p4, p5, p6 );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &operator=( const Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *pCb;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
-        Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t>(
-                        new __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
-        Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t>(
-                        new __Slot6F<ret, p1t, p2t, p3t, p4t, p5t, p6t>( pFnc )
-                        );
-        }
+    //
+    // 6 Parameter(s)
+    //
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
+    class _Slot6
+    {
+    public:
+        _Slot6() { }
+        virtual ~_Slot6() { }
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )=0;
+        virtual _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
+    class __Slot6 : public _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t>
+    {
+    public:
+        __Slot6( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot6() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )
+        {
+            return (pCls->*pFnc)( p1, p2, p3, p4, p5, p6 );
+        }
+    
+        virtual _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *clone() const
+        {
+            return new __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
+    class __Slot6F : public _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t>
+    {
+    public:
+        __Slot6F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot6F() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )
+        {
+            return (*pFnc)( p1, p2, p3, p4, p5, p6 );
+        }
+    
+        virtual _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *clone() const
+        {
+            return new __Slot6F<ret, p1t, p2t, p3t, p4t, p5t, p6t>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
+    class Signal6
+    {
+    public:
+        Signal6() : pCb( NULL ) { }
+        Signal6( _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *pCb ) : pCb( pCb ) { }
+        Signal6( const Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal6() { delete pCb; pCb = NULL; }
+    
+        ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6 )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)( p1, p2, p3, p4, p5, p6 );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &operator=( const Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot6<ret, p1t, p2t, p3t, p4t, p5t, p6t> *pCb;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
+    Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t>(
+            new __Slot6<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t>
+    Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal6<ret, p1t, p2t, p3t, p4t, p5t, p6t>(
+            new __Slot6F<ret, p1t, p2t, p3t, p4t, p5t, p6t>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_6
 
 #ifndef BU_SIGNAL_PARAM_COUNT_7
 #define BU_SIGNAL_PARAM_COUNT_7
-        //
-        // 7 Parameter(s)
-        //
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
-        class _Slot7
-        {
-        public:
-                _Slot7() { }
-                virtual ~_Slot7() { }
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )=0;
-                virtual _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
-        class __Slot7 : public _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>
-        {
-        public:
-                __Slot7( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot7() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )
-                {
-                        return (pCls->*pFnc)( p1, p2, p3, p4, p5, p6, p7 );
-                }
-        
-                virtual _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *clone() const
-                {
-                        return new __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
-        class __Slot7F : public _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>
-        {
-        public:
-                __Slot7F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot7F() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )
-                {
-                        return (*pFnc)( p1, p2, p3, p4, p5, p6, p7 );
-                }
-        
-                virtual _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *clone() const
-                {
-                        return new __Slot7F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
-        class Signal7
-        {
-        public:
-                Signal7() : pCb( NULL ) { }
-                Signal7( _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *pCb ) : pCb( pCb ) { }
-                Signal7( const Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal7() { delete pCb; pCb = NULL; }
-        
-                ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)( p1, p2, p3, p4, p5, p6, p7 );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &operator=( const Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *pCb;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
-        Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>(
-                        new __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
-        Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>(
-                        new __Slot7F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pFnc )
-                        );
-        }
+    //
+    // 7 Parameter(s)
+    //
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
+    class _Slot7
+    {
+    public:
+        _Slot7() { }
+        virtual ~_Slot7() { }
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )=0;
+        virtual _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
+    class __Slot7 : public _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>
+    {
+    public:
+        __Slot7( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot7() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )
+        {
+            return (pCls->*pFnc)( p1, p2, p3, p4, p5, p6, p7 );
+        }
+    
+        virtual _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *clone() const
+        {
+            return new __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
+    class __Slot7F : public _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>
+    {
+    public:
+        __Slot7F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot7F() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )
+        {
+            return (*pFnc)( p1, p2, p3, p4, p5, p6, p7 );
+        }
+    
+        virtual _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *clone() const
+        {
+            return new __Slot7F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
+    class Signal7
+    {
+    public:
+        Signal7() : pCb( NULL ) { }
+        Signal7( _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *pCb ) : pCb( pCb ) { }
+        Signal7( const Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal7() { delete pCb; pCb = NULL; }
+    
+        ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7 )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)( p1, p2, p3, p4, p5, p6, p7 );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &operator=( const Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> *pCb;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
+    Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>(
+            new __Slot7<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t>
+    Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal7<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>(
+            new __Slot7F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_7
 
 #ifndef BU_SIGNAL_PARAM_COUNT_8
 #define BU_SIGNAL_PARAM_COUNT_8
-        //
-        // 8 Parameter(s)
-        //
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
-        class _Slot8
-        {
-        public:
-                _Slot8() { }
-                virtual ~_Slot8() { }
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )=0;
-                virtual _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
-        class __Slot8 : public _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>
-        {
-        public:
-                __Slot8( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot8() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )
-                {
-                        return (pCls->*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8 );
-                }
-        
-                virtual _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *clone() const
-                {
-                        return new __Slot8<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
-        class __Slot8F : public _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>
-        {
-        public:
-                __Slot8F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot8F() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )
-                {
-                        return (*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8 );
-                }
-        
-                virtual _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *clone() const
-                {
-                        return new __Slot8F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
-        class Signal8
-        {
-        public:
-                Signal8() : pCb( NULL ) { }
-                Signal8( _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *pCb ) : pCb( pCb ) { }
-                Signal8( const Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal8() { delete pCb; pCb = NULL; }
-        
-                ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)( p1, p2, p3, p4, p5, p6, p7, p8 );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &operator=( const Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *pCb;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
-        Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>(
-                        new __Slot8<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
-        Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>(
-                        new __Slot8F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pFnc )
-                        );
-        }
+    //
+    // 8 Parameter(s)
+    //
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
+    class _Slot8
+    {
+    public:
+        _Slot8() { }
+        virtual ~_Slot8() { }
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )=0;
+        virtual _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
+    class __Slot8 : public _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>
+    {
+    public:
+        __Slot8( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot8() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )
+        {
+            return (pCls->*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8 );
+        }
+    
+        virtual _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *clone() const
+        {
+            return new __Slot8<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
+    class __Slot8F : public _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>
+    {
+    public:
+        __Slot8F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot8F() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )
+        {
+            return (*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8 );
+        }
+    
+        virtual _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *clone() const
+        {
+            return new __Slot8F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
+    class Signal8
+    {
+    public:
+        Signal8() : pCb( NULL ) { }
+        Signal8( _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *pCb ) : pCb( pCb ) { }
+        Signal8( const Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal8() { delete pCb; pCb = NULL; }
+    
+        ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8 )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)( p1, p2, p3, p4, p5, p6, p7, p8 );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &operator=( const Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> *pCb;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
+    Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>(
+            new __Slot8<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t>
+    Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal8<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>(
+            new __Slot8F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_8
 
 #ifndef BU_SIGNAL_PARAM_COUNT_9
 #define BU_SIGNAL_PARAM_COUNT_9
-        //
-        // 9 Parameter(s)
-        //
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
-        class _Slot9
-        {
-        public:
-                _Slot9() { }
-                virtual ~_Slot9() { }
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )=0;
-                virtual _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
-        class __Slot9 : public _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>
-        {
-        public:
-                __Slot9( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot9() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )
-                {
-                        return (pCls->*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
-                }
-        
-                virtual _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *clone() const
-                {
-                        return new __Slot9<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
-        class __Slot9F : public _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>
-        {
-        public:
-                __Slot9F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot9F() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )
-                {
-                        return (*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
-                }
-        
-                virtual _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *clone() const
-                {
-                        return new __Slot9F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
-        class Signal9
-        {
-        public:
-                Signal9() : pCb( NULL ) { }
-                Signal9( _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *pCb ) : pCb( pCb ) { }
-                Signal9( const Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal9() { delete pCb; pCb = NULL; }
-        
-                ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &operator=( const Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *pCb;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
-        Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>(
-                        new __Slot9<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
-        Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>(
-                        new __Slot9F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pFnc )
-                        );
-        }
+    //
+    // 9 Parameter(s)
+    //
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
+    class _Slot9
+    {
+    public:
+        _Slot9() { }
+        virtual ~_Slot9() { }
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )=0;
+        virtual _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
+    class __Slot9 : public _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>
+    {
+    public:
+        __Slot9( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot9() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )
+        {
+            return (pCls->*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
+        }
+    
+        virtual _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *clone() const
+        {
+            return new __Slot9<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
+    class __Slot9F : public _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>
+    {
+    public:
+        __Slot9F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot9F() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )
+        {
+            return (*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
+        }
+    
+        virtual _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *clone() const
+        {
+            return new __Slot9F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
+    class Signal9
+    {
+    public:
+        Signal9() : pCb( NULL ) { }
+        Signal9( _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *pCb ) : pCb( pCb ) { }
+        Signal9( const Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal9() { delete pCb; pCb = NULL; }
+    
+        ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9 )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)( p1, p2, p3, p4, p5, p6, p7, p8, p9 );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &operator=( const Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> *pCb;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
+    Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>(
+            new __Slot9<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t>
+    Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal9<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>(
+            new __Slot9F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_9
 
 #ifndef BU_SIGNAL_PARAM_COUNT_10
 #define BU_SIGNAL_PARAM_COUNT_10
-        //
-        // 10 Parameter(s)
-        //
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
-        class _Slot10
-        {
-        public:
-                _Slot10() { }
-                virtual ~_Slot10() { }
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )=0;
-                virtual _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *clone() const=0;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
-        class __Slot10 : public _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>
-        {
-        public:
-                __Slot10( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t ) ) :
-                        pCls( pCls ), pFnc( pFnc ) { }
-                virtual ~__Slot10() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )
-                {
-                        return (pCls->*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
-                }
-        
-                virtual _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *clone() const
-                {
-                        return new __Slot10<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pCls, pFnc );
-                }
-        
-        private:
-                cls *pCls;
-                ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
-        class __Slot10F : public _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>
-        {
-        public:
-                __Slot10F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t ) ) :
-                        pFnc( pFnc ) { }
-                virtual ~__Slot10F() { }
-        
-                virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )
-                {
-                        return (*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
-                }
-        
-                virtual _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *clone() const
-                {
-                        return new __Slot10F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pFnc );
-                }
-        
-        private:
-                ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t );
-        };
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
-        class Signal10
-        {
-        public:
-                Signal10() : pCb( NULL ) { }
-                Signal10( _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *pCb ) : pCb( pCb ) { }
-                Signal10( const Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rSrc ) :
-                        pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
-                virtual ~Signal10() { delete pCb; pCb = NULL; }
-        
-                ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )
-                {
-                        if( !pCb ) throw SignalException("Uninitialized signal called.");
-                        return (*pCb)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
-                }
-        
-                bool isSet() const { return pCb != NULL; }
-                operator bool() const { return isSet(); }
-        
-                Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &operator=( const Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rhs )
-                {
-                        pCb = rhs.pCb->clone();
-                        return *this;
-                }
-        
-        private:
-                _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *pCb;
-        };
-        
-        template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
-        Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t ) )
-        {
-                if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>(
-                        new __Slot10<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pCls, pFnc )
-                        );
-        }
-        
-        template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
-        Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t ) )
-        {
-                if( !pFnc ) throw SignalException("NULL pointer in slot().");
-                return Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>(
-                        new __Slot10F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pFnc )
-                        );
-        }
+    //
+    // 10 Parameter(s)
+    //
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
+    class _Slot10
+    {
+    public:
+        _Slot10() { }
+        virtual ~_Slot10() { }
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )=0;
+        virtual _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *clone() const=0;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
+    class __Slot10 : public _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>
+    {
+    public:
+        __Slot10( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t ) ) :
+            pCls( pCls ), pFnc( pFnc ) { }
+        virtual ~__Slot10() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )
+        {
+            return (pCls->*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
+        }
+    
+        virtual _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *clone() const
+        {
+            return new __Slot10<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pCls, pFnc );
+        }
+    
+    private:
+        cls *pCls;
+        ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
+    class __Slot10F : public _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>
+    {
+    public:
+        __Slot10F( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t ) ) :
+            pFnc( pFnc ) { }
+        virtual ~__Slot10F() { }
+    
+        virtual ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )
+        {
+            return (*pFnc)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
+        }
+    
+        virtual _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *clone() const
+        {
+            return new __Slot10F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pFnc );
+        }
+    
+    private:
+        ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t );
+    };
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
+    class Signal10
+    {
+    public:
+        Signal10() : pCb( NULL ) { }
+        Signal10( _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *pCb ) : pCb( pCb ) { }
+        Signal10( const Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rSrc ) :
+            pCb( (rSrc.pCb)?(rSrc.pCb->clone()):(NULL) ) { }
+        virtual ~Signal10() { delete pCb; pCb = NULL; }
+    
+        ret operator()( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5, p6t p6, p7t p7, p8t p8, p9t p9, p10t p10 )
+        {
+            if( !pCb ) throw SignalException("Uninitialized signal called.");
+            return (*pCb)( p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 );
+        }
+    
+        bool isSet() const { return pCb != NULL; }
+        operator bool() const { return isSet(); }
+    
+        Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &operator=( const Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> &rhs )
+        {
+            pCb = rhs.pCb->clone();
+            return *this;
+        }
+    
+    private:
+        _Slot10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> *pCb;
+    };
+    
+    template<typename cls, typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
+    Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> slot( cls *pCls, ret (cls::*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t ) )
+    {
+        if( !pCls || !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>(
+            new __Slot10<cls, ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pCls, pFnc )
+            );
+    }
+    
+    template<typename ret, typename p1t, typename p2t, typename p3t, typename p4t, typename p5t, typename p6t, typename p7t, typename p8t, typename p9t, typename p10t>
+    Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t> slot( ret (*pFnc)( p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t ) )
+    {
+        if( !pFnc ) throw SignalException("NULL pointer in slot().");
+        return Signal10<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>(
+            new __Slot10F<ret, p1t, p2t, p3t, p4t, p5t, p6t, p7t, p8t, p9t, p10t>( pFnc )
+            );
+    }
 #endif  // BU_SIGNAL_PARAM_COUNT_10
 
 };
diff --git a/src/compat/win32.cpp b/src/compat/win32.cpp
index e1151b0..38b9ad7 100644
--- a/src/compat/win32.cpp
+++ b/src/compat/win32.cpp
@@ -10,7 +10,7 @@
 #ifdef WIN32
 
 #define deffunc( name ) \
-        Bu::Winsock2::FNDEF_DYN_ ##name Bu::Winsock2::_fnptr_ ##name = NULL
+    Bu::Winsock2::FNDEF_DYN_ ##name Bu::Winsock2::_fnptr_ ##name = NULL
 
 char Bu::Winsock2::scode[32];
 
@@ -33,133 +33,133 @@ deffunc( getpeername );
 deffunc( setsockopt );
 deffunc( bind );
 deffunc( listen );
-deffunc( accept );      
+deffunc( accept );  
 deffunc( recv );
 deffunc( send );
 deffunc( __WSAFDIsSet );
 
 // Safely get a function from the library
 #define getfunc( name ) \
-        Bu::Winsock2::_fnptr_ ##name = (FNDEF_DYN_ ##name) \
-                GetProcAddress( Ws2_32, #name ); \
-        if( Bu::Winsock2::_fnptr_ ##name == NULL ) { \
-                throw Bu::ExceptionBase("Error loading function " #name " from dll.");\
-        } (void)0
+    Bu::Winsock2::_fnptr_ ##name = (FNDEF_DYN_ ##name) \
+        GetProcAddress( Ws2_32, #name ); \
+    if( Bu::Winsock2::_fnptr_ ##name == NULL ) { \
+        throw Bu::ExceptionBase("Error loading function " #name " from dll.");\
+    } (void)0
 
 Bu::Winsock2::Winsock2()
 {
-        Ws2_32 = LoadLibrary(TEXT("WS2_32.DLL"));
-
-        getfunc( WSAStartup );
-        getfunc( WSACleanup );
-        getfunc( WSAGetLastError );
-        getfunc( inet_ntoa );
-        getfunc( inet_addr );
-        getfunc( select );
-        getfunc( socket );
-        getfunc( shutdown );
-        getfunc( ioctlsocket );
-        getfunc( htons );
-        getfunc( htonl );
-        getfunc( gethostbyname );
-        getfunc( freeaddrinfo );
-        getfunc( getaddrinfo );
-        getfunc( connect );
-        getfunc( getpeername );
-        getfunc( setsockopt );
-        getfunc( bind );
-        getfunc( listen );
-        getfunc( accept );      
-        getfunc( recv );
-        getfunc( send );
-        getfunc( __WSAFDIsSet );
-
-        Bu::Winsock2::WSAStartup( MAKEWORD(2, 2), &wsaData );
+    Ws2_32 = LoadLibrary(TEXT("WS2_32.DLL"));
+
+    getfunc( WSAStartup );
+    getfunc( WSACleanup );
+    getfunc( WSAGetLastError );
+    getfunc( inet_ntoa );
+    getfunc( inet_addr );
+    getfunc( select );
+    getfunc( socket );
+    getfunc( shutdown );
+    getfunc( ioctlsocket );
+    getfunc( htons );
+    getfunc( htonl );
+    getfunc( gethostbyname );
+    getfunc( freeaddrinfo );
+    getfunc( getaddrinfo );
+    getfunc( connect );
+    getfunc( getpeername );
+    getfunc( setsockopt );
+    getfunc( bind );
+    getfunc( listen );
+    getfunc( accept );  
+    getfunc( recv );
+    getfunc( send );
+    getfunc( __WSAFDIsSet );
+
+    Bu::Winsock2::WSAStartup( MAKEWORD(2, 2), &wsaData );
 }
 
 Bu::Winsock2::~Winsock2()
 {
-        Bu::Winsock2::WSACleanup();
-        FreeLibrary( Ws2_32 );
+    Bu::Winsock2::WSACleanup();
+    FreeLibrary( Ws2_32 );
 }
 
 char *Bu::Winsock2::gai_strerror( int iCode )
 {
-        sprintf( scode, "%d (%d)", iCode, Bu::Winsock2::WSAGetLastError() );
-        return scode;
+    sprintf( scode, "%d (%d)", iCode, Bu::Winsock2::WSAGetLastError() );
+    return scode;
 }
 
 int Bu::Winsock2::WSAStartup( WORD a, LPWSADATA b ) {
-        return (*Bu::Winsock2::_fnptr_WSAStartup)( a, b );
+    return (*Bu::Winsock2::_fnptr_WSAStartup)( a, b );
 }
 int Bu::Winsock2::WSACleanup( ) {
-        return (*Bu::Winsock2::_fnptr_WSACleanup)();
+    return (*Bu::Winsock2::_fnptr_WSACleanup)();
 }
 int Bu::Winsock2::WSAGetLastError( ) {
-        return (*Bu::Winsock2::_fnptr_WSAGetLastError)();
+    return (*Bu::Winsock2::_fnptr_WSAGetLastError)();
 }
 char * Bu::Winsock2::inet_ntoa( struct in_addr a ) {
-        return (*Bu::Winsock2::_fnptr_inet_ntoa)( a );
+    return (*Bu::Winsock2::_fnptr_inet_ntoa)( a );
 }
 unsigned long Bu::Winsock2::inet_addr( const char *s_in ) {
-        return (*Bu::Winsock2::_fnptr_inet_addr)( s_in );
+    return (*Bu::Winsock2::_fnptr_inet_addr)( s_in );
 }
 int Bu::Winsock2::select( int a, fd_set *b, fd_set *c, fd_set *d,
-                const struct timeval *e ) {
-        return (*Bu::Winsock2::_fnptr_select)( a, b, c, d, e );
+        const struct timeval *e ) {
+    return (*Bu::Winsock2::_fnptr_select)( a, b, c, d, e );
 }
 SOCKET Bu::Winsock2::socket( int domain, int type, int protocol ) {
-        return (*Bu::Winsock2::_fnptr_socket)( domain, type, protocol );
+    return (*Bu::Winsock2::_fnptr_socket)( domain, type, protocol );
 }
 int Bu::Winsock2::shutdown( SOCKET s, int how ) {
-        return (*Bu::Winsock2::_fnptr_shutdown)( s, how );
+    return (*Bu::Winsock2::_fnptr_shutdown)( s, how );
 }
 int Bu::Winsock2::ioctlsocket( SOCKET s, long cmd, u_long *argp ) {
-        return (*Bu::Winsock2::_fnptr_ioctlsocket)( s, cmd, argp );
+    return (*Bu::Winsock2::_fnptr_ioctlsocket)( s, cmd, argp );
 }
 u_short Bu::Winsock2::htons( u_short in ) {
-        return (*Bu::Winsock2::_fnptr_htons)( in );
+    return (*Bu::Winsock2::_fnptr_htons)( in );
 }
 u_long Bu::Winsock2::htonl( u_long in ) {
-        return (*Bu::Winsock2::_fnptr_htonl)( in );
+    return (*Bu::Winsock2::_fnptr_htonl)( in );
 }
 struct hostent * Bu::Winsock2::gethostbyname( const char *name ) {
-        return (*Bu::Winsock2::_fnptr_gethostbyname)( name );
+    return (*Bu::Winsock2::_fnptr_gethostbyname)( name );
 }
 void Bu::Winsock2::freeaddrinfo( struct addrinfo *ai ) {
-        return (*Bu::Winsock2::_fnptr_freeaddrinfo)( ai );
+    return (*Bu::Winsock2::_fnptr_freeaddrinfo)( ai );
 }
 int Bu::Winsock2::getaddrinfo( const char *a, const char *b,
-                const struct addrinfo *c, struct addrinfo **d ) {
-        return (*Bu::Winsock2::_fnptr_getaddrinfo)( a, b, c, d );
+        const struct addrinfo *c, struct addrinfo **d ) {
+    return (*Bu::Winsock2::_fnptr_getaddrinfo)( a, b, c, d );
 }
 int Bu::Winsock2::connect( SOCKET s, const struct sockaddr *a, int b ) {
-        return (*Bu::Winsock2::_fnptr_connect)( s, a, b );
+    return (*Bu::Winsock2::_fnptr_connect)( s, a, b );
 }
 int Bu::Winsock2::getpeername( SOCKET s, struct sockaddr *a, int *b ) {
-        return (*Bu::Winsock2::_fnptr_getpeername)( s, a, b);
+    return (*Bu::Winsock2::_fnptr_getpeername)( s, a, b);
 }
 int Bu::Winsock2::setsockopt( SOCKET s, int a, int b,
-                const char *c, int d ) {
-        return (*Bu::Winsock2::_fnptr_setsockopt)( s, a, b, c, d );
+        const char *c, int d ) {
+    return (*Bu::Winsock2::_fnptr_setsockopt)( s, a, b, c, d );
 }
 int Bu::Winsock2::bind( SOCKET s, const struct sockaddr *a, int b ) {
-        return (*Bu::Winsock2::_fnptr_bind)( s, a, b );
+    return (*Bu::Winsock2::_fnptr_bind)( s, a, b );
 }
 int Bu::Winsock2::listen( SOCKET s, int backlog ) {
-        return (*Bu::Winsock2::_fnptr_listen)( s, backlog );
+    return (*Bu::Winsock2::_fnptr_listen)( s, backlog );
 }
-SOCKET Bu::Winsock2::accept( SOCKET s, struct sockaddr *a, int *b ) {   
-        return (*Bu::Winsock2::_fnptr_accept)( s, a, b );
+SOCKET Bu::Winsock2::accept( SOCKET s, struct sockaddr *a, int *b ) {   
+    return (*Bu::Winsock2::_fnptr_accept)( s, a, b );
 }
 int Bu::Winsock2::recv( SOCKET s, char *buf, int len, int flags ) {
-        return (*Bu::Winsock2::_fnptr_recv)( s, buf, len, flags );
+    return (*Bu::Winsock2::_fnptr_recv)( s, buf, len, flags );
 }
 int Bu::Winsock2::send( SOCKET s, const char *buf, int len, int flags ) {
-        return (*Bu::Winsock2::_fnptr_send)( s, buf, len, flags );
+    return (*Bu::Winsock2::_fnptr_send)( s, buf, len, flags );
 }
 int Bu::Winsock2::__WSAFDIsSet( SOCKET s, fd_set *set ) {
-        return (*Bu::Winsock2::_fnptr___WSAFDIsSet)( s, set );
+    return (*Bu::Winsock2::_fnptr___WSAFDIsSet)( s, set );
 }
 
 Bu::String Bu::getLastWinError()
@@ -177,11 +177,11 @@ Bu::String Bu::getLastWinError()
         (LPSTR) &lpMsgBuf,
         0, NULL );
 
-        Bu::String sRet( (char *)lpMsgBuf );
+    Bu::String sRet( (char *)lpMsgBuf );
 
     LocalFree(lpMsgBuf);
 
-        return sRet;
+    return sRet;
 }
 
 #endif
diff --git a/src/compat/win32.h b/src/compat/win32.h
index 7e44c13..0cc42b6 100644
--- a/src/compat/win32.h
+++ b/src/compat/win32.h
@@ -32,9 +32,9 @@ extern "C"
 #endif
 
 #define decltype( ret, name, ... ) \
-        typedef ret (__cdecl *FNDEF_DYN_ ##name)( __VA_ARGS__ ); \
-        static FNDEF_DYN_ ##name _fnptr_ ##name; \
-        static ret name( __VA_ARGS__ )
+    typedef ret (__cdecl *FNDEF_DYN_ ##name)( __VA_ARGS__ ); \
+    static FNDEF_DYN_ ##name _fnptr_ ##name; \
+    static ret name( __VA_ARGS__ )
 
 __extension__ typedef int socklen_t;
 
@@ -44,54 +44,54 @@ __extension__ typedef int socklen_t;
 
 namespace Bu
 {
-        class Winsock2 : public Bu::Singleton<Winsock2>
-        {
-        friend class Bu::Singleton<Winsock2>;
-        private:
-                Winsock2();
-                virtual ~Winsock2();
-
-                WSADATA wsaData;
-                HINSTANCE Ws2_32;
-
-        public:
-                // decltype( return type, function name<, optional parameters> )
-                decltype( int, WSAStartup, WORD, LPWSADATA );
-                decltype( int, WSACleanup );
-                decltype( int, WSAGetLastError );
-                decltype( char *, inet_ntoa, struct in_addr );
-                decltype( unsigned long, inet_addr, const char *s_in );
-                decltype( int, select, int nfds, fd_set *readfds, fd_set *writefds, 
-                                fd_set *exceptfds, const struct timeval *timeout );
-                decltype( SOCKET, socket, int domain, int type, int protocol );
-                decltype( int, shutdown, SOCKET s, int how );
-                decltype( int, ioctlsocket, SOCKET s, long cmd, u_long *argp );
-                decltype( u_short, htons, u_short in );
-                decltype( u_long, htonl, u_long in );
-                decltype( struct hostent *, gethostbyname, const char *name );
-                decltype( void, freeaddrinfo, struct addrinfo *ai );
-                decltype( int, getaddrinfo, const char *nodename, const char *servname,
-                                const struct addrinfo *hints, struct addrinfo **res );
-                decltype( int, connect, SOCKET s, const struct sockaddr *serv_addr,
-                                int addrlen );
-                decltype( int, getpeername, SOCKET s, struct sockaddr *name,
-                                int *namelen );
-                decltype( int, setsockopt, SOCKET s, int level, int optname,
-                                const char *optval, int optlen );
-                decltype( int, bind, SOCKET s, const struct sockaddr *my_addr,
-                                int addrlen );
-                decltype( int, listen, SOCKET s, int backlog );
-                decltype( SOCKET, accept, SOCKET s, struct sockaddr *addr,
-                                int *addrlen);  
-                decltype( int, recv, SOCKET s, char *buf, int len, int flags );
-                decltype( int, send, SOCKET s, const char *buf, int len, int flags );
-                decltype( int, __WSAFDIsSet, SOCKET s, fd_set *set );
-        
-                static char scode[32];
-                static char *gai_strerror( int iCode );
-        };
-
-        Bu::String getLastWinError();
+    class Winsock2 : public Bu::Singleton<Winsock2>
+    {
+    friend class Bu::Singleton<Winsock2>;
+    private:
+        Winsock2();
+        virtual ~Winsock2();
+
+        WSADATA wsaData;
+        HINSTANCE Ws2_32;
+
+    public:
+        // decltype( return type, function name<, optional parameters> )
+        decltype( int, WSAStartup, WORD, LPWSADATA );
+        decltype( int, WSACleanup );
+        decltype( int, WSAGetLastError );
+        decltype( char *, inet_ntoa, struct in_addr );
+        decltype( unsigned long, inet_addr, const char *s_in );
+        decltype( int, select, int nfds, fd_set *readfds, fd_set *writefds, 
+                fd_set *exceptfds, const struct timeval *timeout );
+        decltype( SOCKET, socket, int domain, int type, int protocol );
+        decltype( int, shutdown, SOCKET s, int how );
+        decltype( int, ioctlsocket, SOCKET s, long cmd, u_long *argp );
+        decltype( u_short, htons, u_short in );
+        decltype( u_long, htonl, u_long in );
+        decltype( struct hostent *, gethostbyname, const char *name );
+        decltype( void, freeaddrinfo, struct addrinfo *ai );
+        decltype( int, getaddrinfo, const char *nodename, const char *servname,
+                const struct addrinfo *hints, struct addrinfo **res );
+        decltype( int, connect, SOCKET s, const struct sockaddr *serv_addr,
+                int addrlen );
+        decltype( int, getpeername, SOCKET s, struct sockaddr *name,
+                int *namelen );
+        decltype( int, setsockopt, SOCKET s, int level, int optname,
+                const char *optval, int optlen );
+        decltype( int, bind, SOCKET s, const struct sockaddr *my_addr,
+                int addrlen );
+        decltype( int, listen, SOCKET s, int backlog );
+        decltype( SOCKET, accept, SOCKET s, struct sockaddr *addr,
+                int *addrlen);  
+        decltype( int, recv, SOCKET s, char *buf, int len, int flags );
+        decltype( int, send, SOCKET s, const char *buf, int len, int flags );
+        decltype( int, __WSAFDIsSet, SOCKET s, fd_set *set );
+    
+        static char scode[32];
+        static char *gai_strerror( int iCode );
+    };
+
+    Bu::String getLastWinError();
 };
 
 #ifdef FD_ISSET
@@ -117,7 +117,7 @@ namespace Bu
 #define bu_setsockopt (*Bu::Winsock2::setsockopt)
 #define bu_bind (*Bu::Winsock2::bind)
 #define bu_listen (*Bu::Winsock2::listen)
-#define bu_accept (*Bu::Winsock2::accept)       
+#define bu_accept (*Bu::Winsock2::accept)   
 #define bu_recv (*Bu::Winsock2::recv)
 #define bu_send (*Bu::Winsock2::send)
 #define bu___WSAFDIsSet (*Bu::Winsock2::__WSAFDIsSet)
diff --git a/src/config.h b/src/config.h
index fa304bb..c73906b 100644
--- a/src/config.h
+++ b/src/config.h
@@ -20,9 +20,9 @@
 #ifndef WIN32
 # include "bu/autoconfig.h"
 #else
-# define        __LITTLE_ENDIAN 1234
-# define        __BIG_ENDIAN    4321
-# define        __PDP_ENDIAN    3412
+# define    __LITTLE_ENDIAN 1234
+# define    __BIG_ENDIAN    4321
+# define    __PDP_ENDIAN    3412
 # define __BYTE_ORDER __LITTLE_ENDIAN
 
 # ifndef LITTLE_ENDIAN
diff --git a/src/experimental/blowfish.h b/src/experimental/blowfish.h
index 0308026..b287bd4 100644
--- a/src/experimental/blowfish.h
+++ b/src/experimental/blowfish.h
@@ -23,454 +23,454 @@
 #define MAX_STRING   256
 #define MAX_PASSWD   56  // 448bits
 #define F(x) \
-        (((SB[0][x.byte.zero] + SB[1][x.byte.one]) ^ SB[2][x.byte.two]) + \
-         SB[3][x.byte.three])
+    (((SB[0][x.byte.zero] + SB[1][x.byte.one]) ^ SB[2][x.byte.two]) + \
+     SB[3][x.byte.three])
 #define revBytes( x ) x = (((x&0xff)<<24)|((x&0xff00)<<8)|((x&0xff0000)>>8)|((x&0xff000000)>>24))
 
 namespace Bu
 {
-        template<int Mode>
-        class Blowfish : public Bu::Cipher<8>
-        {
-        public:
-                Blowfish( Bu::Stream &rNext ) :
-                        Bu::Cipher<8>( rNext )
-                {
-                }
-
-                virtual ~Blowfish()
-                {
-                        stop();
-                        reset();
-                }
-
-                void setPassword( const Bu::String &sPass )
-                {
-                        reset();
-
-                        uint32_t i,j,len=sPass.getSize();
-                        Word Work,null0,null1;
-
-                        if (len > 0)
-                        {
-                                j = 0;
-                                for (i=0;i<NUM_SUBKEYS;i++)
-                                {
-                                        Work.byte.zero = sPass[(j++)%len];
-                                        Work.byte.one = sPass[(j++)%len];
-                                        Work.byte.two = sPass[(j++)%len];
-                                        Work.byte.three = sPass[(j++)%len];
-                                        PA[i] ^= Work.word;
-                                }
-
-                                null0.word = null1.word = 0;
-
-                                for (i=0;i<NUM_SUBKEYS;i+=2)
-                                {
-                                        keyEncipher( null0, null1 );
-                                        PA[i] = null0.word;
-                                        PA[i+1] = null1.word;
-                                }
-
-                                for (j=0;j<NUM_S_BOXES;j++)
-                                        for (i=0;i<NUM_ENTRIES;i+=2)
-                                        {
-                                                keyEncipher( null0, null1 );
-                                                SB[j][i] = null0.word;
-                                                SB[j][i+1] = null1.word;
-                                        }
-                        }
-
-                        Work.word = null0.word = null1.word = 0;
-                        len = 0;
-                }
-
-        private:
-                uint32_t PA[NUM_SUBKEYS];
-                uint32_t SB[NUM_S_BOXES][NUM_ENTRIES];
+    template<int Mode>
+    class Blowfish : public Bu::Cipher<8>
+    {
+    public:
+        Blowfish( Bu::Stream &rNext ) :
+            Bu::Cipher<8>( rNext )
+        {
+        }
+
+        virtual ~Blowfish()
+        {
+            stop();
+            reset();
+        }
+
+        void setPassword( const Bu::String &sPass )
+        {
+            reset();
+
+            uint32_t i,j,len=sPass.getSize();
+            Word Work,null0,null1;
+
+            if (len > 0)
+            {
+                j = 0;
+                for (i=0;i<NUM_SUBKEYS;i++)
+                {
+                    Work.byte.zero = sPass[(j++)%len];
+                    Work.byte.one = sPass[(j++)%len];
+                    Work.byte.two = sPass[(j++)%len];
+                    Work.byte.three = sPass[(j++)%len];
+                    PA[i] ^= Work.word;
+                }
+
+                null0.word = null1.word = 0;
+
+                for (i=0;i<NUM_SUBKEYS;i+=2)
+                {
+                    keyEncipher( null0, null1 );
+                    PA[i] = null0.word;
+                    PA[i+1] = null1.word;
+                }
+
+                for (j=0;j<NUM_S_BOXES;j++)
+                    for (i=0;i<NUM_ENTRIES;i+=2)
+                    {
+                        keyEncipher( null0, null1 );
+                        SB[j][i] = null0.word;
+                        SB[j][i+1] = null1.word;
+                    }
+            }
+
+            Work.word = null0.word = null1.word = 0;
+            len = 0;
+        }
+
+    private:
+        uint32_t PA[NUM_SUBKEYS];
+        uint32_t SB[NUM_S_BOXES][NUM_ENTRIES];
 
 #if __BYTE_ORDER == __BIG_ENDIAN
-                struct WordByte
-                {
-                        uint32_t zero:8;
-                        uint32_t one:8;
-                        uint32_t two:8;
-                        uint32_t three:8;
-                };
+        struct WordByte
+        {
+            uint32_t zero:8;
+            uint32_t one:8;
+            uint32_t two:8;
+            uint32_t three:8;
+        };
 #elif __BYTE_ORDER == __LITTLE_ENDIAN
-                struct WordByte
-                {
-                        uint32_t three:8;
-                        uint32_t two:8;
-                        uint32_t one:8;
-                        uint32_t zero:8;
-                };
+        struct WordByte
+        {
+            uint32_t three:8;
+            uint32_t two:8;
+            uint32_t one:8;
+            uint32_t zero:8;
+        };
 #else
 #error No endianness defined
 #endif
 
-                union Word
-                {
-                        uint32_t word;
-                        WordByte byte;
-                };
-
-                struct DWord
-                {
-                        Word word0;
-                        Word word1;
-                };
-
-                void reset()
-                {
-                        uint32_t i,j;
-
-                        static uint32_t PA_Init[NUM_SUBKEYS] =
-                        {
-                                0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
-                                0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
-                                0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
-                                0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
-                                0x9216d5d9, 0x8979fb1b
-                        };
-
-                        static uint32_t SB_Init[NUM_S_BOXES][NUM_ENTRIES] = {
-                        {
-                                0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
-                                0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
-                                0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
-                                0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
-                                0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
-                                0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
-                                0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
-                                0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
-                                0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
-                                0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
-                                0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
-                                0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
-                                0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
-                                0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
-                                0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
-                                0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
-                                0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
-                                0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
-                                0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
-                                0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
-                                0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
-                                0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
-                                0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
-                                0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
-                                0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
-                                0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
-                                0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
-                                0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
-                                0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
-                                0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
-                                0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
-                                0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
-                                
-                                0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
-                                0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
-                                0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
-                                0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
-                                0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
-                                0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
-                                0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
-                                0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
-                                0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
-                                0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
-                                0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
-                                0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
-                                0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
-                                0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
-                                0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
-                                0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
-                                0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
-                                0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
-                                0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
-                                0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
-                                0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
-                                0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
-                                0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
-                                0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
-                                0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
-                                0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
-                                0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
-                                0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
-                                0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
-                                0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
-                                0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
-                                0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
-                        }, {
-                                0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
-                                0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
-                                0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
-                                0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
-                                0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
-                                0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
-                                0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
-                                0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
-                                0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
-                                0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
-                                0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
-                                0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
-                                0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
-                                0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
-                                0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
-                                0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
-                                0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
-                                0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
-                                0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
-                                0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
-                                0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
-                                0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
-                                0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
-                                0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
-                                0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
-                                0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
-                                0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
-                                0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
-                                0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
-                                0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
-                                0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
-                                0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
-
-                                0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
-                                0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
-                                0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
-                                0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
-                                0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
-                                0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
-                                0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
-                                0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
-                                0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
-                                0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
-                                0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
-                                0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
-                                0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
-                                0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
-                                0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
-                                0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
-                                0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
-                                0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
-                                0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
-                                0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
-                                0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
-                                0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
-                                0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
-                                0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
-                                0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
-                                0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
-                                0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
-                                0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
-                                0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
-                                0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
-                                0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
-                                0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
-                        }, {
-                                0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
-                                0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
-                                0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
-                                0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
-                                0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
-                                0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
-                                0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
-                                0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
-                                0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
-                                0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
-                                0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
-                                0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
-                                0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
-                                0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
-                                0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
-                                0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
-                                0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
-                                0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
-                                0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
-                                0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
-                                0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
-                                0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
-                                0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
-                                0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
-                                0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
-                                0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
-                                0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
-                                0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
-                                0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
-                                0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
-                                0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
-                                0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
-
-                                0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
-                                0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
-                                0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
-                                0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
-                                0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
-                                0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
-                                0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
-                                0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
-                                0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
-                                0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
-                                0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
-                                0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
-                                0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
-                                0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
-                                0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
-                                0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
-                                0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
-                                0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
-                                0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
-                                0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
-                                0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
-                                0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
-                                0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
-                                0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
-                                0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
-                                0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
-                                0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
-                                0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
-                                0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
-                                0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
-                                0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
-                                0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
-                        }, {
-                                0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
-                                0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
-                                0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
-                                0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
-                                0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
-                                0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
-                                0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
-                                0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
-                                0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
-                                0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
-                                0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
-                                0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
-                                0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
-                                0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
-                                0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
-                                0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
-                                0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
-                                0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
-                                0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
-                                0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
-                                0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
-                                0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
-                                0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
-                                0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
-                                0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
-                                0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
-                                0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
-                                0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
-                                0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
-                                0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
-                                0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
-                                0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
-
-                                0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
-                                0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
-                                0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
-                                0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
-                                0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
-                                0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
-                                0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
-                                0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
-                                0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
-                                0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
-                                0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
-                                0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
-                                0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
-                                0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
-                                0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
-                                0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
-                                0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
-                                0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
-                                0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
-                                0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
-                                0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
-                                0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
-                                0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
-                                0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
-                                0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
-                                0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
-                                0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
-                                0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
-                                0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
-                                0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
-                                0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
-                                0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
-                        }
-                        };
-
-                        for (i=0;i<NUM_SUBKEYS;i++)
-                                PA[i] = PA_Init[i];
-
-                        for (j=0;j<NUM_S_BOXES;j++)
-                                for (i=0;i<NUM_ENTRIES;i++)
-                                        SB[j][i] = SB_Init[j][i];
-                }
-
-        protected:
-                virtual void encipher( void *pData )
-                {
-                        DWord *dwWork = (DWord *)pData;
-                        Word &w1 = dwWork->word0, &w2 = dwWork->word1;
-
-                        w1.word = be32toh( w1.word );
-                        w2.word = be32toh( w2.word );
-
-                        keyEncipher( w1, w2 );
-
-                        revBytes( w1.word );
-                        revBytes( w2.word );
-                }
-
-                virtual void decipher( void *pData )
-                {
-                        DWord *dwWork = (DWord *)pData;
-                        Word &w1 = dwWork->word0, &w2 = dwWork->word1;
-
-                        revBytes( w1.word );
-                        revBytes( w2.word );
-                        
-                        w1.word ^= PA[17];
-                        w2.word ^= F(w1)^PA[16];      w1.word ^= F(w2)^PA[15];
-                        w2.word ^= F(w1)^PA[14];      w1.word ^= F(w2)^PA[13];
-                        w2.word ^= F(w1)^PA[12];      w1.word ^= F(w2)^PA[11];
-                        w2.word ^= F(w1)^PA[10];      w1.word ^= F(w2)^PA[9];
-                        w2.word ^= F(w1)^PA[8];       w1.word ^= F(w2)^PA[7];
-                        w2.word ^= F(w1)^PA[6];       w1.word ^= F(w2)^PA[5];
-                        w2.word ^= F(w1)^PA[4];       w1.word ^= F(w2)^PA[3];
-                        w2.word ^= F(w1)^PA[2];       w1.word ^= F(w2)^PA[1];
-                        w2.word ^= PA[0];
-                        
-                        Bu::swap( w1, w2 );
-
-                        w1.word = htobe32( w1.word );
-                        w2.word = htobe32( w2.word );
-                }
-
-                inline void keyEncipher( Word &w1, Word &w2 )
-                {
-                        w1.word ^= PA[0];
-                        w2.word ^= F(w1)^PA[1];       w1.word ^= F(w2)^PA[2];
-                        w2.word ^= F(w1)^PA[3];       w1.word ^= F(w2)^PA[4];
-                        w2.word ^= F(w1)^PA[5];       w1.word ^= F(w2)^PA[6];
-                        w2.word ^= F(w1)^PA[7];       w1.word ^= F(w2)^PA[8];
-                        w2.word ^= F(w1)^PA[9];       w1.word ^= F(w2)^PA[10];
-                        w2.word ^= F(w1)^PA[11];      w1.word ^= F(w2)^PA[12];
-                        w2.word ^= F(w1)^PA[13];      w1.word ^= F(w2)^PA[14];
-                        w2.word ^= F(w1)^PA[15];      w1.word ^= F(w2)^PA[16];
-                        w2.word ^= PA[17];
-
-                        Bu::swap( w1, w2 );
-                }
-        };
-
-        typedef CipherModeEcb<8, Blowfish<1> > BlowfishEcb;
-        typedef CipherModeCfb<8, Blowfish<1> > BlowfishCfb;
-        typedef CipherModeCbc<8, Blowfish<1> > BlowfishCbc;
-        typedef CipherModeOfb<8, Blowfish<1> > BlowfishOfb;
+        union Word
+        {
+            uint32_t word;
+            WordByte byte;
+        };
+
+        struct DWord
+        {
+            Word word0;
+            Word word1;
+        };
+
+        void reset()
+        {
+            uint32_t i,j;
+
+            static uint32_t PA_Init[NUM_SUBKEYS] =
+            {
+                0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+                0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+                0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+                0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+                0x9216d5d9, 0x8979fb1b
+            };
+
+            static uint32_t SB_Init[NUM_S_BOXES][NUM_ENTRIES] = {
+            {
+                0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
+                0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
+                0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+                0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
+                0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
+                0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+                0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
+                0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
+                0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+                0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
+                0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
+                0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+                0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
+                0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
+                0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+                0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
+                0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
+                0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+                0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
+                0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
+                0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+                0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
+                0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
+                0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+                0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
+                0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
+                0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+                0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
+                0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
+                0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+                0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
+                0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
+                
+                0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+                0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
+                0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
+                0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+                0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
+                0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
+                0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+                0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
+                0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
+                0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+                0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
+                0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
+                0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+                0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
+                0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
+                0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+                0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
+                0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
+                0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+                0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
+                0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
+                0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+                0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
+                0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
+                0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+                0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
+                0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
+                0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+                0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
+                0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
+                0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+                0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
+            }, {
+                0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
+                0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
+                0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+                0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
+                0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
+                0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+                0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
+                0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
+                0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+                0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
+                0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
+                0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+                0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
+                0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
+                0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+                0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
+                0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
+                0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+                0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
+                0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
+                0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+                0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
+                0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
+                0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+                0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
+                0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
+                0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+                0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
+                0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
+                0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+                0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
+                0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
+
+                0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+                0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
+                0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
+                0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+                0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
+                0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
+                0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+                0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
+                0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
+                0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+                0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
+                0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
+                0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+                0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
+                0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
+                0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+                0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
+                0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
+                0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+                0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
+                0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
+                0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+                0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
+                0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
+                0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+                0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
+                0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
+                0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+                0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
+                0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
+                0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+                0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
+            }, {
+                0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
+                0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
+                0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+                0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
+                0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
+                0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+                0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
+                0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
+                0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+                0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
+                0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
+                0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+                0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
+                0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
+                0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+                0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
+                0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
+                0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+                0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
+                0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
+                0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+                0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
+                0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
+                0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+                0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
+                0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
+                0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+                0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
+                0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
+                0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+                0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
+                0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
+
+                0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+                0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
+                0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
+                0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+                0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
+                0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
+                0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+                0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
+                0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
+                0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+                0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
+                0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
+                0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+                0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
+                0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
+                0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+                0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
+                0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
+                0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+                0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
+                0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
+                0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+                0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
+                0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
+                0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+                0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
+                0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
+                0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+                0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
+                0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
+                0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+                0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
+            }, {
+                0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
+                0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
+                0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+                0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
+                0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
+                0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+                0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
+                0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
+                0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+                0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
+                0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
+                0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+                0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
+                0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
+                0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+                0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
+                0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
+                0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+                0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
+                0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
+                0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+                0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
+                0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
+                0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+                0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
+                0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
+                0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+                0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
+                0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
+                0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+                0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
+                0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
+
+                0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+                0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
+                0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
+                0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+                0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
+                0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
+                0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+                0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
+                0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
+                0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+                0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
+                0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
+                0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+                0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
+                0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
+                0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+                0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
+                0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
+                0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+                0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
+                0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
+                0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+                0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
+                0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
+                0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+                0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
+                0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
+                0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+                0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
+                0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
+                0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+                0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
+            }
+            };
+
+            for (i=0;i<NUM_SUBKEYS;i++)
+                PA[i] = PA_Init[i];
+
+            for (j=0;j<NUM_S_BOXES;j++)
+                for (i=0;i<NUM_ENTRIES;i++)
+                    SB[j][i] = SB_Init[j][i];
+        }
+
+    protected:
+        virtual void encipher( void *pData )
+        {
+            DWord *dwWork = (DWord *)pData;
+            Word &w1 = dwWork->word0, &w2 = dwWork->word1;
+
+            w1.word = be32toh( w1.word );
+            w2.word = be32toh( w2.word );
+
+            keyEncipher( w1, w2 );
+
+            revBytes( w1.word );
+            revBytes( w2.word );
+        }
+
+        virtual void decipher( void *pData )
+        {
+            DWord *dwWork = (DWord *)pData;
+            Word &w1 = dwWork->word0, &w2 = dwWork->word1;
+
+            revBytes( w1.word );
+            revBytes( w2.word );
+            
+            w1.word ^= PA[17];
+            w2.word ^= F(w1)^PA[16];      w1.word ^= F(w2)^PA[15];
+            w2.word ^= F(w1)^PA[14];      w1.word ^= F(w2)^PA[13];
+            w2.word ^= F(w1)^PA[12];      w1.word ^= F(w2)^PA[11];
+            w2.word ^= F(w1)^PA[10];      w1.word ^= F(w2)^PA[9];
+            w2.word ^= F(w1)^PA[8];       w1.word ^= F(w2)^PA[7];
+            w2.word ^= F(w1)^PA[6];       w1.word ^= F(w2)^PA[5];
+            w2.word ^= F(w1)^PA[4];       w1.word ^= F(w2)^PA[3];
+            w2.word ^= F(w1)^PA[2];       w1.word ^= F(w2)^PA[1];
+            w2.word ^= PA[0];
+            
+            Bu::swap( w1, w2 );
+
+            w1.word = htobe32( w1.word );
+            w2.word = htobe32( w2.word );
+        }
+
+        inline void keyEncipher( Word &w1, Word &w2 )
+        {
+            w1.word ^= PA[0];
+            w2.word ^= F(w1)^PA[1];       w1.word ^= F(w2)^PA[2];
+            w2.word ^= F(w1)^PA[3];       w1.word ^= F(w2)^PA[4];
+            w2.word ^= F(w1)^PA[5];       w1.word ^= F(w2)^PA[6];
+            w2.word ^= F(w1)^PA[7];       w1.word ^= F(w2)^PA[8];
+            w2.word ^= F(w1)^PA[9];       w1.word ^= F(w2)^PA[10];
+            w2.word ^= F(w1)^PA[11];      w1.word ^= F(w2)^PA[12];
+            w2.word ^= F(w1)^PA[13];      w1.word ^= F(w2)^PA[14];
+            w2.word ^= F(w1)^PA[15];      w1.word ^= F(w2)^PA[16];
+            w2.word ^= PA[17];
+
+            Bu::swap( w1, w2 );
+        }
+    };
+
+    typedef CipherModeEcb<8, Blowfish<1> > BlowfishEcb;
+    typedef CipherModeCfb<8, Blowfish<1> > BlowfishCfb;
+    typedef CipherModeCbc<8, Blowfish<1> > BlowfishCbc;
+    typedef CipherModeOfb<8, Blowfish<1> > BlowfishOfb;
 };
 
 #endif
diff --git a/src/experimental/cache.h b/src/experimental/cache.h
index e3c8483..795d180 100644
--- a/src/experimental/cache.h
+++ b/src/experimental/cache.h
@@ -18,420 +18,420 @@
 
 namespace Bu
 {
-//      template<class keytype, class obtype>
-//      keytype __cacheGetKey( obtype *&pObj );
-        template<class keytype, class obtype>
-        keytype __cacheGetKey( const obtype *pObj )
-        {
-                return pObj->getKey();
-        }
-
-        template<class keytype, class obtype>
-        class Cache
-        {
-        public:
-                /**
-                 * Cache Pointer - Provides access to data that is held within the
-                 * cache.  This provides safe, refcounting access to data stored in
-                 * the cache, with support for lazy loading.
-                 */
-                class Ptr
-                {
-                friend class Bu::Cache<keytype, obtype>;
-                private:
-                        Ptr( Cache<keytype, obtype> *pCache, obtype *pData,
-                                const keytype &kId ) :
-                                pCache( pCache ),
-                                pData( pData ),
-                                kId( kId )
-                        {
-                                if( pCache )
-                                        pCache->incRef( kId );
-                        }
-                        
-                        Ptr( Cache<keytype, obtype> *pCache, const keytype &kId ) :
-                                pCache( pCache ),
-                                pData( NULL ),
-                                kId( kId )
-                        {
-                        }
-
-                public:
-                        Ptr( const Ptr &rSrc ) :
-                                pCache( rSrc.pCache ),
-                                pData( rSrc.pData ),
-                                kId( rSrc.kId )
-                        {
-                                if( pCache && pData )
-                                        pCache->incRef( kId );
-                        }
-
-                        Ptr() :
-                                pCache( 0 ),
-                                pData( 0 )
-                        {
-                        }
-
-                        virtual ~Ptr()
-                        {
-                                if( pCache && pData )
-                                        pCache->decRef( kId );
-                        }
-
-                        obtype &operator*()
-                        {
-                                checkPtr();
-                                return *pData;
-                        }
-
-                        const obtype &operator*() const
-                        {
-                                checkPtr();
-                                return *pData;
-                        }
-
-                        obtype *operator->()
-                        {
-                                checkPtr();
-                                return pData;
-                        }
-
-                        const obtype *operator->() const
-                        {
-                                checkPtr();
-                                return pData;
-                        }
-
-                        bool isValid() const
-                        {
-                                return pCache != NULL;
-                        }
-
-                        bool isBound() const
-                        {
-                                return pData != NULL;
-                        }
-
-                        bool isSet() const
-                        {
-                                return pCache != NULL;
-                        }
-
-                        const keytype &getKey() const
-                        {
-                                return kId;
-                        }
-
-                        void unbind()
-                        {
-                                if( pCache && pData )
-                                        pCache->decRef( kId );
-                                pData = NULL;
-                        }
-
-                        void clear()
-                        {
-                                unbind();
-                                pCache = NULL;
-                        }
-
-                        void unset()
-                        {
-                                clear();
-                        }
-
-                        Ptr &operator=( const Ptr &rRhs )
-                        {
-                                if( pCache && pData )
-                                        pCache->decRef( kId );
-                                pCache = rRhs.pCache;
-                                pData = rRhs.pData;
-                                kId = rRhs.kId;
-                                if( pCache && pData )
-                                        pCache->incRef( kId );
-                                return *this;
-                        }
-
-                        bool operator==( const Ptr &rRhs ) const
-                        {
-                                return pCache == rRhs.pCache && kId == rRhs.kId;
-                        }
-
-                        bool operator!=( const Ptr &rRhs ) const
-                        {
-                                return pCache != rRhs.pCache || kId != rRhs.kId;
-                        }
-
-                private:
-                        void checkPtr() const
-                        {
-                                if( pCache && !pData )
-                                {
-                                        pData = pCache->getRaw( kId );
-                                        pCache->incRef( kId );
-                                }
-                        }
-
-                private:
-                        Bu::Cache<keytype, obtype> *pCache;
-                        mutable obtype *pData;
-                        mutable keytype kId;
-                };
-
-        private:
-                typedef Bu::CacheStore<keytype, obtype> Store;
-                typedef Bu::List<Store *> StoreList;
-                typedef Bu::CacheCalc<keytype, obtype> Calc;
-                
-                typedef struct CacheEntry
-                {
-                        obtype *pData;
-                        int iRefs;
-                        time_t tLastSync;
-                } CacheEntry;
-
-                typedef Bu::Hash<keytype, CacheEntry> CidHash;
-
-        public:
-                typedef keytype Key;
-                Cache( Calc *pCalc, Store *pStore ) :
-                        pCalc( pCalc ),
-                        pStore( pStore )
-                {
-                        TRACE();
-                        pCalc->setCache( this );
-                }
-
-                virtual ~Cache()
-                {
-                        TRACE();
-
-                        // Better safe than sorry, better try a sync before anything
-                        // else happens.
-                        sync();
-
-                        // Cycle through and unload all objects from the system.
-                        for( typename CidHash::iterator i = hEnt.begin();
-                                 i != hEnt.end(); i++ )
-                        {
-                                if( i.getValue().iRefs > 0 )
-                                {
-                                        // TODO: Throw an error in this case? iRefs != 0 for an
-                                        // object when the Cache is destroyed.
-                                        throw Bu::ExceptionBase("iRefs not zero.");
-                                }
-                                pStore->unload(
-                                        i.getValue().pData,
-                                        i.getKey()
-                                        );
-                        }
-                        delete pCalc;
-                        delete pStore;
-                }
-
-                Ptr insert( obtype *pData )
-                {
-                        TRACE( pData );
-                        if( pStore->has( __cacheGetKey<keytype, obtype>( pData ) ) )
-                                throw Bu::ExceptionBase("Key already exists in cache.");
-                        CacheEntry e = {pData, 0, 0};
-                        keytype k = pStore->create( pData );
-                        hEnt.insert( k, e );
-
-                        pCalc->onLoad( pData, k );
-
-                        pStore->sync();
-
-                        return Ptr( this, pData, k );
-                }
-
-                bool has( const keytype &cId )
-                {
-                        return hEnt.has( cId ) || pStore->has( cId );
-                }
-
-                /**
-                 * Retrieve an object from the cache and return a pointer to it.
-                 * The object returned may be loaded from backend storage if needed,
-                 * or the currently live object will be returned.
-                 *@param cId The id of the object to load.
-                 *@returns A pointer to the object.
-                 */
-                Ptr get( const keytype &cId )
-                {
-                        TRACE( cId );
-                        try {
-                                return Ptr( this, hEnt.get( cId ).pData, cId );
-                        }
-                        catch( Bu::HashException &e ) {
-                                CacheEntry e = {pStore->load( cId ), 0, time( NULL )};
-                                pCalc->onLoad( e.pData, cId );
-                                hEnt.insert( cId, e );
-                                return Ptr( this, e.pData, cId );
-                        }
-                }
-
-                /**
-                 * Retrieve a handle to an object without loading it now.  This function
-                 * will return a pointer that has not yet been "realized" but can be
-                 * used normally.  Upon initial use in any way the object will be
-                 * loaded from the cache, either linking against the already loaded
-                 * object or loading it fresh from the backend storage.  The advantage
-                 * of this is that you recieve a usable handle to the data, but it
-                 * does not count as a reference yet, meaning that the data is loaded
-                 * when you need it, not before.
-                 */
-                Ptr getLazy( const keytype &cId )
-                {
-                        TRACE( cId );
-                        return Ptr( this, cId );
-                }
-
-                int getRefCount( const keytype &cId )
-                {
-                        TRACE( cId );
-                        return hEnt.get( cId ).iRefs;
-                }
-
-                void unload( const keytype &cId )
-                {
-                        TRACE( cId );
-                        try {
-                                if( hEnt.get( cId ).iRefs > 0 )
-                                {
-                                        printf("Shouldn't unload, references still exist!\n");
-                                        return;
-                                }
-                        }
-                        catch( Bu::HashException &e ) {
-                                // It's not here?  Eh, return.
-                                return;
-                        }
-                        obtype *pObj = hEnt.get( cId ).pData;
-                        pCalc->onUnload( pObj, cId );
-                        hEnt.erase( cId );
-
-                        // The unload has to happen last just in case cId is a reference
-                        // to data that is about to be deleted from memory by the unload.
-                        pStore->unload( pObj, cId );
-                }
-
-                void erase( const keytype &cId )
-                {
-                        TRACE( cId );
-                        try {
-                                if( hEnt.get( cId ).iRefs > 0 )
-                                {
-                                        printf("Shouldn't erase, references still exist!\n");
-                                        return;
-                                }
-
-                                obtype *pObj = hEnt.get( cId ).pData;
-                                pCalc->onDestroy( pObj, cId );
-                                hEnt.erase( cId );
-
-                                pStore->destroy( pObj, cId );
-                                pStore->sync();
-                        }
-                        catch( Bu::HashException &e ) {
-                                pCalc->onDestroy( cId );
-
-                                if( hEnt.has( cId ) )
-                                {
-                                        // The object was loaded by onDestroy
-                                        erase( cId );
-                                }
-                                else
-                                {
-                                        pStore->destroy( cId );
-                                        pStore->sync();
-                                }
-                        }
-                }
-
-                typedef Bu::List<keytype> KeyList;
-                KeyList getKeys()
-                {
-                        return pStore->getKeys();
-                }
-
-                KeyList getActiveKeys()
-                {
-                        return hEnt.getKeys();
-                }
-
-                int getSize()
-                {
-                        return pStore->getSize();
-                }
-
-                /**
-                 * Make sure all currently loaded but not-in-use objects are synced to
-                 * the store.
-                 */
-                void sync()
-                {
-                        TRACE();
-                        int iSynced = 0;
-                        for( typename CidHash::iterator i = hEnt.begin();
-                                 i != hEnt.end(); i++ )
-                        {
-                                if( i.getValue().iRefs == 0 )
-                                {
-                                        if( pCalc->shouldSync(
-                                                        i.getValue().pData,
-                                                        i.getKey(),
-                                                        i.getValue().tLastSync
-                                                        ) )
-                                        {
-                                                pStore->sync(
-                                                        i.getValue().pData,
-                                                        i.getKey()
-                                                        );
-                                                iSynced++;
-                                                i.getValue().tLastSync = time( NULL );
-                                        }
-                                }
-                        }
-                        if( iSynced > 0 )
-                        {
-                                pStore->sync();
-                        }
-                }
-
-        private:
-                void incRef( const keytype &cId )
-                {
-                        TRACE( cId );
-                        hEnt.get( cId ).iRefs++;
-                }
-
-                void decRef( const keytype &cId )
-                {
-                        TRACE( cId );
-                        CacheEntry &e = hEnt.get( cId );
-                        e.iRefs--;
-                }
-
-                obtype *getRaw( const keytype &cId )
-                {
-                        TRACE( cId );
-                        try {
-                                return hEnt.get( cId ).pData;
-                        }
-                        catch( Bu::HashException &e ) {
-                                CacheEntry e = {pStore->load( cId ), 0, time( NULL )};
-                                pCalc->onLoad( e.pData, cId );
-                                hEnt.insert( cId, e );
-                                return e.pData;
-                        }
-                }
-
-        private:
-                CidHash hEnt;
-                Calc *pCalc;
-                Store *pStore;
-        };
+//  template<class keytype, class obtype>
+//  keytype __cacheGetKey( obtype *&pObj );
+    template<class keytype, class obtype>
+    keytype __cacheGetKey( const obtype *pObj )
+    {
+        return pObj->getKey();
+    }
+
+    template<class keytype, class obtype>
+    class Cache
+    {
+    public:
+        /**
+         * Cache Pointer - Provides access to data that is held within the
+         * cache.  This provides safe, refcounting access to data stored in
+         * the cache, with support for lazy loading.
+         */
+        class Ptr
+        {
+        friend class Bu::Cache<keytype, obtype>;
+        private:
+            Ptr( Cache<keytype, obtype> *pCache, obtype *pData,
+                const keytype &kId ) :
+                pCache( pCache ),
+                pData( pData ),
+                kId( kId )
+            {
+                if( pCache )
+                    pCache->incRef( kId );
+            }
+            
+            Ptr( Cache<keytype, obtype> *pCache, const keytype &kId ) :
+                pCache( pCache ),
+                pData( NULL ),
+                kId( kId )
+            {
+            }
+
+        public:
+            Ptr( const Ptr &rSrc ) :
+                pCache( rSrc.pCache ),
+                pData( rSrc.pData ),
+                kId( rSrc.kId )
+            {
+                if( pCache && pData )
+                    pCache->incRef( kId );
+            }
+
+            Ptr() :
+                pCache( 0 ),
+                pData( 0 )
+            {
+            }
+
+            virtual ~Ptr()
+            {
+                if( pCache && pData )
+                    pCache->decRef( kId );
+            }
+
+            obtype &operator*()
+            {
+                checkPtr();
+                return *pData;
+            }
+
+            const obtype &operator*() const
+            {
+                checkPtr();
+                return *pData;
+            }
+
+            obtype *operator->()
+            {
+                checkPtr();
+                return pData;
+            }
+
+            const obtype *operator->() const
+            {
+                checkPtr();
+                return pData;
+            }
+
+            bool isValid() const
+            {
+                return pCache != NULL;
+            }
+
+            bool isBound() const
+            {
+                return pData != NULL;
+            }
+
+            bool isSet() const
+            {
+                return pCache != NULL;
+            }
+
+            const keytype &getKey() const
+            {
+                return kId;
+            }
+
+            void unbind()
+            {
+                if( pCache && pData )
+                    pCache->decRef( kId );
+                pData = NULL;
+            }
+
+            void clear()
+            {
+                unbind();
+                pCache = NULL;
+            }
+
+            void unset()
+            {
+                clear();
+            }
+
+            Ptr &operator=( const Ptr &rRhs )
+            {
+                if( pCache && pData )
+                    pCache->decRef( kId );
+                pCache = rRhs.pCache;
+                pData = rRhs.pData;
+                kId = rRhs.kId;
+                if( pCache && pData )
+                    pCache->incRef( kId );
+                return *this;
+            }
+
+            bool operator==( const Ptr &rRhs ) const
+            {
+                return pCache == rRhs.pCache && kId == rRhs.kId;
+            }
+
+            bool operator!=( const Ptr &rRhs ) const
+            {
+                return pCache != rRhs.pCache || kId != rRhs.kId;
+            }
+
+        private:
+            void checkPtr() const
+            {
+                if( pCache && !pData )
+                {
+                    pData = pCache->getRaw( kId );
+                    pCache->incRef( kId );
+                }
+            }
+
+        private:
+            Bu::Cache<keytype, obtype> *pCache;
+            mutable obtype *pData;
+            mutable keytype kId;
+        };
+
+    private:
+        typedef Bu::CacheStore<keytype, obtype> Store;
+        typedef Bu::List<Store *> StoreList;
+        typedef Bu::CacheCalc<keytype, obtype> Calc;
+        
+        typedef struct CacheEntry
+        {
+            obtype *pData;
+            int iRefs;
+            time_t tLastSync;
+        } CacheEntry;
+
+        typedef Bu::Hash<keytype, CacheEntry> CidHash;
+
+    public:
+        typedef keytype Key;
+        Cache( Calc *pCalc, Store *pStore ) :
+            pCalc( pCalc ),
+            pStore( pStore )
+        {
+            TRACE();
+            pCalc->setCache( this );
+        }
+
+        virtual ~Cache()
+        {
+            TRACE();
+
+            // Better safe than sorry, better try a sync before anything
+            // else happens.
+            sync();
+
+            // Cycle through and unload all objects from the system.
+            for( typename CidHash::iterator i = hEnt.begin();
+                 i != hEnt.end(); i++ )
+            {
+                if( i.getValue().iRefs > 0 )
+                {
+                    // TODO: Throw an error in this case? iRefs != 0 for an
+                    // object when the Cache is destroyed.
+                    throw Bu::ExceptionBase("iRefs not zero.");
+                }
+                pStore->unload(
+                    i.getValue().pData,
+                    i.getKey()
+                    );
+            }
+            delete pCalc;
+            delete pStore;
+        }
+
+        Ptr insert( obtype *pData )
+        {
+            TRACE( pData );
+            if( pStore->has( __cacheGetKey<keytype, obtype>( pData ) ) )
+                throw Bu::ExceptionBase("Key already exists in cache.");
+            CacheEntry e = {pData, 0, 0};
+            keytype k = pStore->create( pData );
+            hEnt.insert( k, e );
+
+            pCalc->onLoad( pData, k );
+
+            pStore->sync();
+
+            return Ptr( this, pData, k );
+        }
+
+        bool has( const keytype &cId )
+        {
+            return hEnt.has( cId ) || pStore->has( cId );
+        }
+
+        /**
+         * Retrieve an object from the cache and return a pointer to it.
+         * The object returned may be loaded from backend storage if needed,
+         * or the currently live object will be returned.
+         *@param cId The id of the object to load.
+         *@returns A pointer to the object.
+         */
+        Ptr get( const keytype &cId )
+        {
+            TRACE( cId );
+            try {
+                return Ptr( this, hEnt.get( cId ).pData, cId );
+            }
+            catch( Bu::HashException &e ) {
+                CacheEntry e = {pStore->load( cId ), 0, time( NULL )};
+                pCalc->onLoad( e.pData, cId );
+                hEnt.insert( cId, e );
+                return Ptr( this, e.pData, cId );
+            }
+        }
+
+        /**
+         * Retrieve a handle to an object without loading it now.  This function
+         * will return a pointer that has not yet been "realized" but can be
+         * used normally.  Upon initial use in any way the object will be
+         * loaded from the cache, either linking against the already loaded
+         * object or loading it fresh from the backend storage.  The advantage
+         * of this is that you recieve a usable handle to the data, but it
+         * does not count as a reference yet, meaning that the data is loaded
+         * when you need it, not before.
+         */
+        Ptr getLazy( const keytype &cId )
+        {
+            TRACE( cId );
+            return Ptr( this, cId );
+        }
+
+        int getRefCount( const keytype &cId )
+        {
+            TRACE( cId );
+            return hEnt.get( cId ).iRefs;
+        }
+
+        void unload( const keytype &cId )
+        {
+            TRACE( cId );
+            try {
+                if( hEnt.get( cId ).iRefs > 0 )
+                {
+                    printf("Shouldn't unload, references still exist!\n");
+                    return;
+                }
+            }
+            catch( Bu::HashException &e ) {
+                // It's not here?  Eh, return.
+                return;
+            }
+            obtype *pObj = hEnt.get( cId ).pData;
+            pCalc->onUnload( pObj, cId );
+            hEnt.erase( cId );
+
+            // The unload has to happen last just in case cId is a reference
+            // to data that is about to be deleted from memory by the unload.
+            pStore->unload( pObj, cId );
+        }
+
+        void erase( const keytype &cId )
+        {
+            TRACE( cId );
+            try {
+                if( hEnt.get( cId ).iRefs > 0 )
+                {
+                    printf("Shouldn't erase, references still exist!\n");
+                    return;
+                }
+
+                obtype *pObj = hEnt.get( cId ).pData;
+                pCalc->onDestroy( pObj, cId );
+                hEnt.erase( cId );
+
+                pStore->destroy( pObj, cId );
+                pStore->sync();
+            }
+            catch( Bu::HashException &e ) {
+                pCalc->onDestroy( cId );
+
+                if( hEnt.has( cId ) )
+                {
+                    // The object was loaded by onDestroy
+                    erase( cId );
+                }
+                else
+                {
+                    pStore->destroy( cId );
+                    pStore->sync();
+                }
+            }
+        }
+
+        typedef Bu::List<keytype> KeyList;
+        KeyList getKeys()
+        {
+            return pStore->getKeys();
+        }
+
+        KeyList getActiveKeys()
+        {
+            return hEnt.getKeys();
+        }
+
+        int getSize()
+        {
+            return pStore->getSize();
+        }
+
+        /**
+         * Make sure all currently loaded but not-in-use objects are synced to
+         * the store.
+         */
+        void sync()
+        {
+            TRACE();
+            int iSynced = 0;
+            for( typename CidHash::iterator i = hEnt.begin();
+                 i != hEnt.end(); i++ )
+            {
+                if( i.getValue().iRefs == 0 )
+                {
+                    if( pCalc->shouldSync(
+                            i.getValue().pData,
+                            i.getKey(),
+                            i.getValue().tLastSync
+                            ) )
+                    {
+                        pStore->sync(
+                            i.getValue().pData,
+                            i.getKey()
+                            );
+                        iSynced++;
+                        i.getValue().tLastSync = time( NULL );
+                    }
+                }
+            }
+            if( iSynced > 0 )
+            {
+                pStore->sync();
+            }
+        }
+
+    private:
+        void incRef( const keytype &cId )
+        {
+            TRACE( cId );
+            hEnt.get( cId ).iRefs++;
+        }
+
+        void decRef( const keytype &cId )
+        {
+            TRACE( cId );
+            CacheEntry &e = hEnt.get( cId );
+            e.iRefs--;
+        }
+
+        obtype *getRaw( const keytype &cId )
+        {
+            TRACE( cId );
+            try {
+                return hEnt.get( cId ).pData;
+            }
+            catch( Bu::HashException &e ) {
+                CacheEntry e = {pStore->load( cId ), 0, time( NULL )};
+                pCalc->onLoad( e.pData, cId );
+                hEnt.insert( cId, e );
+                return e.pData;
+            }
+        }
+
+    private:
+        CidHash hEnt;
+        Calc *pCalc;
+        Store *pStore;
+    };
 };
 
 #endif
diff --git a/src/experimental/cachecalc.h b/src/experimental/cachecalc.h
index ecfa3f4..cb5c755 100644
--- a/src/experimental/cachecalc.h
+++ b/src/experimental/cachecalc.h
@@ -14,50 +14,50 @@
 
 namespace Bu
 {
-        template<class keytype, class obtype> class Cache;
-
-        template<class keytype, class obtype>
-        class CacheCalc
-        {
-        friend class Cache<keytype, obtype>;
-        private:
-                typedef Cache<keytype, obtype> MyCache;
-        public:
-                CacheCalc() :
-                        pCache( (MyCache *)0 )
-                {
-                        TRACE();
-                }
-
-                virtual ~CacheCalc()
-                {
-                        TRACE();
-                }
-
-                virtual void onLoad( obtype *pSrc, const keytype &key )=0;
-                virtual void onUnload( obtype *pSrc, const keytype &key )=0;
-                virtual void onDestroy( obtype *pSrc, const keytype &key )=0;
-                virtual void onDestroy( const keytype &key )=0;
-                virtual bool shouldSync( obtype *pSrc, const keytype &key,
-                        time_t tLastSync )=0;
-                virtual void onTick() { };
-
-        protected:
-                MyCache *getCache()
-                {
-                        TRACE();
-                        return pCache;
-                }
-
-        private:
-                void setCache( MyCache *pCache )
-                {
-                        TRACE();
-                        this->pCache = pCache;
-                }
-
-                MyCache *pCache;
-        };
+    template<class keytype, class obtype> class Cache;
+
+    template<class keytype, class obtype>
+    class CacheCalc
+    {
+    friend class Cache<keytype, obtype>;
+    private:
+        typedef Cache<keytype, obtype> MyCache;
+    public:
+        CacheCalc() :
+            pCache( (MyCache *)0 )
+        {
+            TRACE();
+        }
+
+        virtual ~CacheCalc()
+        {
+            TRACE();
+        }
+
+        virtual void onLoad( obtype *pSrc, const keytype &key )=0;
+        virtual void onUnload( obtype *pSrc, const keytype &key )=0;
+        virtual void onDestroy( obtype *pSrc, const keytype &key )=0;
+        virtual void onDestroy( const keytype &key )=0;
+        virtual bool shouldSync( obtype *pSrc, const keytype &key,
+            time_t tLastSync )=0;
+        virtual void onTick() { };
+
+    protected:
+        MyCache *getCache()
+        {
+            TRACE();
+            return pCache;
+        }
+
+    private:
+        void setCache( MyCache *pCache )
+        {
+            TRACE();
+            this->pCache = pCache;
+        }
+
+        MyCache *pCache;
+    };
 };
 
 #endif
diff --git a/src/experimental/cachestore.h b/src/experimental/cachestore.h
index a332e49..5052670 100644
--- a/src/experimental/cachestore.h
+++ b/src/experimental/cachestore.h
@@ -12,35 +12,35 @@
 
 namespace Bu
 {
-        /**
-         * Handles I/O for data in the cache.  This also assigns ID's to the newly
-         * created objects that are requested through this system.
-         */
-        template<class keytype, class obtype>
-        class CacheStore
-        {
-        public:
-                CacheStore()
-                {
-                }
+    /**
+     * Handles I/O for data in the cache.  This also assigns ID's to the newly
+     * created objects that are requested through this system.
+     */
+    template<class keytype, class obtype>
+    class CacheStore
+    {
+    public:
+        CacheStore()
+        {
+        }
 
-                virtual ~CacheStore()
-                {
-                }
+        virtual ~CacheStore()
+        {
+        }
 
-                virtual obtype *load( const keytype &key )=0;
-                virtual void unload( obtype *pObj, const keytype &key )=0;
-                virtual keytype create( obtype *pSrc )=0;
-                virtual void sync()=0;
-                virtual void sync( obtype *pObj, const keytype &key )=0;
-                virtual void destroy( obtype *pObj, const keytype &key )=0;
-                virtual void destroy( const keytype &key )=0;
-                virtual bool has( const keytype &key )=0;
-                virtual Bu::List<keytype> getKeys() { return Bu::List<keytype>(); }
-                virtual int getSize() { return -1; }
+        virtual obtype *load( const keytype &key )=0;
+        virtual void unload( obtype *pObj, const keytype &key )=0;
+        virtual keytype create( obtype *pSrc )=0;
+        virtual void sync()=0;
+        virtual void sync( obtype *pObj, const keytype &key )=0;
+        virtual void destroy( obtype *pObj, const keytype &key )=0;
+        virtual void destroy( const keytype &key )=0;
+        virtual bool has( const keytype &key )=0;
+        virtual Bu::List<keytype> getKeys() { return Bu::List<keytype>(); }
+        virtual int getSize() { return -1; }
 
-        private:
-        };
+    private:
+    };
 };
 
 #endif
diff --git a/src/experimental/cachestorefiles.h b/src/experimental/cachestorefiles.h
index d3a6894..0805e7b 100644
--- a/src/experimental/cachestorefiles.h
+++ b/src/experimental/cachestorefiles.h
@@ -23,188 +23,188 @@
 
 namespace Bu
 {
-        template<class keytype, class obtype>
-        keytype __cacheGetKey( const obtype *pObj );
-
-        template<class keytype, class obtype>
-        obtype *__cacheStoreFilesAlloc( const keytype &key )
-        {
-                return new obtype();
-        }
-
-        template<class keytype, class obtype>
-        void __cacheStoreFilesStore( Bu::Stream &s, obtype &rObj,
-                        const keytype & )
-        {
-                Bu::Archive ar( s, Bu::Archive::save );
-                ar << rObj;
-        }
-
-        template<class keytype, class obtype>
-        obtype *__cacheStoreFilesLoad( Bu::Stream &s, const keytype &key )
-        {
-                obtype *pObj = __cacheStoreFilesAlloc<keytype, obtype>( key );
-                Bu::Archive ar( s, Bu::Archive::load );
-                ar >> (*pObj);
-                return pObj;
-        }
-
-        template<class keytype, class obtype>
-        class CacheStoreFiles : public CacheStore<keytype, obtype>
-        {
-        public:
-                CacheStoreFiles( const Bu::String &sPrefix ) :
-                        sPrefix( sPrefix )
-                {
-                        if( access( sPrefix.getStr(), W_OK|R_OK|X_OK ) )
-                        {
+    template<class keytype, class obtype>
+    keytype __cacheGetKey( const obtype *pObj );
+
+    template<class keytype, class obtype>
+    obtype *__cacheStoreFilesAlloc( const keytype &key )
+    {
+        return new obtype();
+    }
+
+    template<class keytype, class obtype>
+    void __cacheStoreFilesStore( Bu::Stream &s, obtype &rObj,
+            const keytype & )
+    {
+        Bu::Archive ar( s, Bu::Archive::save );
+        ar << rObj;
+    }
+
+    template<class keytype, class obtype>
+    obtype *__cacheStoreFilesLoad( Bu::Stream &s, const keytype &key )
+    {
+        obtype *pObj = __cacheStoreFilesAlloc<keytype, obtype>( key );
+        Bu::Archive ar( s, Bu::Archive::load );
+        ar >> (*pObj);
+        return pObj;
+    }
+
+    template<class keytype, class obtype>
+    class CacheStoreFiles : public CacheStore<keytype, obtype>
+    {
+    public:
+        CacheStoreFiles( const Bu::String &sPrefix ) :
+            sPrefix( sPrefix )
+        {
+            if( access( sPrefix.getStr(), W_OK|R_OK|X_OK ) )
+            {
 #ifdef WIN32
-                                mkdir( sPrefix.getStr() );
+                mkdir( sPrefix.getStr() );
 #else
-                                mkdir( sPrefix.getStr(), 0755 );
+                mkdir( sPrefix.getStr(), 0755 );
 #endif
-                        }
-                }
-
-                virtual ~CacheStoreFiles()
-                {
-                }
-                
-                virtual obtype *load( const keytype &key )
-                {
-//                      try
-//                      {
-                                Bu::MemBuf mb;
-                                Bu::Formatter f( mb );
-                                f << sPrefix << "/" << key;
-                                Bu::File fIn( mb.getString(), Bu::File::Read );
-                                obtype *pOb = __cacheStoreFilesLoad<keytype, obtype>( fIn, key );
-                                return pOb;
-//                      }
-//                      catch( std::exception &e )
-//                      {
-//                              throw Bu::HashException( e.what() );
-//                      }
-                }
-
-                virtual void unload( obtype *pObj, const keytype & )
-                {
-                        delete pObj;
-                }
-
-                virtual keytype create( obtype *pSrc )
-                {
-                        keytype key = __cacheGetKey<keytype, obtype>( pSrc );
-                        Bu::MemBuf mb;
-                        Bu::Formatter f( mb );
-                        f << sPrefix << "/" << key;
-
-                        Bu::File fTouch( mb.getString(), Bu::File::WriteNew );
-
-                        return key;
-                }
-
-                virtual void sync()
-                {
-                }
-
-                virtual void sync( obtype *pSrc, const keytype &key )
-                {
-                        Bu::MemBuf mb;
-                        Bu::Formatter f( mb );
-                        f << sPrefix << "/" << key;
-
-                        Bu::File fOut( mb.getString(), Bu::File::WriteNew );
-                        __cacheStoreFilesStore<keytype, obtype>( fOut, *pSrc, key );
-                }
-
-                virtual void destroy( obtype *pObj, const keytype &key )
-                {
-                        Bu::MemBuf mb;
-                        Bu::Formatter f( mb );
-                        f << sPrefix << "/" << key;
-
-                        unlink( mb.getString().getStr() );
-                        delete pObj;
-                }
-
-                virtual void destroy( const keytype &key )
-                {
-                        Bu::MemBuf mb;
-                        Bu::Formatter f( mb );
-                        f << sPrefix << "/" << key;
-
-                        unlink( mb.getString().getStr() );
-                }
-
-                virtual bool has( const keytype &key )
-                {
-                        Bu::MemBuf mb;
-                        Bu::Formatter f( mb );
-                        f << sPrefix << "/";
-                        Bu::String sBase = mb.getString();
-                        f << key;
-
-                        if( sBase == mb.getString() )
-                                return false;
-
-                        return access( mb.getString().getStr(), F_OK ) == 0;
-                }
-
-                virtual Bu::List<keytype> getKeys()
-                {
-                        DIR *dir = opendir( sPrefix.getStr() );
-                        struct dirent *de;
-                        Bu::List<keytype> lKeys;
-
-                        while( (de = readdir( dir ) ) )
-                        {
-                                if( de->d_type != DT_REG )
-                                        continue;
-
-                                keytype tmp;
-                                Bu::MemBuf mb( de->d_name );
-                                Bu::Formatter f( mb );
-                                try
-                                {
-                                        Fmt fm;
-                                        fm.tokenize( false );
-                                        f << fm;
-                                        f >> tmp;
-                                }
-                                catch( Bu::ExceptionBase &e )
-                                {
-                                        Bu::sio << "Parse error in dir-scan: " << e.what()
-                                                << Bu::sio.nl;
-                                }
-                                lKeys.append( tmp );
-                        }
-                        closedir( dir );
-
-                        return lKeys;
-                }
-
-                virtual int getSize()
-                {
-                        DIR *dir = opendir( sPrefix.getStr() );
-                        struct dirent *de;
-                        int iCount = 0;
-
-                        while( (de = readdir( dir ) ) )
-                        {
-                                if( de->d_type != DT_REG )
-                                        continue;
-
-                                iCount++;
-                        }
-                        closedir( dir );
-
-                        return iCount;
-                }
-
-        private:
-                Bu::String sPrefix;
-        };
+            }
+        }
+
+        virtual ~CacheStoreFiles()
+        {
+        }
+        
+        virtual obtype *load( const keytype &key )
+        {
+//          try
+//          {
+                Bu::MemBuf mb;
+                Bu::Formatter f( mb );
+                f << sPrefix << "/" << key;
+                Bu::File fIn( mb.getString(), Bu::File::Read );
+                obtype *pOb = __cacheStoreFilesLoad<keytype, obtype>( fIn, key );
+                return pOb;
+//          }
+//          catch( std::exception &e )
+//          {
+//              throw Bu::HashException( e.what() );
+//          }
+        }
+
+        virtual void unload( obtype *pObj, const keytype & )
+        {
+            delete pObj;
+        }
+
+        virtual keytype create( obtype *pSrc )
+        {
+            keytype key = __cacheGetKey<keytype, obtype>( pSrc );
+            Bu::MemBuf mb;
+            Bu::Formatter f( mb );
+            f << sPrefix << "/" << key;
+
+            Bu::File fTouch( mb.getString(), Bu::File::WriteNew );
+
+            return key;
+        }
+
+        virtual void sync()
+        {
+        }
+
+        virtual void sync( obtype *pSrc, const keytype &key )
+        {
+            Bu::MemBuf mb;
+            Bu::Formatter f( mb );
+            f << sPrefix << "/" << key;
+
+            Bu::File fOut( mb.getString(), Bu::File::WriteNew );
+            __cacheStoreFilesStore<keytype, obtype>( fOut, *pSrc, key );
+        }
+
+        virtual void destroy( obtype *pObj, const keytype &key )
+        {
+            Bu::MemBuf mb;
+            Bu::Formatter f( mb );
+            f << sPrefix << "/" << key;
+
+            unlink( mb.getString().getStr() );
+            delete pObj;
+        }
+
+        virtual void destroy( const keytype &key )
+        {
+            Bu::MemBuf mb;
+            Bu::Formatter f( mb );
+            f << sPrefix << "/" << key;
+
+            unlink( mb.getString().getStr() );
+        }
+
+        virtual bool has( const keytype &key )
+        {
+            Bu::MemBuf mb;
+            Bu::Formatter f( mb );
+            f << sPrefix << "/";
+            Bu::String sBase = mb.getString();
+            f << key;
+
+            if( sBase == mb.getString() )
+                return false;
+
+            return access( mb.getString().getStr(), F_OK ) == 0;
+        }
+
+        virtual Bu::List<keytype> getKeys()
+        {
+            DIR *dir = opendir( sPrefix.getStr() );
+            struct dirent *de;
+            Bu::List<keytype> lKeys;
+
+            while( (de = readdir( dir ) ) )
+            {
+                if( de->d_type != DT_REG )
+                    continue;
+
+                keytype tmp;
+                Bu::MemBuf mb( de->d_name );
+                Bu::Formatter f( mb );
+                try
+                {
+                    Fmt fm;
+                    fm.tokenize( false );
+                    f << fm;
+                    f >> tmp;
+                }
+                catch( Bu::ExceptionBase &e )
+                {
+                    Bu::sio << "Parse error in dir-scan: " << e.what()
+                        << Bu::sio.nl;
+                }
+                lKeys.append( tmp );
+            }
+            closedir( dir );
+
+            return lKeys;
+        }
+
+        virtual int getSize()
+        {
+            DIR *dir = opendir( sPrefix.getStr() );
+            struct dirent *de;
+            int iCount = 0;
+
+            while( (de = readdir( dir ) ) )
+            {
+                if( de->d_type != DT_REG )
+                    continue;
+
+                iCount++;
+            }
+            closedir( dir );
+
+            return iCount;
+        }
+
+    private:
+        Bu::String sPrefix;
+    };
 
 };
 
diff --git a/src/experimental/cachestoremyriad.h b/src/experimental/cachestoremyriad.h
index 1953b61..01fe307 100644
--- a/src/experimental/cachestoremyriad.h
+++ b/src/experimental/cachestoremyriad.h
@@ -18,141 +18,141 @@
 
 namespace Bu
 {
-        template<class keytype, class obtype>
-        keytype __cacheGetKey( const obtype *pObj );
-
-        template<class keytype, class obtype>
-        obtype *__cacheStoreMyriadAlloc( const keytype &key )
-        {
-                return new obtype();
-        }
-
-        template<class keytype, class obtype>
-        void __cacheStoreMyriadStore( Bu::Stream &s, obtype &rObj,
-                        const keytype & )
-        {
-                Bu::Archive ar( s, Bu::Archive::save );
-                ar << rObj;
-        }
-
-        template<class keytype, class obtype>
-        obtype *__cacheStoreMyriadLoad( Bu::Stream &s, const keytype &key )
-        {
-                obtype *pObj = __cacheStoreMyriadAlloc<keytype, obtype>( key );
-                Bu::Archive ar( s, Bu::Archive::load );
-                ar >> (*pObj);
-                return pObj;
-        }
-
-        template<class keytype, class obtype>
-        class CacheStoreMyriad : public CacheStore<keytype, obtype>
-        {
-        public:
-                CacheStoreMyriad( Bu::Stream &sArch,
-                        int iBlockSize=512, int iPreAllocate=8 ) :
-                        mStore( sArch, iBlockSize, iPreAllocate )
-                {
-                        try
-                        {
-                                MyriadStream ns = mStore.openStream( 1 );
-                                Bu::Archive ar( ns, Bu::Archive::load );
-                                ar >> hId;
-                        }
-                        catch( Bu::MyriadException &e )
-                        {
-                                int iStream = mStore.createStream();
-                                if( iStream != 1 )
-                                        throw Bu::ExceptionBase("That's...horrible...id = %d.\n\n",
-                                                        iStream );
-                                MyriadStream ns = mStore.openStream( 1 );
-                                Bu::Archive ar( ns, Bu::Archive::save );
-                                ar << hId;
-                        }
-                }
-
-                virtual ~CacheStoreMyriad()
-                {
-                        MyriadStream ns = mStore.openStream( 1 );
-                        Bu::Archive ar( ns, Bu::Archive::save );
-                        ar << hId;
-                }
-                
-                virtual obtype *load( const keytype &key )
-                {
-                        int iStream = hId.get( key );
-                        MyriadStream ns = mStore.openStream( iStream );
-                        obtype *pOb = __cacheStoreMyriadLoad<keytype, obtype>( ns, key );
-                        return pOb;
-                }
-
-                virtual void unload( obtype *pObj, const keytype & )
-                {
-                        delete pObj;
-                }
-
-                virtual keytype create( obtype *pSrc )
-                {
-                        keytype key = __cacheGetKey<keytype, obtype>( pSrc );
-                        int iStream = mStore.createStream();
-                        hId.insert( key, iStream );
-                        MyriadStream ns = mStore.openStream( iStream );
-                        __cacheStoreMyriadStore<keytype, obtype>( ns, *pSrc, key );
-                        ns.setSize( ns.tell() );
-                        return key;
-                }
-
-                virtual void sync()
-                {
-                        MyriadStream ns = mStore.openStream( 1 );
-                        Bu::Archive ar( ns, Bu::Archive::save );
-                        ar << hId;
-                        ns.setSize( ns.tell() );
-                        mStore.sync();
-                }
-
-                virtual void sync( obtype *pSrc, const keytype &key )
-                {
-                        int iStream = hId.get( key );
-                        MyriadStream ns = mStore.openStream( iStream );
-                        __cacheStoreMyriadStore<keytype, obtype>( ns, *pSrc, key );
-                        ns.setSize( ns.tell() );
-                }
-
-                virtual void destroy( obtype *pObj, const keytype &key )
-                {
-                        int iStream = hId.get( key );
-                        mStore.deleteStream( iStream );
-                        hId.erase( key );
-                        delete pObj;
-                }
-
-                virtual void destroy( const keytype &key )
-                {
-                        int iStream = hId.get( key );
-                        mStore.deleteStream( iStream );
-                        hId.erase( key );
-                }
-
-                virtual bool has( const keytype &key )
-                {
-                        return hId.has( key );
-                }
-
-                virtual Bu::List<keytype> getKeys()
-                {
-                        return hId.getKeys();
-                }
-
-                virtual int getSize()
-                {
-                        return hId.getSize();
-                }
-
-        private:
-                Myriad mStore;
-                typedef Bu::Hash<keytype, long> StreamHash;
-                StreamHash hId;
-        };
+    template<class keytype, class obtype>
+    keytype __cacheGetKey( const obtype *pObj );
+
+    template<class keytype, class obtype>
+    obtype *__cacheStoreMyriadAlloc( const keytype &key )
+    {
+        return new obtype();
+    }
+
+    template<class keytype, class obtype>
+    void __cacheStoreMyriadStore( Bu::Stream &s, obtype &rObj,
+            const keytype & )
+    {
+        Bu::Archive ar( s, Bu::Archive::save );
+        ar << rObj;
+    }
+
+    template<class keytype, class obtype>
+    obtype *__cacheStoreMyriadLoad( Bu::Stream &s, const keytype &key )
+    {
+        obtype *pObj = __cacheStoreMyriadAlloc<keytype, obtype>( key );
+        Bu::Archive ar( s, Bu::Archive::load );
+        ar >> (*pObj);
+        return pObj;
+    }
+
+    template<class keytype, class obtype>
+    class CacheStoreMyriad : public CacheStore<keytype, obtype>
+    {
+    public:
+        CacheStoreMyriad( Bu::Stream &sArch,
+            int iBlockSize=512, int iPreAllocate=8 ) :
+            mStore( sArch, iBlockSize, iPreAllocate )
+        {
+            try
+            {
+                MyriadStream ns = mStore.openStream( 1 );
+                Bu::Archive ar( ns, Bu::Archive::load );
+                ar >> hId;
+            }
+            catch( Bu::MyriadException &e )
+            {
+                int iStream = mStore.createStream();
+                if( iStream != 1 )
+                    throw Bu::ExceptionBase("That's...horrible...id = %d.\n\n",
+                            iStream );
+                MyriadStream ns = mStore.openStream( 1 );
+                Bu::Archive ar( ns, Bu::Archive::save );
+                ar << hId;
+            }
+        }
+
+        virtual ~CacheStoreMyriad()
+        {
+            MyriadStream ns = mStore.openStream( 1 );
+            Bu::Archive ar( ns, Bu::Archive::save );
+            ar << hId;
+        }
+        
+        virtual obtype *load( const keytype &key )
+        {
+            int iStream = hId.get( key );
+            MyriadStream ns = mStore.openStream( iStream );
+            obtype *pOb = __cacheStoreMyriadLoad<keytype, obtype>( ns, key );
+            return pOb;
+        }
+
+        virtual void unload( obtype *pObj, const keytype & )
+        {
+            delete pObj;
+        }
+
+        virtual keytype create( obtype *pSrc )
+        {
+            keytype key = __cacheGetKey<keytype, obtype>( pSrc );
+            int iStream = mStore.createStream();
+            hId.insert( key, iStream );
+            MyriadStream ns = mStore.openStream( iStream );
+            __cacheStoreMyriadStore<keytype, obtype>( ns, *pSrc, key );
+            ns.setSize( ns.tell() );
+            return key;
+        }
+
+        virtual void sync()
+        {
+            MyriadStream ns = mStore.openStream( 1 );
+            Bu::Archive ar( ns, Bu::Archive::save );
+            ar << hId;
+            ns.setSize( ns.tell() );
+            mStore.sync();
+        }
+
+        virtual void sync( obtype *pSrc, const keytype &key )
+        {
+            int iStream = hId.get( key );
+            MyriadStream ns = mStore.openStream( iStream );
+            __cacheStoreMyriadStore<keytype, obtype>( ns, *pSrc, key );
+            ns.setSize( ns.tell() );
+        }
+
+        virtual void destroy( obtype *pObj, const keytype &key )
+        {
+            int iStream = hId.get( key );
+            mStore.deleteStream( iStream );
+            hId.erase( key );
+            delete pObj;
+        }
+
+        virtual void destroy( const keytype &key )
+        {
+            int iStream = hId.get( key );
+            mStore.deleteStream( iStream );
+            hId.erase( key );
+        }
+
+        virtual bool has( const keytype &key )
+        {
+            return hId.has( key );
+        }
+
+        virtual Bu::List<keytype> getKeys()
+        {
+            return hId.getKeys();
+        }
+
+        virtual int getSize()
+        {
+            return hId.getSize();
+        }
+
+    private:
+        Myriad mStore;
+        typedef Bu::Hash<keytype, long> StreamHash;
+        StreamHash hId;
+    };
 };
 
 #endif
diff --git a/src/experimental/cipher.h b/src/experimental/cipher.h
index 5d5cb07..6e58613 100644
--- a/src/experimental/cipher.h
+++ b/src/experimental/cipher.h
@@ -13,115 +13,115 @@
 
 namespace Bu
 {
-        template<int iBlockSize>
-        class Cipher : public Bu::Filter
-        {
-        public:
-                Cipher( Bu::Stream &rNext ) :
-                        Bu::Filter( rNext ),
-                        iReadBufFill( 0 ),
-                        iReadBufPos( 0 ),
-                        iWriteBufFill( 0 )
-                {
-                }
-
-                virtual ~Cipher()
-                {
-                }
-
-                virtual void start()
-                {
-                }
-
-                virtual Bu::size stop()
-                {
-                        flush();
-                        return 0;
-                }
-
-                virtual Bu::size read( void *pBuf, Bu::size iBytes )
-                {
-                        Bu::size iRead = 0;
-                        while( iRead < iBytes )
-                        {
-                                if( iReadBufFill < iBlockSize )
-                                {
-                                        int iR = rNext.read(
-                                                aReadBuf+iReadBufFill,
-                                                iBlockSize-iReadBufFill
-                                                );
-                                        if( iR == 0 )
-                                                return iRead;
-
-                                        iReadBufFill += iR;
-
-                                        if( iReadBufFill == iBlockSize )
-                                                decipher( aReadBuf );
-                                }
-
-                                if( iReadBufFill == iBlockSize )
-                                {
-                                        int iCpy = Bu::buMin( (int)(iBytes-iRead), iBlockSize-iReadBufPos );
-                                        memcpy( ((char *)pBuf)+iRead, aReadBuf+iReadBufPos, iCpy );
-                                        iRead += iCpy;
-                                        iReadBufPos += iCpy;
-                                        if( iReadBufPos == iBlockSize )
-                                        {
-                                                iReadBufPos = iReadBufFill = 0;
-                                        }
-                                }
-                        }
-
-                        return iRead;
-                }
-
-                virtual Bu::size write( const void *pBuf, Bu::size iBytes )
-                {
-                        Bu::size iPos = 0;
-                        
-                        while( iPos < iBytes )
-                        {
-                                int iLeft = Bu::buMin((int)(iBytes-iPos),iBlockSize-iWriteBufFill);
-                                memcpy( aWriteBuf+iWriteBufFill, (char *)pBuf+iPos, iLeft );
-                                iPos += iLeft;
-                                iWriteBufFill += iLeft;
-                                if( iWriteBufFill == iBlockSize )
-                                {
-                                        encipher( aWriteBuf );
-                                        rNext.write( aWriteBuf, iBlockSize );
-                                        iWriteBufFill = 0;
-                                }
-                        }
-
-                        return iPos;
-                }
-
-                virtual void flush()
-                {
-                        if( iWriteBufFill > 0 && iWriteBufFill < iBlockSize )
-                        {
-                                memset( aWriteBuf+iWriteBufFill, 0, iBlockSize-iWriteBufFill );
-                                encipher( aWriteBuf );
-                                rNext.write( aWriteBuf, iBlockSize );
-                                iWriteBufFill = 0;
-                        }
-                        rNext.flush();
-                }
-
-                using Bu::Stream::read;
-                using Bu::Stream::write;
-
-        protected:
-                virtual void encipher( void *pData )=0;
-                virtual void decipher( void *pData )=0;
-
-        private:
-                char aReadBuf[iBlockSize];
-                char aWriteBuf[iBlockSize];
-                int iReadBufFill;
-                int iReadBufPos;
-                int iWriteBufFill;
-        };
+    template<int iBlockSize>
+    class Cipher : public Bu::Filter
+    {
+    public:
+        Cipher( Bu::Stream &rNext ) :
+            Bu::Filter( rNext ),
+            iReadBufFill( 0 ),
+            iReadBufPos( 0 ),
+            iWriteBufFill( 0 )
+        {
+        }
+
+        virtual ~Cipher()
+        {
+        }
+
+        virtual void start()
+        {
+        }
+
+        virtual Bu::size stop()
+        {
+            flush();
+            return 0;
+        }
+
+        virtual Bu::size read( void *pBuf, Bu::size iBytes )
+        {
+            Bu::size iRead = 0;
+            while( iRead < iBytes )
+            {
+                if( iReadBufFill < iBlockSize )
+                {
+                    int iR = rNext.read(
+                        aReadBuf+iReadBufFill,
+                        iBlockSize-iReadBufFill
+                        );
+                    if( iR == 0 )
+                        return iRead;
+
+                    iReadBufFill += iR;
+
+                    if( iReadBufFill == iBlockSize )
+                        decipher( aReadBuf );
+                }
+
+                if( iReadBufFill == iBlockSize )
+                {
+                    int iCpy = Bu::buMin( (int)(iBytes-iRead), iBlockSize-iReadBufPos );
+                    memcpy( ((char *)pBuf)+iRead, aReadBuf+iReadBufPos, iCpy );
+                    iRead += iCpy;
+                    iReadBufPos += iCpy;
+                    if( iReadBufPos == iBlockSize )
+                    {
+                        iReadBufPos = iReadBufFill = 0;
+                    }
+                }
+            }
+
+            return iRead;
+        }
+
+        virtual Bu::size write( const void *pBuf, Bu::size iBytes )
+        {
+            Bu::size iPos = 0;
+            
+            while( iPos < iBytes )
+            {
+                int iLeft = Bu::buMin((int)(iBytes-iPos),iBlockSize-iWriteBufFill);
+                memcpy( aWriteBuf+iWriteBufFill, (char *)pBuf+iPos, iLeft );
+                iPos += iLeft;
+                iWriteBufFill += iLeft;
+                if( iWriteBufFill == iBlockSize )
+                {
+                    encipher( aWriteBuf );
+                    rNext.write( aWriteBuf, iBlockSize );
+                    iWriteBufFill = 0;
+                }
+            }
+
+            return iPos;
+        }
+
+        virtual void flush()
+        {
+            if( iWriteBufFill > 0 && iWriteBufFill < iBlockSize )
+            {
+                memset( aWriteBuf+iWriteBufFill, 0, iBlockSize-iWriteBufFill );
+                encipher( aWriteBuf );
+                rNext.write( aWriteBuf, iBlockSize );
+                iWriteBufFill = 0;
+            }
+            rNext.flush();
+        }
+
+        using Bu::Stream::read;
+        using Bu::Stream::write;
+
+    protected:
+        virtual void encipher( void *pData )=0;
+        virtual void decipher( void *pData )=0;
+
+    private:
+        char aReadBuf[iBlockSize];
+        char aWriteBuf[iBlockSize];
+        int iReadBufFill;
+        int iReadBufPos;
+        int iWriteBufFill;
+    };
 };
 
 #endif
diff --git a/src/experimental/ciphermodecbc.h b/src/experimental/ciphermodecbc.h
index 8fbf9f6..b06a972 100644
--- a/src/experimental/ciphermodecbc.h
+++ b/src/experimental/ciphermodecbc.h
@@ -6,49 +6,49 @@
 
 namespace Bu
 {
-        template<int iBlockSize, typename CipherType>
-        class CipherModeCbc : public CipherType
-        {
-        public:
-                CipherModeCbc(class Stream &rNext ) :
-                        CipherType( rNext ),
-                        bStart( true )
-                {
-                        memset( aVector, 0, iBlockSize );
-                }
-
-                virtual ~CipherModeCbc()
-                {
-                }
-
-                void setIv( const Bu::String &sIv )
-                {
-                        memcpy( aVector, sIv.getStr(), iBlockSize );
-                }
-
-        protected:
-                void decipher( void *pBuf )
-                {
-                        uint8_t aTmp[iBlockSize];
-                        memcpy( aTmp, pBuf, iBlockSize );
-                        CipherType::decipher( pBuf );
-                        for( int j = 0; j < iBlockSize; j++ )
-                                ((uint8_t *)pBuf)[j] ^= aVector[j];
-                        memcpy( aVector, aTmp, iBlockSize );
-                }
-
-                void encipher( void *pBuf )
-                {
-                        for( int j = 0; j < iBlockSize; j++ )
-                                ((uint8_t *)pBuf)[j] ^= aVector[j];
-                        CipherType::encipher( pBuf );
-                        memcpy( aVector, pBuf, iBlockSize );
-                }
-
-        private:
-                bool bStart;
-                uint8_t aVector[iBlockSize];
-        };
+    template<int iBlockSize, typename CipherType>
+    class CipherModeCbc : public CipherType
+    {
+    public:
+        CipherModeCbc(class Stream &rNext ) :
+            CipherType( rNext ),
+            bStart( true )
+        {
+            memset( aVector, 0, iBlockSize );
+        }
+
+        virtual ~CipherModeCbc()
+        {
+        }
+
+        void setIv( const Bu::String &sIv )
+        {
+            memcpy( aVector, sIv.getStr(), iBlockSize );
+        }
+
+    protected:
+        void decipher( void *pBuf )
+        {
+            uint8_t aTmp[iBlockSize];
+            memcpy( aTmp, pBuf, iBlockSize );
+            CipherType::decipher( pBuf );
+            for( int j = 0; j < iBlockSize; j++ )
+                ((uint8_t *)pBuf)[j] ^= aVector[j];
+            memcpy( aVector, aTmp, iBlockSize );
+        }
+
+        void encipher( void *pBuf )
+        {
+            for( int j = 0; j < iBlockSize; j++ )
+                ((uint8_t *)pBuf)[j] ^= aVector[j];
+            CipherType::encipher( pBuf );
+            memcpy( aVector, pBuf, iBlockSize );
+        }
+
+    private:
+        bool bStart;
+        uint8_t aVector[iBlockSize];
+    };
 };
 
 #endif
diff --git a/src/experimental/ciphermodecfb.h b/src/experimental/ciphermodecfb.h
index dab6c2e..34c682f 100644
--- a/src/experimental/ciphermodecfb.h
+++ b/src/experimental/ciphermodecfb.h
@@ -6,48 +6,48 @@
 
 namespace Bu
 {
-        template<int iBlockSize, typename CipherType>
-        class CipherModeCfb : public CipherType
-        {
-        public:
-                CipherModeCfb(class Stream &rNext ) :
-                        CipherType( rNext ),
-                        bStart( true )
-                {
-                        memset( aVector, 0, iBlockSize );
-                }
-
-                virtual ~CipherModeCfb()
-                {
-                }
-
-                void setIv( const Bu::String &sIv )
-                {
-                        memcpy( aVector, sIv.getStr(), iBlockSize );
-                }
-
-        protected:
-                void decipher( void *pBuf )
-                {
-                        uint8_t aTmp[iBlockSize];
-                        memcpy( aTmp, pBuf, iBlockSize );
-                        CipherType::encipher( aVector );
-                        for( int j = 0; j < iBlockSize; j++ )
-                                ((uint8_t *)pBuf)[j] ^= aVector[j];
-                        memcpy( aVector, aTmp, iBlockSize );
-                }
-
-                void encipher( void *pBuf )
-                {
-                        CipherType::encipher( aVector );
-                        for( int j = 0; j < iBlockSize; j++ )
-                                aVector[j] = ((uint8_t *)pBuf)[j] ^= aVector[j];
-                }
-
-        private:
-                bool bStart;
-                uint8_t aVector[iBlockSize];
-        };
+    template<int iBlockSize, typename CipherType>
+    class CipherModeCfb : public CipherType
+    {
+    public:
+        CipherModeCfb(class Stream &rNext ) :
+            CipherType( rNext ),
+            bStart( true )
+        {
+            memset( aVector, 0, iBlockSize );
+        }
+
+        virtual ~CipherModeCfb()
+        {
+        }
+
+        void setIv( const Bu::String &sIv )
+        {
+            memcpy( aVector, sIv.getStr(), iBlockSize );
+        }
+
+    protected:
+        void decipher( void *pBuf )
+        {
+            uint8_t aTmp[iBlockSize];
+            memcpy( aTmp, pBuf, iBlockSize );
+            CipherType::encipher( aVector );
+            for( int j = 0; j < iBlockSize; j++ )
+                ((uint8_t *)pBuf)[j] ^= aVector[j];
+            memcpy( aVector, aTmp, iBlockSize );
+        }
+
+        void encipher( void *pBuf )
+        {
+            CipherType::encipher( aVector );
+            for( int j = 0; j < iBlockSize; j++ )
+                aVector[j] = ((uint8_t *)pBuf)[j] ^= aVector[j];
+        }
+
+    private:
+        bool bStart;
+        uint8_t aVector[iBlockSize];
+    };
 };
 
 #endif
diff --git a/src/experimental/ciphermodeecb.h b/src/experimental/ciphermodeecb.h
index 006741a..cac2beb 100644
--- a/src/experimental/ciphermodeecb.h
+++ b/src/experimental/ciphermodeecb.h
@@ -3,30 +3,30 @@
 
 namespace Bu
 {
-        template<int iBlockSize, typename CipherType>
-        class CipherModeEcb : public CipherType
-        {
-        public:
-                CipherModeEcb( class Stream &rNext ) :
-                        CipherType( rNext )
-                {
-                }
+    template<int iBlockSize, typename CipherType>
+    class CipherModeEcb : public CipherType
+    {
+    public:
+        CipherModeEcb( class Stream &rNext ) :
+            CipherType( rNext )
+        {
+        }
 
-                virtual ~CipherModeEcb()
-                {
-                }
-        
-        protected:
-                virtual void decipher( void *pBuf )
-                {
-                        CipherType::decipher( pBuf );
-                }
+        virtual ~CipherModeEcb()
+        {
+        }
+    
+    protected:
+        virtual void decipher( void *pBuf )
+        {
+            CipherType::decipher( pBuf );
+        }
 
-                virtual void encipher( void *pBuf )
-                {
-                        CipherType::encipher( pBuf );
-                }
-        };
+        virtual void encipher( void *pBuf )
+        {
+            CipherType::encipher( pBuf );
+        }
+    };
 };
 
 #endif
diff --git a/src/experimental/ciphermodeofb.h b/src/experimental/ciphermodeofb.h
index 8c2aa20..e1b5108 100644
--- a/src/experimental/ciphermodeofb.h
+++ b/src/experimental/ciphermodeofb.h
@@ -6,51 +6,51 @@
 
 namespace Bu
 {
-        template<int iBlockSize, typename CipherType>
-        class CipherModeOfb : public CipherType
-        {
-        public:
-                CipherModeOfb(class Stream &rNext ) :
-                        CipherType( rNext ),
-                        bStart( true )
-                {
-                        memset( aVector, 0, iBlockSize );
-                }
-
-                virtual ~CipherModeOfb()
-                {
-                }
-
-                void setIv( const Bu::String &sIv )
-                {
-                        memcpy( aVector, sIv.getStr(), iBlockSize );
-                }
-
-        protected:
-                void decipher( void *pBuf )
-                {
-                        CipherType::encipher( aVector );
-                        uint8_t aTmp[iBlockSize];
-                        memcpy( aTmp, aVector, iBlockSize );
-                        for( int j = 0; j < iBlockSize; j++ )
-                                ((uint8_t *)pBuf)[j] ^= aVector[j];
-                        memcpy( aVector, aTmp, iBlockSize );
-                }
-
-                void encipher( void *pBuf )
-                {
-                        CipherType::encipher( aVector );
-                        uint8_t aTmp[iBlockSize];
-                        memcpy( aTmp, aVector, iBlockSize );
-                        for( int j = 0; j < iBlockSize; j++ )
-                                ((uint8_t *)pBuf)[j] ^= aVector[j];
-                        memcpy( aVector, aTmp, iBlockSize );
-                }
-
-        private:
-                bool bStart;
-                uint8_t aVector[iBlockSize];
-        };
+    template<int iBlockSize, typename CipherType>
+    class CipherModeOfb : public CipherType
+    {
+    public:
+        CipherModeOfb(class Stream &rNext ) :
+            CipherType( rNext ),
+            bStart( true )
+        {
+            memset( aVector, 0, iBlockSize );
+        }
+
+        virtual ~CipherModeOfb()
+        {
+        }
+
+        void setIv( const Bu::String &sIv )
+        {
+            memcpy( aVector, sIv.getStr(), iBlockSize );
+        }
+
+    protected:
+        void decipher( void *pBuf )
+        {
+            CipherType::encipher( aVector );
+            uint8_t aTmp[iBlockSize];
+            memcpy( aTmp, aVector, iBlockSize );
+            for( int j = 0; j < iBlockSize; j++ )
+                ((uint8_t *)pBuf)[j] ^= aVector[j];
+            memcpy( aVector, aTmp, iBlockSize );
+        }
+
+        void encipher( void *pBuf )
+        {
+            CipherType::encipher( aVector );
+            uint8_t aTmp[iBlockSize];
+            memcpy( aTmp, aVector, iBlockSize );
+            for( int j = 0; j < iBlockSize; j++ )
+                ((uint8_t *)pBuf)[j] ^= aVector[j];
+            memcpy( aVector, aTmp, iBlockSize );
+        }
+
+    private:
+        bool bStart;
+        uint8_t aVector[iBlockSize];
+    };
 };
 
 #endif
diff --git a/src/experimental/dir.h b/src/experimental/dir.h
index 8e885d1..9e518eb 100644
--- a/src/experimental/dir.h
+++ b/src/experimental/dir.h
@@ -6,15 +6,15 @@
 
 namespace Bu
 {
-        class Dir : public FileSystem
-        {
-        public:
-                Dir();
-                Dir( const Bu::String &sPath );
-                virtual ~Dir();
+    class Dir : public FileSystem
+    {
+    public:
+        Dir();
+        Dir( const Bu::String &sPath );
+        virtual ~Dir();
 
-        private:
-        };
+    private:
+    };
 };
 
 #endif
diff --git a/src/experimental/fastcgi.cpp b/src/experimental/fastcgi.cpp
index 7068fa8..71426b9 100644
--- a/src/experimental/fastcgi.cpp
+++ b/src/experimental/fastcgi.cpp
@@ -8,7 +8,7 @@
 #include "bu/fastcgi.h"
 
 #ifndef WIN32
-        #include <arpa/inet.h>
+    #include <arpa/inet.h>
 #endif
 
 #include <errno.h>
@@ -21,17 +21,17 @@ using Bu::sio;
 using Bu::Fmt;
 
 Bu::FastCgi::FastCgi() :
-        pSrv( NULL ),
-        bRunning( true )
+    pSrv( NULL ),
+    bRunning( true )
 {
-        pSrv = new Bu::TcpServerSocket( (Bu::TcpServerSocket::socket_t)STDIN_FILENO, false );
+    pSrv = new Bu::TcpServerSocket( (Bu::TcpServerSocket::socket_t)STDIN_FILENO, false );
 }
 
 Bu::FastCgi::FastCgi( int iPort ) :
-        pSrv( NULL ),
-        bRunning( true )
+    pSrv( NULL ),
+    bRunning( true )
 {
-        pSrv = new Bu::TcpServerSocket( iPort );
+    pSrv = new Bu::TcpServerSocket( iPort );
 }
 
 Bu::FastCgi::~FastCgi()
@@ -41,332 +41,332 @@ Bu::FastCgi::~FastCgi()
 bool Bu::FastCgi::isEmbedded()
 {
 #ifndef WIN32
-        struct sockaddr name;
-        socklen_t namelen = sizeof(name);
-        if( getpeername( STDIN_FILENO, &name, &namelen ) != 0 &&
-                errno == ENOTCONN )
-        {
-                sio << "errno = " << errno << " (" << strerror( errno ) << ")" <<
-                        sio.nl;
-                sio << "Socket found" << sio.nl;
-                return true;
-        }
-        else
-        {
-                sio << "errno = " << errno << " (" << strerror( errno ) << ")" <<
-                        sio.nl;
-                sio << "No socket detected, running in standalone mode" << sio.nl;
-                return false;
-        }
+    struct sockaddr name;
+    socklen_t namelen = sizeof(name);
+    if( getpeername( STDIN_FILENO, &name, &namelen ) != 0 &&
+        errno == ENOTCONN )
+    {
+        sio << "errno = " << errno << " (" << strerror( errno ) << ")" <<
+            sio.nl;
+        sio << "Socket found" << sio.nl;
+        return true;
+    }
+    else
+    {
+        sio << "errno = " << errno << " (" << strerror( errno ) << ")" <<
+            sio.nl;
+        sio << "No socket detected, running in standalone mode" << sio.nl;
+        return false;
+    }
 #else
-        #warning Bu::FastCgi::isEmbedded IS A STUB for WIN32!!!!
-        return false;
+    #warning Bu::FastCgi::isEmbedded IS A STUB for WIN32!!!!
+    return false;
 #endif
 }
 
 void Bu::FastCgi::read( Bu::TcpSocket &s, Bu::FastCgi::Record &r )
 {
-        int iRead = s.read( &r, sizeof(Record) );
-        if( iRead != sizeof(Record) )
-                throw Bu::TcpSocketException("Hey, the size %d is wrong for Record. (%s)",
-                        iRead, strerror( errno ) );
-        r.uRequestId = ntohs( r.uRequestId );
-        r.uContentLength = ntohs( r.uContentLength );
+    int iRead = s.read( &r, sizeof(Record) );
+    if( iRead != sizeof(Record) )
+        throw Bu::TcpSocketException("Hey, the size %d is wrong for Record. (%s)",
+            iRead, strerror( errno ) );
+    r.uRequestId = ntohs( r.uRequestId );
+    r.uContentLength = ntohs( r.uContentLength );
 }
 
 void Bu::FastCgi::write( Bu::TcpSocket &s, Bu::FastCgi::Record r )
 {
-//      sio << "Out -> " << r << sio.nl;
-        r.uRequestId = htons( r.uRequestId );
-        r.uContentLength = htons( r.uContentLength );
-        s.write( &r, sizeof(Record) );
+//  sio << "Out -> " << r << sio.nl;
+    r.uRequestId = htons( r.uRequestId );
+    r.uContentLength = htons( r.uContentLength );
+    s.write( &r, sizeof(Record) );
 }
 
 void Bu::FastCgi::read( Bu::TcpSocket &s, Bu::FastCgi::BeginRequestBody &b )
 {
-        s.read( &b, sizeof(BeginRequestBody) );
-        b.uRole = ntohs( b.uRole );
+    s.read( &b, sizeof(BeginRequestBody) );
+    b.uRole = ntohs( b.uRole );
 }
 
 void Bu::FastCgi::write( Bu::TcpSocket &s, Bu::FastCgi::EndRequestBody b )
 {
-        b.uStatus = htonl( b.uStatus );
-        s.write( &b, sizeof(b) );
+    b.uStatus = htonl( b.uStatus );
+    s.write( &b, sizeof(b) );
 }
 
 uint32_t Bu::FastCgi::readLen( Bu::TcpSocket &s, uint16_t &uRead )
 {
-        uint8_t uByte[4];
-        s.read( uByte, 1 );
-        uRead++;
-        if( uByte[0] >> 7 == 0 )
-                return uByte[0];
-        
-        s.read( uByte+1, 3 );
-        uRead += 3;
-        return ((uByte[0]&0x7f)<<24)|(uByte[1]<<16)|(uByte[2]<<8)|(uByte[3]);
+    uint8_t uByte[4];
+    s.read( uByte, 1 );
+    uRead++;
+    if( uByte[0] >> 7 == 0 )
+        return uByte[0];
+    
+    s.read( uByte+1, 3 );
+    uRead += 3;
+    return ((uByte[0]&0x7f)<<24)|(uByte[1]<<16)|(uByte[2]<<8)|(uByte[3]);
 }
 
 void Bu::FastCgi::readPair( Bu::TcpSocket &s, StrHash &hParams, uint16_t &uRead )
 {
-        uint32_t uName = readLen( s, uRead );
-        uint32_t uValue = readLen( s, uRead );
-        uRead += uName + uValue;
-        unsigned char *sName = new unsigned char[uName];
-        s.read( sName, uName );
-        Bu::String fsName( (char *)sName, uName );
-        delete[] sName;
-
-        if( uValue > 0 )
-        {
-                unsigned char *sValue = new unsigned char[uValue];
-                s.read( sValue, uValue );
-                Bu::String fsValue( (char *)sValue, uValue );
-                hParams.insert( fsName, fsValue );
-                delete[] sValue;
-        }
-        else
-        {
-                hParams.insert( fsName, "" );
-        }
+    uint32_t uName = readLen( s, uRead );
+    uint32_t uValue = readLen( s, uRead );
+    uRead += uName + uValue;
+    unsigned char *sName = new unsigned char[uName];
+    s.read( sName, uName );
+    Bu::String fsName( (char *)sName, uName );
+    delete[] sName;
+
+    if( uValue > 0 )
+    {
+        unsigned char *sValue = new unsigned char[uValue];
+        s.read( sValue, uValue );
+        Bu::String fsValue( (char *)sValue, uValue );
+        hParams.insert( fsName, fsValue );
+        delete[] sValue;
+    }
+    else
+    {
+        hParams.insert( fsName, "" );
+    }
 }
 
 bool Bu::FastCgi::hasChannel( int iChan )
 {
-        if( aChannel.getSize() < iChan )
-                return false;
-        if( aChannel[iChan-1] == NULL )
-                return false;
-        return true;
+    if( aChannel.getSize() < iChan )
+        return false;
+    if( aChannel[iChan-1] == NULL )
+        return false;
+    return true;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::FastCgi::Record &r )
 {
-        f << "[Ver=" << (uint32_t)r.uVersion <<
-                ", Type=" << (uint32_t)r.uType <<
-                ", Req=" << (uint32_t)r.uRequestId <<
-                ", clen=" << (uint32_t)r.uContentLength <<
-                ", plen=" << (uint32_t)r.uPaddingLength <<
-                ", resv=" << (uint32_t)r.uReserved <<
-                "]";
-        return f;
+    f << "[Ver=" << (uint32_t)r.uVersion <<
+        ", Type=" << (uint32_t)r.uType <<
+        ", Req=" << (uint32_t)r.uRequestId <<
+        ", clen=" << (uint32_t)r.uContentLength <<
+        ", plen=" << (uint32_t)r.uPaddingLength <<
+        ", resv=" << (uint32_t)r.uReserved <<
+        "]";
+    return f;
 }
 
 void Bu::FastCgi::run()
 {
-//      sio << "sizeof(Bu::FastCgi::Record) = " << sizeof(Record) << sio.nl;
-        bRunning = true;
-        while( bRunning )
-        {
-                int iSock = pSrv->accept( 5 );
-                if( iSock < 0 )
-                        continue;
-
-                Bu::TcpSocket s( iSock );
-                s.setBlocking( true );
-//              sio << "Got connection, blocking?  " << s.isBlocking() << sio.nl;
-                try
-                {
-                        for(;;)
-                        {
-                                Record r;
-                                memset( &r, 0, sizeof(r) );
-//                              try
-//                              {
-                                        read( s, r );
-//                              }
-//                              catch( Bu::ExceptionBase &e )
-//                              {
-//                                      sio << "Error: " << e.what() << ", " << s.isOpen() <<
-//                                              sio.nl;
-//                                      continue;
-//                              }
-                                Channel *pChan = NULL;
-                                if( r.uRequestId > 0 )
-                                {
-                                        if( !hasChannel( r.uRequestId ) &&
-                                                r.uType != typeBeginRequest )
-                                        {
-                                                sio << "Error, stream data without stream." << sio.nl;
-                                                sio << r << sio.nl;
-                                                if( r.uContentLength > 0 )
-                                                {
-                                                        char *buf = new char[r.uContentLength];
-                                                        sio << " (read " << s.read( buf, r.uContentLength )
-                                                                << "/" << r.uContentLength << "):" << sio.nl;
-                                                        sio.write( buf, r.uContentLength );
-                                                        sio << sio.nl << sio.nl;
-                                                }
-                                        }
-                                        while( aChannel.getSize() < r.uRequestId )
-                                                aChannel.append( NULL );
-                                        if( r.uRequestId > 0 )
-                                                pChan = aChannel[r.uRequestId-1];
-                                }
-
-//                              sio << "Record (id=" << r.uRequestId << ", len=" << 
-//                                      r.uContentLength << ", pad=" << 
-//                                      (unsigned int)r.uPaddingLength << "):  ";
-//                              fflush( stdout );
-                                
-                                switch( (RequestType)r.uType )
-                                {
-                                        case typeBeginRequest:
-//                                              sio << "Begin Request.";
-                                                {
-                                                        BeginRequestBody b;
-                                                        read( s, b );
-                                                        if( pChan != NULL )
-                                                        {
-                                                                sio << "Error!!!" << sio.nl;
-                                                                return;
-                                                        }
-                                                        pChan = aChannel[r.uRequestId-1] = new Channel();
-                                                }
-                                                break;
-
-                                        case typeParams:
-//                                              sio << "Params.";
-                                                if( r.uContentLength == 0 )
-                                                {
-                                                        pChan->uFlags |= chflgParamsDone;
-                                                }
-                                                else
-                                                {
-                                                        uint16_t uUsed = 0;
-                                                        while( uUsed < r.uContentLength )
-                                                        {
-                                                                readPair( s, pChan->hParams, uUsed );
-                                                        }
-                                                }
-                                                break;
-
-                                        case typeStdIn:
-//                                              sio << "StdIn.";
-                                                if( r.uContentLength == 0 )
-                                                {
-                                                        pChan->uFlags |= chflgStdInDone;
-                                                }
-                                                else
-                                                {
-                                                        char *buf = new char[r.uContentLength];
-                                                        int iTotal = 0;
-                                                        do
-                                                        {
-                                                                size_t iRead = s.read(
-                                                                        buf, r.uContentLength-iTotal );
-                                                                iTotal += iRead;
-//                                                              sio << " (read " << iRead << " " << iTotal
-//                                                                      << "/" << r.uContentLength << ")";
-                                                                pChan->sStdIn.append( buf, iRead );
-                                                        } while( iTotal < r.uContentLength );
-                                                        delete[] buf;
-                                                }
-                                                break;
-
-                                        case typeData:
-//                                              sio << "Data.";
-                                                if( r.uContentLength == 0 )
-                                                {
-                                                        pChan->uFlags |= chflgDataDone;
-                                                }
-                                                else
-                                                {
-                                                        char *buf = new char[r.uContentLength];
-                                                        s.read( buf, r.uContentLength );
-                                                        pChan->sData.append( buf, r.uContentLength );
-                                                        delete[] buf;
-                                                }
-                                                break;
-
-                                        case typeStdOut:
-                                        case typeStdErr:
-                                        case typeEndRequest:
-                                        case typeAbortRequest:
-                                        case typeGetValuesResult:
-//                                              sio << "Scary.";
-                                                // ??? we shouldn't get these.
-                                                break;
-
-                                        case typeGetValues:
-                                                break;
-                                }
-
-//                              sio << sio.nl;
-
-                                if( pChan )
-                                {
-                                        if( pChan->uFlags == chflgAllDone )
-                                        {
-//                                              sio << "All done, generating output." << sio.nl;
-                                                Bu::MemBuf mStdOut, mStdErr;
-                                                int iRet = onRequest(
-                                                        pChan->hParams, pChan->sStdIn,
-                                                        mStdOut, mStdErr
-                                                        );
-
-                                                Bu::String &sStdOut = mStdOut.getString();
-                                                Bu::String &sStdErr = mStdErr.getString();
-
-                                                Record rOut;
-                                                memset( &rOut, 0, sizeof(rOut) );
-                                                rOut.uVersion = 1;
-                                                rOut.uRequestId = r.uRequestId;
-                                                rOut.uPaddingLength = 0;
-                                                rOut.uType = typeStdOut;
-                                                if( sStdOut.getSize() > 0 )
-                                                {
-                                                        for( int iPos = 0; iPos < sStdOut.getSize();
-                                                                 iPos += 65528 )
-                                                        {
-                                                                int iSize = sStdOut.getSize()-iPos;
-                                                                if( iSize > 65528 )
-                                                                        iSize = 65528;
-                                                                rOut.uContentLength = iSize;
-                                                                write( s, rOut );
-                                                                s.write( sStdOut.getStr()+iPos, iSize );
-                                                        }
-                                                }
-                                                rOut.uContentLength = 0;
-                                                write( s, rOut );
-
-                                                rOut.uType = typeStdErr;
-                                                if( sStdErr.getSize() > 0 )
-                                                {
-                                                        for( int iPos = 0; iPos < sStdErr.getSize();
-                                                                 iPos += 65528 )
-                                                        {
-                                                                int iSize = sStdErr.getSize()-iPos;
-                                                                if( iSize > 65528 )
-                                                                        iSize = 65528;
-                                                                rOut.uContentLength = iSize;
-                                                                write( s, rOut );
-                                                                s.write( sStdErr.getStr()+iPos, iSize );
-                                                        }
-                                                }
-                                                rOut.uContentLength = 0;
-                                                write( s, rOut );
-
-                                                rOut.uType = typeEndRequest;
-                                                rOut.uContentLength = 8;
-                                                write( s, rOut );
-                                                
-                                                EndRequestBody b;
-                                                memset( &b, 0, sizeof(b) );
-                                                b.uStatus =  iRet;
-                                                write( s, b );
-
-                                                delete pChan;
-                                                aChannel[r.uRequestId-1] = NULL;
-                                        }
-                                }
-                        }
-                }
-                catch( Bu::TcpSocketException &e )
-                {
-//                      sio << "Bu::SocketException: " << e.what() << sio.nl <<
-//                              "\tSocket open:  " << s.isOpen() << sio.nl;
-                }
-        }
+//  sio << "sizeof(Bu::FastCgi::Record) = " << sizeof(Record) << sio.nl;
+    bRunning = true;
+    while( bRunning )
+    {
+        int iSock = pSrv->accept( 5 );
+        if( iSock < 0 )
+            continue;
+
+        Bu::TcpSocket s( iSock );
+        s.setBlocking( true );
+//      sio << "Got connection, blocking?  " << s.isBlocking() << sio.nl;
+        try
+        {
+            for(;;)
+            {
+                Record r;
+                memset( &r, 0, sizeof(r) );
+//              try
+//              {
+                    read( s, r );
+//              }
+//              catch( Bu::ExceptionBase &e )
+//              {
+//                  sio << "Error: " << e.what() << ", " << s.isOpen() <<
+//                      sio.nl;
+//                  continue;
+//              }
+                Channel *pChan = NULL;
+                if( r.uRequestId > 0 )
+                {
+                    if( !hasChannel( r.uRequestId ) &&
+                        r.uType != typeBeginRequest )
+                    {
+                        sio << "Error, stream data without stream." << sio.nl;
+                        sio << r << sio.nl;
+                        if( r.uContentLength > 0 )
+                        {
+                            char *buf = new char[r.uContentLength];
+                            sio << " (read " << s.read( buf, r.uContentLength )
+                                << "/" << r.uContentLength << "):" << sio.nl;
+                            sio.write( buf, r.uContentLength );
+                            sio << sio.nl << sio.nl;
+                        }
+                    }
+                    while( aChannel.getSize() < r.uRequestId )
+                        aChannel.append( NULL );
+                    if( r.uRequestId > 0 )
+                        pChan = aChannel[r.uRequestId-1];
+                }
+
+//              sio << "Record (id=" << r.uRequestId << ", len=" << 
+//                  r.uContentLength << ", pad=" << 
+//                  (unsigned int)r.uPaddingLength << "):  ";
+//              fflush( stdout );
+                
+                switch( (RequestType)r.uType )
+                {
+                    case typeBeginRequest:
+//                      sio << "Begin Request.";
+                        {
+                            BeginRequestBody b;
+                            read( s, b );
+                            if( pChan != NULL )
+                            {
+                                sio << "Error!!!" << sio.nl;
+                                return;
+                            }
+                            pChan = aChannel[r.uRequestId-1] = new Channel();
+                        }
+                        break;
+
+                    case typeParams:
+//                      sio << "Params.";
+                        if( r.uContentLength == 0 )
+                        {
+                            pChan->uFlags |= chflgParamsDone;
+                        }
+                        else
+                        {
+                            uint16_t uUsed = 0;
+                            while( uUsed < r.uContentLength )
+                            {
+                                readPair( s, pChan->hParams, uUsed );
+                            }
+                        }
+                        break;
+
+                    case typeStdIn:
+//                      sio << "StdIn.";
+                        if( r.uContentLength == 0 )
+                        {
+                            pChan->uFlags |= chflgStdInDone;
+                        }
+                        else
+                        {
+                            char *buf = new char[r.uContentLength];
+                            int iTotal = 0;
+                            do
+                            {
+                                size_t iRead = s.read(
+                                    buf, r.uContentLength-iTotal );
+                                iTotal += iRead;
+//                              sio << " (read " << iRead << " " << iTotal
+//                                  << "/" << r.uContentLength << ")";
+                                pChan->sStdIn.append( buf, iRead );
+                            } while( iTotal < r.uContentLength );
+                            delete[] buf;
+                        }
+                        break;
+
+                    case typeData:
+//                      sio << "Data.";
+                        if( r.uContentLength == 0 )
+                        {
+                            pChan->uFlags |= chflgDataDone;
+                        }
+                        else
+                        {
+                            char *buf = new char[r.uContentLength];
+                            s.read( buf, r.uContentLength );
+                            pChan->sData.append( buf, r.uContentLength );
+                            delete[] buf;
+                        }
+                        break;
+
+                    case typeStdOut:
+                    case typeStdErr:
+                    case typeEndRequest:
+                    case typeAbortRequest:
+                    case typeGetValuesResult:
+//                      sio << "Scary.";
+                        // ??? we shouldn't get these.
+                        break;
+
+                    case typeGetValues:
+                        break;
+                }
+
+//              sio << sio.nl;
+
+                if( pChan )
+                {
+                    if( pChan->uFlags == chflgAllDone )
+                    {
+//                      sio << "All done, generating output." << sio.nl;
+                        Bu::MemBuf mStdOut, mStdErr;
+                        int iRet = onRequest(
+                            pChan->hParams, pChan->sStdIn,
+                            mStdOut, mStdErr
+                            );
+
+                        Bu::String &sStdOut = mStdOut.getString();
+                        Bu::String &sStdErr = mStdErr.getString();
+
+                        Record rOut;
+                        memset( &rOut, 0, sizeof(rOut) );
+                        rOut.uVersion = 1;
+                        rOut.uRequestId = r.uRequestId;
+                        rOut.uPaddingLength = 0;
+                        rOut.uType = typeStdOut;
+                        if( sStdOut.getSize() > 0 )
+                        {
+                            for( int iPos = 0; iPos < sStdOut.getSize();
+                                 iPos += 65528 )
+                            {
+                                int iSize = sStdOut.getSize()-iPos;
+                                if( iSize > 65528 )
+                                    iSize = 65528;
+                                rOut.uContentLength = iSize;
+                                write( s, rOut );
+                                s.write( sStdOut.getStr()+iPos, iSize );
+                            }
+                        }
+                        rOut.uContentLength = 0;
+                        write( s, rOut );
+
+                        rOut.uType = typeStdErr;
+                        if( sStdErr.getSize() > 0 )
+                        {
+                            for( int iPos = 0; iPos < sStdErr.getSize();
+                                 iPos += 65528 )
+                            {
+                                int iSize = sStdErr.getSize()-iPos;
+                                if( iSize > 65528 )
+                                    iSize = 65528;
+                                rOut.uContentLength = iSize;
+                                write( s, rOut );
+                                s.write( sStdErr.getStr()+iPos, iSize );
+                            }
+                        }
+                        rOut.uContentLength = 0;
+                        write( s, rOut );
+
+                        rOut.uType = typeEndRequest;
+                        rOut.uContentLength = 8;
+                        write( s, rOut );
+                        
+                        EndRequestBody b;
+                        memset( &b, 0, sizeof(b) );
+                        b.uStatus =  iRet;
+                        write( s, b );
+
+                        delete pChan;
+                        aChannel[r.uRequestId-1] = NULL;
+                    }
+                }
+            }
+        }
+        catch( Bu::TcpSocketException &e )
+        {
+//          sio << "Bu::SocketException: " << e.what() << sio.nl <<
+//              "\tSocket open:  " << s.isOpen() << sio.nl;
+        }
+    }
 }
 
diff --git a/src/experimental/fastcgi.h b/src/experimental/fastcgi.h
index 63d975f..50b10f5 100644
--- a/src/experimental/fastcgi.h
+++ b/src/experimental/fastcgi.h
@@ -16,118 +16,118 @@
 
 namespace Bu
 {
-        class Stream;
-
-        class FastCgi
-        {
-        public:
-                FastCgi( int iPort );
-                FastCgi();
-                virtual ~FastCgi();
-
-                static bool isEmbedded();
-
-                typedef Bu::Hash<Bu::String, Bu::String> StrHash;
-                enum RequestType
-                {
-                        typeBeginRequest        = 1,
-                        typeAbortRequest        = 2,
-                        typeEndRequest          = 3,
-                        typeParams                      = 4,
-                        typeStdIn                       = 5,
-                        typeStdOut                      = 6,
-                        typeStdErr                      = 7,
-                        typeData                        = 8,
-                        typeGetValues           = 9,
-                        typeGetValuesResult     = 10
-                };
-
-                enum Role
-                {
-                        roleResponder           = 1,
-                        roleAuthorizer          = 2,
-                        roleFilter                      = 3
-                };
-
-                enum Flags
-                {
-                        flagsKeepConn           = 1
-                };
-
-                enum Status
-                {
-                        statusRequestComplete   = 0,
-                        statusCantMpxConn               = 1,
-                        statusOverloaded                = 2,
-                        statusUnknownRole               = 3
-                };
-
-                typedef struct {
-                        uint8_t uVersion;
-                        uint8_t uType;
-                        uint16_t uRequestId;
-                        uint16_t uContentLength;
-                        uint8_t uPaddingLength;
-                        uint8_t uReserved;
-                } Record;
-
-                typedef struct {
-                        uint16_t uRole;
-                        uint8_t uFlags;
-                        uint8_t reserved[5];
-                } BeginRequestBody;
-
-                typedef struct {
-                        uint32_t uStatus;
-                        uint8_t uProtocolStatus;
-                        uint8_t reserved[3];
-                } EndRequestBody;
-
-                typedef struct Channel {
-                        Channel() : uFlags( 0 ) { }
-                        StrHash hParams;
-                        Bu::String sStdIn;
-                        Bu::String sData;
-                        uint8_t uFlags;
-                } Channel;
-
-                enum ChannelFlags
-                {
-                        chflgParamsDone         = 0x01,
-                        chflgStdInDone          = 0x02,
-                        chflgDataDone           = 0x04,
-
-                        chflgAllDone            = 0x03
-                };
-
-                virtual void run();
-
-                void stopRunning() { bRunning = false; }
-
-                virtual void onInit() { };
-                virtual int onRequest( const StrHash &hParams,
-                        const Bu::String &sStdIn, Bu::Stream &sStdOut,
-                        Bu::Stream &sStdErr )=0;
-                virtual void onUninit() { };
-
-        private:
-                void read( Bu::TcpSocket &s, Record &r );
-                void read( Bu::TcpSocket &s, BeginRequestBody &b );
-                uint32_t readLen( Bu::TcpSocket &s, uint16_t &uUsed );
-                void readPair( Bu::TcpSocket &s, StrHash &hParams, uint16_t &uUsed );
-
-                void write( Bu::TcpSocket &s, Record r );
-                void write( Bu::TcpSocket &s, EndRequestBody b );
-
-                bool hasChannel( int iChan );
-
-        private:
-                Bu::TcpServerSocket *pSrv;
-                bool bRunning;
-                Bu::Array<Channel *> aChannel;
-        };
-
-        Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::FastCgi::Record &r );
+    class Stream;
+
+    class FastCgi
+    {
+    public:
+        FastCgi( int iPort );
+        FastCgi();
+        virtual ~FastCgi();
+
+        static bool isEmbedded();
+
+        typedef Bu::Hash<Bu::String, Bu::String> StrHash;
+        enum RequestType
+        {
+            typeBeginRequest    = 1,
+            typeAbortRequest    = 2,
+            typeEndRequest      = 3,
+            typeParams          = 4,
+            typeStdIn           = 5,
+            typeStdOut          = 6,
+            typeStdErr          = 7,
+            typeData            = 8,
+            typeGetValues       = 9,
+            typeGetValuesResult = 10
+        };
+
+        enum Role
+        {
+            roleResponder       = 1,
+            roleAuthorizer      = 2,
+            roleFilter          = 3
+        };
+
+        enum Flags
+        {
+            flagsKeepConn       = 1
+        };
+
+        enum Status
+        {
+            statusRequestComplete   = 0,
+            statusCantMpxConn       = 1,
+            statusOverloaded        = 2,
+            statusUnknownRole       = 3
+        };
+
+        typedef struct {
+            uint8_t uVersion;
+            uint8_t uType;
+            uint16_t uRequestId;
+            uint16_t uContentLength;
+            uint8_t uPaddingLength;
+            uint8_t uReserved;
+        } Record;
+
+        typedef struct {
+            uint16_t uRole;
+            uint8_t uFlags;
+            uint8_t reserved[5];
+        } BeginRequestBody;
+
+        typedef struct {
+            uint32_t uStatus;
+            uint8_t uProtocolStatus;
+            uint8_t reserved[3];
+        } EndRequestBody;
+
+        typedef struct Channel {
+            Channel() : uFlags( 0 ) { }
+            StrHash hParams;
+            Bu::String sStdIn;
+            Bu::String sData;
+            uint8_t uFlags;
+        } Channel;
+
+        enum ChannelFlags
+        {
+            chflgParamsDone     = 0x01,
+            chflgStdInDone      = 0x02,
+            chflgDataDone       = 0x04,
+
+            chflgAllDone        = 0x03
+        };
+
+        virtual void run();
+
+        void stopRunning() { bRunning = false; }
+
+        virtual void onInit() { };
+        virtual int onRequest( const StrHash &hParams,
+            const Bu::String &sStdIn, Bu::Stream &sStdOut,
+            Bu::Stream &sStdErr )=0;
+        virtual void onUninit() { };
+
+    private:
+        void read( Bu::TcpSocket &s, Record &r );
+        void read( Bu::TcpSocket &s, BeginRequestBody &b );
+        uint32_t readLen( Bu::TcpSocket &s, uint16_t &uUsed );
+        void readPair( Bu::TcpSocket &s, StrHash &hParams, uint16_t &uUsed );
+
+        void write( Bu::TcpSocket &s, Record r );
+        void write( Bu::TcpSocket &s, EndRequestBody b );
+
+        bool hasChannel( int iChan );
+
+    private:
+        Bu::TcpServerSocket *pSrv;
+        bool bRunning;
+        Bu::Array<Channel *> aChannel;
+    };
+
+    Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::FastCgi::Record &r );
 };
 
 #endif
diff --git a/src/experimental/filesystem.h b/src/experimental/filesystem.h
index 0c992a5..d25cb67 100644
--- a/src/experimental/filesystem.h
+++ b/src/experimental/filesystem.h
@@ -3,22 +3,22 @@
 
 namespace Bu
 {
-        /**
-         * Represents an abstract baseclass for any file organization structure.
-         * If you're looking for acessing a local filesystem, try Bu::Dir.  This
-         * is used to make switching between different types of filesystems
-         * seamless.  FileSystems could be anything that organizes and grants
-         * access to file data, local filesystems, FTP servers, zip or myriadfs
-         * files, etc.
-         */
-        class FileSystem
-        {
-        public:
-                FileSystem();
-                virtual ~FileSystem();
+    /**
+     * Represents an abstract baseclass for any file organization structure.
+     * If you're looking for acessing a local filesystem, try Bu::Dir.  This
+     * is used to make switching between different types of filesystems
+     * seamless.  FileSystems could be anything that organizes and grants
+     * access to file data, local filesystems, FTP servers, zip or myriadfs
+     * files, etc.
+     */
+    class FileSystem
+    {
+    public:
+        FileSystem();
+        virtual ~FileSystem();
 
-        
-        };
+    
+    };
 };
 
 #endif
diff --git a/src/experimental/httpget.cpp b/src/experimental/httpget.cpp
index 7a8a89a..70c722c 100644
--- a/src/experimental/httpget.cpp
+++ b/src/experimental/httpget.cpp
@@ -8,11 +8,11 @@
 #include "bu/httpget.h"
 
 Bu::HttpGet::HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod ) :
-        uSrc( uSrc ),
-        sMethod( sMethod ),
-        sSrv( uSrc.getHost(), uSrc.getPort() )
+    uSrc( uSrc ),
+    sMethod( sMethod ),
+    sSrv( uSrc.getHost(), uSrc.getPort() )
 {
-        sSrv.write( sMethod + " " + uSrc.getFullPath() + " HTTP/1.1\r\n" );
+    sSrv.write( sMethod + " " + uSrc.getFullPath() + " HTTP/1.1\r\n" );
 }
 
 Bu::HttpGet::~HttpGet()
@@ -25,28 +25,28 @@ void Bu::HttpGet::close()
 
 void Bu::HttpGet::get()
 {
-        for( MimeHash::iterator i = hMimeOut.begin(); i; i++ )
-        {
-                sSrv.write( i.getKey() + ": " + i.getValue() + "\r\n" );
-        }
-        sSrv.write("\r\n", 2 );
+    for( MimeHash::iterator i = hMimeOut.begin(); i; i++ )
+    {
+        sSrv.write( i.getKey() + ": " + i.getValue() + "\r\n" );
+    }
+    sSrv.write("\r\n", 2 );
 
-//      sSrv.read(
+//  sSrv.read(
 }
 
 Bu::size Bu::HttpGet::read( void * /*pBuf*/, Bu::size /*nBytes*/ )
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::HttpGet::write( const void * /*pBuf*/, Bu::size /*nBytes*/ )
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::HttpGet::tell()
 {
-        return 0;
+    return 0;
 }
 
 void Bu::HttpGet::seek( Bu::size )
@@ -63,12 +63,12 @@ void Bu::HttpGet::setPosEnd( Bu::size )
 
 bool Bu::HttpGet::isEos()
 {
-        return false;
+    return false;
 }
 
 bool Bu::HttpGet::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::HttpGet::flush()
@@ -77,32 +77,32 @@ void Bu::HttpGet::flush()
 
 bool Bu::HttpGet::canRead()
 {
-        return true;
+    return true;
 }
 
 bool Bu::HttpGet::canWrite()
 {
-        return false;
+    return false;
 }
 
 bool Bu::HttpGet::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::HttpGet::isWritable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::HttpGet::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::HttpGet::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::HttpGet::setBlocking( bool /*bBlocking*/ )
@@ -111,16 +111,16 @@ void Bu::HttpGet::setBlocking( bool /*bBlocking*/ )
 
 Bu::size Bu::HttpGet::getSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::HttpGet::getBlockSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::String Bu::HttpGet::getLocation() const
 {
-        return uSrc.getUrl();
+    return uSrc.getUrl();
 }
 
diff --git a/src/experimental/httpget.h b/src/experimental/httpget.h
index e8092e5..21e69d6 100644
--- a/src/experimental/httpget.h
+++ b/src/experimental/httpget.h
@@ -16,51 +16,51 @@
 
 namespace Bu
 {
-        class HttpGet : public Bu::Stream
-        {
-        public:
-                HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod="GET" );
-                virtual ~HttpGet();
+    class HttpGet : public Bu::Stream
+    {
+    public:
+        HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod="GET" );
+        virtual ~HttpGet();
 
-                void get();
+        void get();
 
-                // From Bu::Stream
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
+        // From Bu::Stream
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
 
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
 
-                virtual void flush();
+        virtual void flush();
 
-                virtual bool canRead();
-                virtual bool canWrite();
+        virtual bool canRead();
+        virtual bool canWrite();
 
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
 
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-        private:
-                Bu::Url uSrc;
-                Bu::String sMethod;
-                Bu::TcpSocket sSrv;
-                typedef Bu::Hash<Bu::String,Bu::String> MimeHash;
-                MimeHash hMimeIn;
-                MimeHash hMimeOut;
-        };
+    private:
+        Bu::Url uSrc;
+        Bu::String sMethod;
+        Bu::TcpSocket sSrv;
+        typedef Bu::Hash<Bu::String,Bu::String> MimeHash;
+        MimeHash hMimeIn;
+        MimeHash hMimeOut;
+    };
 };
 
 #endif
diff --git a/src/experimental/lexer.cpp b/src/experimental/lexer.cpp
index 48ee017..ae95d09 100644
--- a/src/experimental/lexer.cpp
+++ b/src/experimental/lexer.cpp
@@ -18,23 +18,23 @@ Bu::Lexer::~Lexer()
 }
 
 Bu::Lexer::Token::Token() :
-        iToken( -1 )
+    iToken( -1 )
 {
 }
 
 Bu::Lexer::Token::Token( Bu::Lexer::TokenType iToken ) :
-        iToken( iToken )
+    iToken( iToken )
 {
 }
 
 Bu::String Bu::Lexer::tokenToString( const Bu::Lexer::Token &t )
 {
-        Bu::MemBuf mb;
-        Bu::Formatter f( mb );
-        f << "<" << t.iToken << ">";
-        if( t.vExtra.isSet() )
-                f << " (" << t.vExtra << ")";
+    Bu::MemBuf mb;
+    Bu::Formatter f( mb );
+    f << "<" << t.iToken << ">";
+    if( t.vExtra.isSet() )
+        f << " (" << t.vExtra << ")";
 
-        return mb.getString();
+    return mb.getString();
 }
 
diff --git a/src/experimental/lexer.h b/src/experimental/lexer.h
index 69f4106..273f3cf 100644
--- a/src/experimental/lexer.h
+++ b/src/experimental/lexer.h
@@ -12,47 +12,47 @@
 
 namespace Bu
 {
-        class Stream;
-
-        /**
-         * The base class for creating a lexical analyzer.  This is designed to work
-         * in tandem with the Bu::Parser class, which uses this to tokenize textual
-         * input.  It can be used by just about anything that cares about tokens
-         * more than raw input, though.
-         */
-        class Lexer
-        {
-        public:
-                Lexer();
-                virtual ~Lexer();
-
-                typedef int TokenType;
-
-                class Token
-                {
-                public:
-                        Token();
-                        Token( TokenType iToken );
-
-                        template<class t>
-                        Token( TokenType iToken, const t &v ) :
-                                iToken( iToken )//,
-//                              vExtra( v )
-                        {
-                                vExtra = v;
-                        }
-                        TokenType iToken;
-                        Bu::Variant vExtra;
-                        int iStartCol;
-                        int iStartRow;
-                        int iEndCol;
-                        int iEndRow;
-                };
-
-                virtual Token *nextToken()=0;
-
-                virtual Bu::String tokenToString( const Token &t );
-        };
+    class Stream;
+
+    /**
+     * The base class for creating a lexical analyzer.  This is designed to work
+     * in tandem with the Bu::Parser class, which uses this to tokenize textual
+     * input.  It can be used by just about anything that cares about tokens
+     * more than raw input, though.
+     */
+    class Lexer
+    {
+    public:
+        Lexer();
+        virtual ~Lexer();
+
+        typedef int TokenType;
+
+        class Token
+        {
+        public:
+            Token();
+            Token( TokenType iToken );
+
+            template<class t>
+            Token( TokenType iToken, const t &v ) :
+                iToken( iToken )//,
+//              vExtra( v )
+            {
+                vExtra = v;
+            }
+            TokenType iToken;
+            Bu::Variant vExtra;
+            int iStartCol;
+            int iStartRow;
+            int iEndCol;
+            int iEndRow;
+        };
+
+        virtual Token *nextToken()=0;
+
+        virtual Bu::String tokenToString( const Token &t );
+    };
 };
 
 #endif
diff --git a/src/experimental/parser.cpp b/src/experimental/parser.cpp
index 9f10256..5d0d7eb 100644
--- a/src/experimental/parser.cpp
+++ b/src/experimental/parser.cpp
@@ -21,231 +21,231 @@ Bu::Parser::~Parser()
 
 void Bu::Parser::pushLexer( Lexer *pLex )
 {
-        sLexer.push( pLex );
+    sLexer.push( pLex );
 }
 
 void Bu::Parser::popLexer()
 {
-        delete sLexer.peekPop();
+    delete sLexer.peekPop();
 }
 
 Lexer::Token *Bu::Parser::popToken()
 {
-        return sToken.peekPop();
+    return sToken.peekPop();
 }
 
 void Bu::Parser::pushToken( Lexer::Token *pTok )
 {
-        sToken.push( pTok );
+    sToken.push( pTok );
 }
 
 void Bu::Parser::parse()
 {
-        int iCurNt = iRootNonTerminal;
-        Lexer::Token *ptCur = sLexer.peek()->nextToken();
-        sio << "Token(a): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
-        selectProduction( iCurNt, ptCur );
-        
-        while( !sState.isEmpty() )
-        {
-                switch( (*sState.peek()).eType )
-                {
-                        case State::typeTerminal:
-                                sio << "terminal: " << ptCur->iToken << " == "
-                                        << (*sState.peek()).iIndex << sio.nl;
-                                if( ptCur->iToken == (*sState.peek()).iIndex )
-                                {
-                                        advanceState();
-                                        delete ptCur;
-                                        ptCur = sLexer.peek()->nextToken();
-                                        sio << "Token(b): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
-                                }
-                                else
-                                {
-                                        throw Bu::ExceptionBase("Error parsing code.");
-                                }
-                                break;
-
-                        case State::typeTerminalPush:
-                                sio << "terminalpush: " << ptCur->iToken << " == "
-                                        << (*sState.peek()).iIndex << sio.nl;
-                                if( ptCur->iToken == (*sState.peek()).iIndex )
-                                {
-                                        advanceState();
-                                        sToken.push( ptCur );
-
-                                        ptCur = sLexer.peek()->nextToken();
-                                        sio << "Token(c): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
-                                }
-                                else
-                                {
-                                        throw Bu::ExceptionBase("Error parsing code.");
-                                }
-                                break;
-
-                        case State::typeNonTerminal:
-                                sio << "nonterminal: " << ptCur->iToken << " --> "
-                                        << (*sState.peek()).iIndex << sio.nl;
-                                {
-                                        int iNt = (*sState.peek()).iIndex;
-                                        sio << "Current state: " << *sState.peek() << sio.nl;
-                                        if( !selectProduction( iNt, ptCur ) )
-                                        {
-                                                throw Bu::ExceptionBase("Error parsing code.");
-                                        }
-                                }
-                                break;
-
-                        case State::typeReduction:
-                                sio << "reduction" << sio.nl;
-                                aReduction[(*sState.peek()).iIndex]( *this );
-                                advanceState();
-                                break;
-                }
-        }       
+    int iCurNt = iRootNonTerminal;
+    Lexer::Token *ptCur = sLexer.peek()->nextToken();
+    sio << "Token(a): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
+    selectProduction( iCurNt, ptCur );
+    
+    while( !sState.isEmpty() )
+    {
+        switch( (*sState.peek()).eType )
+        {
+            case State::typeTerminal:
+                sio << "terminal: " << ptCur->iToken << " == "
+                    << (*sState.peek()).iIndex << sio.nl;
+                if( ptCur->iToken == (*sState.peek()).iIndex )
+                {
+                    advanceState();
+                    delete ptCur;
+                    ptCur = sLexer.peek()->nextToken();
+                    sio << "Token(b): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
+                }
+                else
+                {
+                    throw Bu::ExceptionBase("Error parsing code.");
+                }
+                break;
+
+            case State::typeTerminalPush:
+                sio << "terminalpush: " << ptCur->iToken << " == "
+                    << (*sState.peek()).iIndex << sio.nl;
+                if( ptCur->iToken == (*sState.peek()).iIndex )
+                {
+                    advanceState();
+                    sToken.push( ptCur );
+
+                    ptCur = sLexer.peek()->nextToken();
+                    sio << "Token(c): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
+                }
+                else
+                {
+                    throw Bu::ExceptionBase("Error parsing code.");
+                }
+                break;
+
+            case State::typeNonTerminal:
+                sio << "nonterminal: " << ptCur->iToken << " --> "
+                    << (*sState.peek()).iIndex << sio.nl;
+                {
+                    int iNt = (*sState.peek()).iIndex;
+                    sio << "Current state: " << *sState.peek() << sio.nl;
+                    if( !selectProduction( iNt, ptCur ) )
+                    {
+                        throw Bu::ExceptionBase("Error parsing code.");
+                    }
+                }
+                break;
+
+            case State::typeReduction:
+                sio << "reduction" << sio.nl;
+                aReduction[(*sState.peek()).iIndex]( *this );
+                advanceState();
+                break;
+        }
+    }   
 }
 
 bool Bu::Parser::selectProduction( int iNt, Lexer::Token *ptCur )
 {
-        NonTerminal &nt = aNonTerminal[iNt];
-        int j = 0;
-        for( NonTerminal::ProductionList::iterator i = nt.lProduction.begin();
-                 i; i++,j++ )
-        {
-                if( (*i).isEmpty() )
-                        continue;
-                sio << "-->(Attempting production " << iNt << ":" << j << ": "
-                        << (*i).first() << ")" << sio.nl;
-                if( (*i).first().eType == State::typeTerminal ||
-                        (*i).first().eType == State::typeTerminalPush )
-                {
-                        if( (*i).first().iIndex == ptCur->iToken )
-                        {
-                                sState.push( (*i).begin() );
-                                sio.incIndent();
-                                sio << "Pushing production " << j << " from nt " << iNt
-                                        << sio.nl;
-                                return true;
-                        }
-                }
-                else if( (*i).first().eType == State::typeNonTerminal )
-                {
-                        sState.push( (*i).begin() );
-                        sio.incIndent();
-                        sio << "Pushing production " << j << " from nt " << iNt
-                                << " as test." << sio.nl;
-                        if( !selectProduction( (*i).first().iIndex, ptCur ) )
-                        {
-                                sio.decIndent();
-                                sState.pop();
-                                sio << "Production " << j << " from nt " << iNt
-                                        << " didn't work out." << sio.nl;
-                        }
-                        else
-                        {
-                                return true;
-                        }
-                }
-        }
-        if( nt.bCanSkip )
-        {
-                sio << "Nothing matches, skipping non-terminal." << sio.nl;
-                advanceState();
-                return true;
-        }
-        sio << "-->(Found nothing)" << sio.nl;
-        return false;
+    NonTerminal &nt = aNonTerminal[iNt];
+    int j = 0;
+    for( NonTerminal::ProductionList::iterator i = nt.lProduction.begin();
+         i; i++,j++ )
+    {
+        if( (*i).isEmpty() )
+            continue;
+        sio << "-->(Attempting production " << iNt << ":" << j << ": "
+            << (*i).first() << ")" << sio.nl;
+        if( (*i).first().eType == State::typeTerminal ||
+            (*i).first().eType == State::typeTerminalPush )
+        {
+            if( (*i).first().iIndex == ptCur->iToken )
+            {
+                sState.push( (*i).begin() );
+                sio.incIndent();
+                sio << "Pushing production " << j << " from nt " << iNt
+                    << sio.nl;
+                return true;
+            }
+        }
+        else if( (*i).first().eType == State::typeNonTerminal )
+        {
+            sState.push( (*i).begin() );
+            sio.incIndent();
+            sio << "Pushing production " << j << " from nt " << iNt
+                << " as test." << sio.nl;
+            if( !selectProduction( (*i).first().iIndex, ptCur ) )
+            {
+                sio.decIndent();
+                sState.pop();
+                sio << "Production " << j << " from nt " << iNt
+                    << " didn't work out." << sio.nl;
+            }
+            else
+            {
+                return true;
+            }
+        }
+    }
+    if( nt.bCanSkip )
+    {
+        sio << "Nothing matches, skipping non-terminal." << sio.nl;
+        advanceState();
+        return true;
+    }
+    sio << "-->(Found nothing)" << sio.nl;
+    return false;
 }
 
 void Bu::Parser::advanceState()
 {
-        if( sState.isEmpty() )
-                return;
-
-        sState.peek()++;
-        if( !sState.peek() )
-        {
-                sio.decIndent();
-                sState.pop();
-                sio << "State advanced, End of production." << sio.nl;
-                advanceState();
-                return;
-        }
-        sio << "State advanced, now: " << *(sState.peek()) << sio.nl;
+    if( sState.isEmpty() )
+        return;
+
+    sState.peek()++;
+    if( !sState.peek() )
+    {
+        sio.decIndent();
+        sState.pop();
+        sio << "State advanced, End of production." << sio.nl;
+        advanceState();
+        return;
+    }
+    sio << "State advanced, now: " << *(sState.peek()) << sio.nl;
 }
 
 void Bu::Parser::setRootNonTerminal( int iRoot )
 {
-        iRootNonTerminal = iRoot;
+    iRootNonTerminal = iRoot;
 }
 
 void Bu::Parser::setRootNonTerminal( const Bu::String &sRoot )
 {
-        setRootNonTerminal( hNonTerminalName.get( sRoot ) );
+    setRootNonTerminal( hNonTerminalName.get( sRoot ) );
 }
 
 int Bu::Parser::addNonTerminal( const Bu::String &sName, NonTerminal &nt )
 {
-        int iId = aNonTerminal.getSize();
-        aNonTerminal.append( nt );
-        hNonTerminalName.insert( sName, iId );
-        sio << "nt '" << sName << "' = " << iId << sio.nl;
-        return iId;
+    int iId = aNonTerminal.getSize();
+    aNonTerminal.append( nt );
+    hNonTerminalName.insert( sName, iId );
+    sio << "nt '" << sName << "' = " << iId << sio.nl;
+    return iId;
 }
 
 int Bu::Parser::addNonTerminal( const Bu::String &sName )
 {
-        int iId = aNonTerminal.getSize();
-        aNonTerminal.append( NonTerminal() );
-        hNonTerminalName.insert( sName, iId );
-        sio << "nt '" << sName << "' = " << iId << sio.nl;
-        return iId;
+    int iId = aNonTerminal.getSize();
+    aNonTerminal.append( NonTerminal() );
+    hNonTerminalName.insert( sName, iId );
+    sio << "nt '" << sName << "' = " << iId << sio.nl;
+    return iId;
 }
 
 void Bu::Parser::setNonTerminal( const Bu::String &sName, NonTerminal &nt )
 {
-        aNonTerminal[hNonTerminalName.get(sName)] = nt;
+    aNonTerminal[hNonTerminalName.get(sName)] = nt;
 }
 
 int Bu::Parser::getNonTerminalId( const Bu::String &sName )
 {
-        return hNonTerminalName.get( sName );
+    return hNonTerminalName.get( sName );
 }
 
 bool Bu::Parser::hasNonTerminal( const Bu::String &sName )
 {
-        return hNonTerminalName.has( sName );
+    return hNonTerminalName.has( sName );
 }
 
 int Bu::Parser::addReduction( const Bu::String &sName, const Reduction &r )
 {
-        int iId = aReduction.getSize();
-        aReduction.append( r );
-        hReductionName.insert( sName, iId );
-        return iId;
+    int iId = aReduction.getSize();
+    aReduction.append( r );
+    hReductionName.insert( sName, iId );
+    return iId;
 }
 
 int Bu::Parser::addReduction( const Bu::String &sName )
 {
-        int iId = aReduction.getSize();
-        aReduction.append( Reduction() );
-        hReductionName.insert( sName, iId );
-        return iId;
+    int iId = aReduction.getSize();
+    aReduction.append( Reduction() );
+    hReductionName.insert( sName, iId );
+    return iId;
 }
 
 void Bu::Parser::setReduction( const Bu::String &sName, const Reduction &r )
 {
-        aReduction[hReductionName.get(sName)] = r;
+    aReduction[hReductionName.get(sName)] = r;
 }
 
 int Bu::Parser::getReductionId( const Bu::String &sName )
 {
-        return hReductionName.get( sName );
+    return hReductionName.get( sName );
 }
 
 bool Bu::Parser::hasReduction( const Bu::String &sName )
 {
-        return hReductionName.has( sName );
+    return hReductionName.has( sName );
 }
 
 //
@@ -253,8 +253,8 @@ bool Bu::Parser::hasReduction( const Bu::String &sName )
 //
 
 Bu::Parser::State::State( Bu::Parser::State::Type eType, int iIndex ) :
-        eType( eType ),
-        iIndex( iIndex )
+    eType( eType ),
+    iIndex( iIndex )
 {
 }
 
@@ -267,7 +267,7 @@ Bu::Parser::State::~State()
 //
 
 Bu::Parser::NonTerminal::NonTerminal() :
-        bCanSkip( false )
+    bCanSkip( false )
 {
 }
 
@@ -277,35 +277,35 @@ Bu::Parser::NonTerminal::~NonTerminal()
 
 void Bu::Parser::NonTerminal::addProduction( Production p )
 {
-        lProduction.append( p );
+    lProduction.append( p );
 }
 
 void Bu::Parser::NonTerminal::setCanSkip()
 {
-        bCanSkip = true;
+    bCanSkip = true;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, Bu::Parser::State::Type t )
 {
-        switch( t )
-        {
-                case Bu::Parser::State::typeTerminal:
-                        return f << "typeTerminal";
+    switch( t )
+    {
+        case Bu::Parser::State::typeTerminal:
+            return f << "typeTerminal";
 
-                case Bu::Parser::State::typeTerminalPush:
-                        return f << "typeTerminalPush";
+        case Bu::Parser::State::typeTerminalPush:
+            return f << "typeTerminalPush";
 
-                case Bu::Parser::State::typeNonTerminal:
-                        return f << "typeNonTerminal";
+        case Bu::Parser::State::typeNonTerminal:
+            return f << "typeNonTerminal";
 
-                case Bu::Parser::State::typeReduction:
-                        return f << "typeReduction";
-        }
-        return f << "***error***";
+        case Bu::Parser::State::typeReduction:
+            return f << "typeReduction";
+    }
+    return f << "***error***";
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Parser::State &s )
 {
-        return f << "{" << s.eType << ": " << s.iIndex << "}";
+    return f << "{" << s.eType << ": " << s.iIndex << "}";
 }
 
diff --git a/src/experimental/parser.h b/src/experimental/parser.h
index 953202d..50b6afb 100644
--- a/src/experimental/parser.h
+++ b/src/experimental/parser.h
@@ -18,115 +18,115 @@
 
 namespace Bu
 {
-        /**
-         * The base framework for a LR(1) grammar parser.  Provided a proper set of
-         * ParserStates this will prase any input the lexer can provide.
-         */
-        class Parser
-        {
-        public:
-                Parser();
-                virtual ~Parser();
-
-                /**
-                 * When a Lexer is pushed onto the stack it becomes the source for
-                 * future tokens read by the parser until it is popped off the stack.
-                 * The Parser takes ownership of every Lexer pushed onto the stack,
-                 * and will delete it when it is popped off the stack.
-                 */
-                void pushLexer( Lexer *pLex );
-
-                /**
-                 * Pop a lexer off the stack, and delete it.
-                 */
-                void popLexer();
-
-                Lexer::Token *popToken();
-                void pushToken( Lexer::Token *pTok );
-
-                /**
-                 * Execute a parse.
-                 */
-                void parse();
-
-                void setRootNonTerminal( int iRoot );
-                void setRootNonTerminal( const Bu::String &sRoot );
-
-                typedef Bu::Signal1<void, Parser &> Reduction;
-
-                /**
-                 * Represents a possible state, either a terminal or non-terminal symbol
-                 * in a Production.
-                 */
-                class State
-                {
-                public:
-                        enum Type
-                        {
-                                typeTerminal,
-                                typeTerminalPush,
-                                typeNonTerminal,
-                                typeReduction
-                        };
-
-                        State( Type eType, int iIndex );
-                        virtual ~State();
-
-                //private:
-                        Type eType;
-                        int iIndex;
-                };
-
-                typedef Bu::List<State> Production;
-
-                class NonTerminal
-                {
-                public:
-                        NonTerminal();
-                        virtual ~NonTerminal();
-
-                        void addProduction( Production p );
-                        void setCanSkip();
-
-//              private:
-                        typedef Bu::List<Production> ProductionList;
-                        ProductionList lProduction;
-                        bool bCanSkip;
-                };
-
-                int addNonTerminal( const Bu::String &sName, NonTerminal &nt );
-                int addNonTerminal( const Bu::String &sName );
-                void setNonTerminal( const Bu::String &sName, NonTerminal &nt );
-                int getNonTerminalId( const Bu::String &sName );
-                bool hasNonTerminal( const Bu::String &sName );
-
-                int addReduction( const Bu::String &sName, const Reduction &r );
-                int addReduction( const Bu::String &sName );
-                void setReduction( const Bu::String &sName, const Reduction &r );
-                int getReductionId( const Bu::String &sName );
-                bool hasReduction( const Bu::String &sName );
-
-        private:
-                bool selectProduction( int iNt, Lexer::Token *ptCur );
-                void advanceState();
-
-        private:
-                typedef Bu::List<Lexer *> LexerStack;
-                typedef Bu::List<Lexer::Token *> TokenStack;
-                typedef Bu::List<Production::const_iterator> StateStack;
-                typedef Bu::Array<Reduction> ReductionArray;
-                typedef Bu::Hash<Bu::String,int> NameIndexHash;
-                typedef Bu::Array<NonTerminal> NonTerminalArray;
-
-                LexerStack sLexer;
-                TokenStack sToken;
-                StateStack sState;
-                ReductionArray aReduction;
-                NameIndexHash hReductionName;
-                NonTerminalArray aNonTerminal;
-                NameIndexHash hNonTerminalName;
-                int iRootNonTerminal;
-        };
+    /**
+     * The base framework for a LR(1) grammar parser.  Provided a proper set of
+     * ParserStates this will prase any input the lexer can provide.
+     */
+    class Parser
+    {
+    public:
+        Parser();
+        virtual ~Parser();
+
+        /**
+         * When a Lexer is pushed onto the stack it becomes the source for
+         * future tokens read by the parser until it is popped off the stack.
+         * The Parser takes ownership of every Lexer pushed onto the stack,
+         * and will delete it when it is popped off the stack.
+         */
+        void pushLexer( Lexer *pLex );
+
+        /**
+         * Pop a lexer off the stack, and delete it.
+         */
+        void popLexer();
+
+        Lexer::Token *popToken();
+        void pushToken( Lexer::Token *pTok );
+
+        /**
+         * Execute a parse.
+         */
+        void parse();
+
+        void setRootNonTerminal( int iRoot );
+        void setRootNonTerminal( const Bu::String &sRoot );
+
+        typedef Bu::Signal1<void, Parser &> Reduction;
+
+        /**
+         * Represents a possible state, either a terminal or non-terminal symbol
+         * in a Production.
+         */
+        class State
+        {
+        public:
+            enum Type
+            {
+                typeTerminal,
+                typeTerminalPush,
+                typeNonTerminal,
+                typeReduction
+            };
+
+            State( Type eType, int iIndex );
+            virtual ~State();
+
+        //private:
+            Type eType;
+            int iIndex;
+        };
+
+        typedef Bu::List<State> Production;
+
+        class NonTerminal
+        {
+        public:
+            NonTerminal();
+            virtual ~NonTerminal();
+
+            void addProduction( Production p );
+            void setCanSkip();
+
+//      private:
+            typedef Bu::List<Production> ProductionList;
+            ProductionList lProduction;
+            bool bCanSkip;
+        };
+
+        int addNonTerminal( const Bu::String &sName, NonTerminal &nt );
+        int addNonTerminal( const Bu::String &sName );
+        void setNonTerminal( const Bu::String &sName, NonTerminal &nt );
+        int getNonTerminalId( const Bu::String &sName );
+        bool hasNonTerminal( const Bu::String &sName );
+
+        int addReduction( const Bu::String &sName, const Reduction &r );
+        int addReduction( const Bu::String &sName );
+        void setReduction( const Bu::String &sName, const Reduction &r );
+        int getReductionId( const Bu::String &sName );
+        bool hasReduction( const Bu::String &sName );
+
+    private:
+        bool selectProduction( int iNt, Lexer::Token *ptCur );
+        void advanceState();
+
+    private:
+        typedef Bu::List<Lexer *> LexerStack;
+        typedef Bu::List<Lexer::Token *> TokenStack;
+        typedef Bu::List<Production::const_iterator> StateStack;
+        typedef Bu::Array<Reduction> ReductionArray;
+        typedef Bu::Hash<Bu::String,int> NameIndexHash;
+        typedef Bu::Array<NonTerminal> NonTerminalArray;
+
+        LexerStack sLexer;
+        TokenStack sToken;
+        StateStack sState;
+        ReductionArray aReduction;
+        NameIndexHash hReductionName;
+        NonTerminalArray aNonTerminal;
+        NameIndexHash hNonTerminalName;
+        int iRootNonTerminal;
+    };
 Bu::Formatter &operator<<( Bu::Formatter &f, Bu::Parser::State::Type t );
 Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::Parser::State &s );
 };
diff --git a/src/experimental/regex.cpp b/src/experimental/regex.cpp
index de24935..dbe0e85 100644
--- a/src/experimental/regex.cpp
+++ b/src/experimental/regex.cpp
@@ -13,83 +13,83 @@
 #define aSubStr ((regmatch_t *)paSubStr)
 
 Bu::RegEx::RegEx() :
-        pRegEx( NULL ),
-        bCompiled( false ),
-        paSubStr( NULL )
+    pRegEx( NULL ),
+    bCompiled( false ),
+    paSubStr( NULL )
 {
 }
 
 Bu::RegEx::RegEx( const Bu::String &sSrc ) :
-        pRegEx( NULL ),
-        bCompiled( false ),
-        paSubStr( NULL )
+    pRegEx( NULL ),
+    bCompiled( false ),
+    paSubStr( NULL )
 {
-        compile( sSrc );
+    compile( sSrc );
 }
 
 Bu::RegEx::~RegEx()
 {
-        if( bCompiled )
-        {
-                regfree( re );
-                delete re;
-                delete[] aSubStr;
-        }
+    if( bCompiled )
+    {
+        regfree( re );
+        delete re;
+        delete[] aSubStr;
+    }
 }
 
 void Bu::RegEx::compile( const Bu::String &sSrc )
 {
-        if( bCompiled )
-        {
-                regfree( re );
-                delete re;
-                delete[] aSubStr;
-                bCompiled = false;
-        }
-        pRegEx = (void *)(new regex_t);
+    if( bCompiled )
+    {
+        regfree( re );
+        delete re;
+        delete[] aSubStr;
+        bCompiled = false;
+    }
+    pRegEx = (void *)(new regex_t);
 
-        int nErr = regcomp( re, sSrc.getStr(), REG_EXTENDED|REG_NEWLINE );
-        if( nErr )
-        {
-                size_t length = regerror( nErr, re, NULL, 0 );
-                char *buffer = new char[length];
-                (void) regerror( nErr, re, buffer, length );
-                Bu::String s( buffer );
-                delete[] buffer;
-                throw "???"; // BuildException( s.getStr() );
-        }
-        bCompiled = true;
-        this->sSrc = sSrc;
+    int nErr = regcomp( re, sSrc.getStr(), REG_EXTENDED|REG_NEWLINE );
+    if( nErr )
+    {
+        size_t length = regerror( nErr, re, NULL, 0 );
+        char *buffer = new char[length];
+        (void) regerror( nErr, re, buffer, length );
+        Bu::String s( buffer );
+        delete[] buffer;
+        throw "???"; // BuildException( s.getStr() );
+    }
+    bCompiled = true;
+    this->sSrc = sSrc;
 
-        nSubStr = re->re_nsub+1;
-        paSubStr = (void *)(new regmatch_t[nSubStr]);
+    nSubStr = re->re_nsub+1;
+    paSubStr = (void *)(new regmatch_t[nSubStr]);
 }
 
 int Bu::RegEx::getNumSubStrings()
 {
-        return nSubStr;
+    return nSubStr;
 }
 
 bool Bu::RegEx::execute( const Bu::String &sSrc )
 {
-        sTest = sSrc;
-        if( regexec( re, sSrc.getStr(), nSubStr, aSubStr, 0 ) )
-                return false;
-        return true;
+    sTest = sSrc;
+    if( regexec( re, sSrc.getStr(), nSubStr, aSubStr, 0 ) )
+        return false;
+    return true;
 }
 
 void Bu::RegEx::getSubStringRange( int nIndex, int &iStart, int &iEnd )
 {
-        iStart = aSubStr[nIndex].rm_so;
-        iEnd = aSubStr[nIndex].rm_eo;
+    iStart = aSubStr[nIndex].rm_so;
+    iEnd = aSubStr[nIndex].rm_eo;
 }
 
 Bu::String Bu::RegEx::getSubString( int nIndex )
 {
-//      regmatch_t *Subs = aSubStr;
-        return Bu::String(
-                sTest.getStr()+aSubStr[nIndex].rm_so,
-                aSubStr[nIndex].rm_eo - aSubStr[nIndex].rm_so
-                );
+//  regmatch_t *Subs = aSubStr;
+    return Bu::String(
+        sTest.getStr()+aSubStr[nIndex].rm_so,
+        aSubStr[nIndex].rm_eo - aSubStr[nIndex].rm_so
+        );
 }
 
diff --git a/src/experimental/regex.h b/src/experimental/regex.h
index c83ebe8..e723450 100644
--- a/src/experimental/regex.h
+++ b/src/experimental/regex.h
@@ -14,31 +14,31 @@
 
 namespace Bu
 {
-        class RegEx
-        {
-        public:
-                RegEx();
-                RegEx( const Bu::String &sSrc );
-                virtual ~RegEx();
+    class RegEx
+    {
+    public:
+        RegEx();
+        RegEx( const Bu::String &sSrc );
+        virtual ~RegEx();
 
-                void compile( const Bu::String &sSrc );
-                int getNumSubStrings();
-                bool execute( const Bu::String &sSrc );
-                void getSubStringRange( int nIndex, int &iStart, int &iEnd );
-                Bu::String getSubString( int nIndex );
-                const Bu::String &getSource()
-                {
-                        return sSrc;
-                }
+        void compile( const Bu::String &sSrc );
+        int getNumSubStrings();
+        bool execute( const Bu::String &sSrc );
+        void getSubStringRange( int nIndex, int &iStart, int &iEnd );
+        Bu::String getSubString( int nIndex );
+        const Bu::String &getSource()
+        {
+            return sSrc;
+        }
 
-        private:
-                Bu::String sSrc;
-                Bu::String sTest;
-                void *pRegEx;
-                bool bCompiled;
-                int nSubStr;
-                void *paSubStr;
-        };
+    private:
+        Bu::String sSrc;
+        Bu::String sTest;
+        void *pRegEx;
+        bool bCompiled;
+        int nSubStr;
+        void *paSubStr;
+    };
 };
 
 #endif
diff --git a/src/experimental/regexengine.h b/src/experimental/regexengine.h
index ec181c1..133d418 100644
--- a/src/experimental/regexengine.h
+++ b/src/experimental/regexengine.h
@@ -7,136 +7,136 @@
 
 namespace Bu
 {
-        template<typename chr> class RegExEngine;
-
-        template<typename chr>
-        class RegExEngineCore
-        {
-        friend class RegExEngine<chr>;
-        friend class SharedCore<RegExEngine<chr>, RegExEngineCore<chr> >;
-        private:
-                RegExEngineCore()
-                {
-                }
-
-                virtual ~RegExEngineCore()
-                {
-                }
-
-                class Range
-                {
-                public:
-                        Range( chr cLower, chr cUpper, int iTrgState ) :
-                                cLower( cLower ), cUpper( cUpper ), iTrgState( iTrgState )
-                        {
-                        }
-                
-                        chr cLower;
-                        chr cUpper;
-                        int iTrgState;
-                };
-
-                class State
-                {
-                public:
-                        Bu::Array<Range> aRange;
-                };
-
-                int addState()
-                {
-                        aState.append( State() );
-                        return aState.getSize()-1;
-                }
-
-                void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState )
-                {
-                        aState[iState].aRange.append( Range( cLower, cUpper, iTrgState ) );
-                }
-
-                template<typename str>
-                bool match( const str &sIn, int &iSize, int &iCompletion )
-                {
-                        bool bMatch;
-                        int iState = 0;
-                        iSize = 0;
-                        for( typename str::const_iterator i = sIn.begin(); i; i++ )
-                        {
-                                Bu::sio << "Finding char " << *i << " in state " << iState
-                                        << ":" << Bu::sio.nl;
-                                bMatch = false;
-                                for( typename Bu::Array<Range>::iterator j =
-                                         aState[iState].aRange.begin(); j; j++ )
-                                {
-                                        Bu::sio << "    Testing range " << (*j).cLower << " - " << (*j).cUpper << Bu::sio.nl;
-                                        if( *i >= (*j).cLower && *i <= (*j).cUpper )
-                                        {
-                                                iState = (*j).iTrgState;
-                                                bMatch = true;
-                                                iSize++;
-                                                if( iState < 0 )
-                                                {
-                                                        iCompletion = iState;
-                                                        return true;
-                                                }
-                                        }
-                                }
-                                if( bMatch == false )
-                                {
-                                        return false;
-                                }
-                        }
-
-                        iCompletion = 0;
-                        return true;
-                }
-
-                typedef Bu::Array<State> StateArray;
-                StateArray aState;
-        };
-
-        template<typename chr>
-        class RegExEngine : public SharedCore<RegExEngine<chr>,
-                                                RegExEngineCore<chr> >
-        {
-        private:
-                typedef class RegExEngine<chr> MyType;
-                typedef class RegExEngineCore<chr> Core;
-                typedef class Core::Range Range;
-                typedef class Core::State State;
-        
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_resetCore;
-                using SharedCore<MyType, Core>::_allocateCore;
-
-        public:
-                RegExEngine()
-                {
-                }
-
-                virtual ~RegExEngine()
-                {
-                }
-
-                int addState()
-                {
-                        return core->addState();
-                }
-
-                void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState )
-                {
-                        core->addCompletion( iState, cLower, cUpper, iTrgState );
-                }
-
-                template<typename str>
-                bool match( const str &sIn, int &iSize, int &iCompletion )
-                {
-                        return core->match( sIn, iSize, iCompletion );
-                }
-
-        private:
-        };
+    template<typename chr> class RegExEngine;
+
+    template<typename chr>
+    class RegExEngineCore
+    {
+    friend class RegExEngine<chr>;
+    friend class SharedCore<RegExEngine<chr>, RegExEngineCore<chr> >;
+    private:
+        RegExEngineCore()
+        {
+        }
+
+        virtual ~RegExEngineCore()
+        {
+        }
+
+        class Range
+        {
+        public:
+            Range( chr cLower, chr cUpper, int iTrgState ) :
+                cLower( cLower ), cUpper( cUpper ), iTrgState( iTrgState )
+            {
+            }
+        
+            chr cLower;
+            chr cUpper;
+            int iTrgState;
+        };
+
+        class State
+        {
+        public:
+            Bu::Array<Range> aRange;
+        };
+
+        int addState()
+        {
+            aState.append( State() );
+            return aState.getSize()-1;
+        }
+
+        void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState )
+        {
+            aState[iState].aRange.append( Range( cLower, cUpper, iTrgState ) );
+        }
+
+        template<typename str>
+        bool match( const str &sIn, int &iSize, int &iCompletion )
+        {
+            bool bMatch;
+            int iState = 0;
+            iSize = 0;
+            for( typename str::const_iterator i = sIn.begin(); i; i++ )
+            {
+                Bu::sio << "Finding char " << *i << " in state " << iState
+                    << ":" << Bu::sio.nl;
+                bMatch = false;
+                for( typename Bu::Array<Range>::iterator j =
+                     aState[iState].aRange.begin(); j; j++ )
+                {
+                    Bu::sio << "    Testing range " << (*j).cLower << " - " << (*j).cUpper << Bu::sio.nl;
+                    if( *i >= (*j).cLower && *i <= (*j).cUpper )
+                    {
+                        iState = (*j).iTrgState;
+                        bMatch = true;
+                        iSize++;
+                        if( iState < 0 )
+                        {
+                            iCompletion = iState;
+                            return true;
+                        }
+                    }
+                }
+                if( bMatch == false )
+                {
+                    return false;
+                }
+            }
+
+            iCompletion = 0;
+            return true;
+        }
+
+        typedef Bu::Array<State> StateArray;
+        StateArray aState;
+    };
+
+    template<typename chr>
+    class RegExEngine : public SharedCore<RegExEngine<chr>,
+                        RegExEngineCore<chr> >
+    {
+    private:
+        typedef class RegExEngine<chr> MyType;
+        typedef class RegExEngineCore<chr> Core;
+        typedef class Core::Range Range;
+        typedef class Core::State State;
+    
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_resetCore;
+        using SharedCore<MyType, Core>::_allocateCore;
+
+    public:
+        RegExEngine()
+        {
+        }
+
+        virtual ~RegExEngine()
+        {
+        }
+
+        int addState()
+        {
+            return core->addState();
+        }
+
+        void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState )
+        {
+            core->addCompletion( iState, cLower, cUpper, iTrgState );
+        }
+
+        template<typename str>
+        bool match( const str &sIn, int &iSize, int &iCompletion )
+        {
+            return core->match( sIn, iSize, iCompletion );
+        }
+
+    private:
+    };
 };
 
 #endif
diff --git a/src/experimental/xmlreader.cpp b/src/experimental/xmlreader.cpp
index f11ac04..82f4684 100644
--- a/src/experimental/xmlreader.cpp
+++ b/src/experimental/xmlreader.cpp
@@ -11,13 +11,13 @@
 namespace Bu { subExceptionDef( XmlException ) }
 
 Bu::XmlReader::XmlReader( Stream &rInput ) :
-        rInput( rInput ),
-        iCurToken( 0 ),
-        iNextToken( 0 ),
-        bIgnoreWS( true )
+    rInput( rInput ),
+    iCurToken( 0 ),
+    iNextToken( 0 ),
+    bIgnoreWS( true )
 {
-        nextToken();
-        stDocument();
+    nextToken();
+    stDocument();
 }
 
 Bu::XmlReader::~XmlReader()
@@ -26,148 +26,148 @@ Bu::XmlReader::~XmlReader()
 
 void Bu::XmlReader::fillBuffer()
 {
-        if( rInput.isEos() )
-                return;
-        char buf[1024];
-        int iSize = rInput.read( buf, 1024 );
-        sBuf.append( buf, iSize );
+    if( rInput.isEos() )
+        return;
+    char buf[1024];
+    int iSize = rInput.read( buf, 1024 );
+    sBuf.append( buf, iSize );
 }
 
 void Bu::XmlReader::cleanupBuffer( int iUsed )
 {
-        for( int j = 0; j < iUsed; j++ )
-        {
-                if( sBuf[j] == '\n' )
-                {
-                        spNextToken.iLine++;
-                        spNextToken.iChar = 1;
-                }
-                else
-                {
-                        spNextToken.iChar++;
-                }
-        }
-
-        printf("--Deleting %d bytes from front of buffer.\n", iUsed );
-        sBuf.trimFront( iUsed );
+    for( int j = 0; j < iUsed; j++ )
+    {
+        if( sBuf[j] == '\n' )
+        {
+            spNextToken.iLine++;
+            spNextToken.iChar = 1;
+        }
+        else
+        {
+            spNextToken.iChar++;
+        }
+    }
+
+    printf("--Deleting %d bytes from front of buffer.\n", iUsed );
+    sBuf.trimFront( iUsed );
 }
 
 int Bu::XmlReader::nextToken()
 {
-        fillBuffer();
-
-        int iUsed = 1;
-
-        iCurToken = iNextToken;
-        spCurToken = spNextToken;
-
-        switch( sBuf[0] )
-        {
-                case '<':
-                        if( !strncmp( sBuf.getStr(), "<?xml", 5 ) )
-                        {
-                                iNextToken = tokXmlDeclHead;
-                                iUsed = 5;
-                        }
-                        else
-                        {
-                                iNextToken = '<';
-                        }
-                        break;
-
-                case '?':
-                        if( sBuf[1] == '>' )
-                        {
-                                iNextToken = tokXmlDeclEnd;
-                                iUsed = 2;
-                        }
-                        else
-                        {
-                                iNextToken = '?';
-                        }
-                        break;
-
-                case ' ':
-                case '\t':
-                case '\n':
-                case '\r':
-                        for( int j = 1;; j++ )
-                        {
-                                if( j == sBuf.getSize() )
-                                {
-                                        if( rInput.isEos() )
-                                                error("Reached end of input while waiting for whitespace to end.");
-
-                                        fillBuffer();
-                                }
-                                if( sBuf[j] == ' ' || sBuf[j] == '\t' ||
-                                        sBuf[j] == '\n' || sBuf[j] == '\r' )
-                                        iUsed++;
-                                else
-                                        break;
-                        }
-                        sStr.clear();
-                        sStr.append( sBuf, iUsed );
-                        iNextToken = tokWS;
-                        break;
-
-                case '=':
-                        iNextToken = sBuf[0];
-                        break;
-
-                default:
-                        if( (sBuf[0] >= 'a' && sBuf[0] <= 'z') ||
-                                (sBuf[0] >= 'A' && sBuf[0] <= 'Z') )
-                        {
-                                for( int j = 1;; j++ )
-                                {
-                                        if( j == sBuf.getSize() )
-                                        {
-                                                if( rInput.isEos() )
-                                                        error("Reached end of input while waiting for a string to end.");
-
-                                                fillBuffer();
-                                        }
-                                        if( (sBuf[j] >= 'a' && sBuf[j] <= 'z') ||
-                                                (sBuf[j] >= 'A' && sBuf[j] <= 'Z') )
-                                                iUsed++;
-                                        else
-                                                break;
-                                }
-                                sStr.clear();
-                                sStr.append( sBuf, iUsed );
-                                iNextToken = tokIdent;
-                        }
-        }
-
-        cleanupBuffer( iUsed );
-
-        return iCurToken;
+    fillBuffer();
+
+    int iUsed = 1;
+
+    iCurToken = iNextToken;
+    spCurToken = spNextToken;
+
+    switch( sBuf[0] )
+    {
+        case '<':
+            if( !strncmp( sBuf.getStr(), "<?xml", 5 ) )
+            {
+                iNextToken = tokXmlDeclHead;
+                iUsed = 5;
+            }
+            else
+            {
+                iNextToken = '<';
+            }
+            break;
+
+        case '?':
+            if( sBuf[1] == '>' )
+            {
+                iNextToken = tokXmlDeclEnd;
+                iUsed = 2;
+            }
+            else
+            {
+                iNextToken = '?';
+            }
+            break;
+
+        case ' ':
+        case '\t':
+        case '\n':
+        case '\r':
+            for( int j = 1;; j++ )
+            {
+                if( j == sBuf.getSize() )
+                {
+                    if( rInput.isEos() )
+                        error("Reached end of input while waiting for whitespace to end.");
+
+                    fillBuffer();
+                }
+                if( sBuf[j] == ' ' || sBuf[j] == '\t' ||
+                    sBuf[j] == '\n' || sBuf[j] == '\r' )
+                    iUsed++;
+                else
+                    break;
+            }
+            sStr.clear();
+            sStr.append( sBuf, iUsed );
+            iNextToken = tokWS;
+            break;
+
+        case '=':
+            iNextToken = sBuf[0];
+            break;
+
+        default:
+            if( (sBuf[0] >= 'a' && sBuf[0] <= 'z') ||
+                (sBuf[0] >= 'A' && sBuf[0] <= 'Z') )
+            {
+                for( int j = 1;; j++ )
+                {
+                    if( j == sBuf.getSize() )
+                    {
+                        if( rInput.isEos() )
+                            error("Reached end of input while waiting for a string to end.");
+
+                        fillBuffer();
+                    }
+                    if( (sBuf[j] >= 'a' && sBuf[j] <= 'z') ||
+                        (sBuf[j] >= 'A' && sBuf[j] <= 'Z') )
+                        iUsed++;
+                    else
+                        break;
+                }
+                sStr.clear();
+                sStr.append( sBuf, iUsed );
+                iNextToken = tokIdent;
+            }
+    }
+
+    cleanupBuffer( iUsed );
+
+    return iCurToken;
 }
 
 void Bu::XmlReader::error( const char *sMessage )
 {
-        throw Bu::XmlException("%d:%d:  %s",
-                spCurToken.iLine, spCurToken.iChar, sMessage );
+    throw Bu::XmlException("%d:%d:  %s",
+        spCurToken.iLine, spCurToken.iChar, sMessage );
 }
 
 void Bu::XmlReader::stDocument()
 {
-        stProlog();
+    stProlog();
 }
 
 void Bu::XmlReader::stProlog()
 {
-        stXmlDecl();
+    stXmlDecl();
 }
 
 void Bu::XmlReader::stXmlDecl()
 {
-        if( nextToken() != tokXmlDeclHead )
-                error("You must begin your xml file with a declaration: <?xml ... ?>");
-        if( nextToken() != tokIdent )
-                error("A version comes first!");
-        if( sStr != "version" )
-                error("No, a version!");
+    if( nextToken() != tokXmlDeclHead )
+        error("You must begin your xml file with a declaration: <?xml ... ?>");
+    if( nextToken() != tokIdent )
+        error("A version comes first!");
+    if( sStr != "version" )
+        error("No, a version!");
 }
 
diff --git a/src/experimental/xmlreader.h b/src/experimental/xmlreader.h
index d4bad1e..9615cfb 100644
--- a/src/experimental/xmlreader.h
+++ b/src/experimental/xmlreader.h
@@ -13,52 +13,52 @@
 
 namespace Bu
 {
-        class Stream;
+    class Stream;
 
-        subExceptionDecl( XmlException );
+    subExceptionDecl( XmlException );
 
-        class XmlReader
-        {
-        public:
-                XmlReader( Stream &rInput );
-                virtual ~XmlReader();
+    class XmlReader
+    {
+    public:
+        XmlReader( Stream &rInput );
+        virtual ~XmlReader();
 
-        private:
-                Stream &rInput;
-                int iCurToken;
-                int iNextToken;
-                Bu::String sBuf;
-                Bu::String sStr;
-                bool bIgnoreWS;
-                typedef struct StreamPos
-                {
-                        StreamPos() : iLine( 1 ), iChar( 1 ) { }
-                        int iLine;
-                        int iChar;
-                } StreamPos;
-                StreamPos spCurToken;
-                StreamPos spNextToken;
+    private:
+        Stream &rInput;
+        int iCurToken;
+        int iNextToken;
+        Bu::String sBuf;
+        Bu::String sStr;
+        bool bIgnoreWS;
+        typedef struct StreamPos
+        {
+            StreamPos() : iLine( 1 ), iChar( 1 ) { }
+            int iLine;
+            int iChar;
+        } StreamPos;
+        StreamPos spCurToken;
+        StreamPos spNextToken;
 
 
-                enum
-                {
-                        tokXmlDeclHead  =       0x100,
-                        tokXmlDeclEnd,
-                        tokWS,
-                        tokIdent,
-                        tokString
-                };
+        enum
+        {
+            tokXmlDeclHead  =   0x100,
+            tokXmlDeclEnd,
+            tokWS,
+            tokIdent,
+            tokString
+        };
 
-                void fillBuffer();
-                void cleanupBuffer( int iUsed );
-                int nextToken();
+        void fillBuffer();
+        void cleanupBuffer( int iUsed );
+        int nextToken();
 
-                void stDocument();
-                void stProlog();
-                void stXmlDecl();
+        void stDocument();
+        void stProlog();
+        void stXmlDecl();
 
-                void error( const char *sMessage );
-        };
+        void error( const char *sMessage );
+    };
 };
 
 #endif
diff --git a/src/extra/myriadfs.cpp b/src/extra/myriadfs.cpp
index 867a595..6dc3ff4 100644
--- a/src/extra/myriadfs.cpp
+++ b/src/extra/myriadfs.cpp
@@ -28,307 +28,307 @@ int64_t iNextFileId = 0;
 #define TRACE
 
 extern "C" {
-        static int myriadfs_getattr( const char *sPath, struct stat *stbuf )
-        {
+    static int myriadfs_getattr( const char *sPath, struct stat *stbuf )
+    {
 #ifdef TRACE
-                printf("myriadfs_getattr(\"%s\", ... );\n", sPath );
+        printf("myriadfs_getattr(\"%s\", ... );\n", sPath );
 #endif
-                try
-                {
-                        Bu::MyriadFs::Stat st;
-                        pFs->stat( sPath, st );
-                        stbuf->st_ino = st.iNode;
-                        stbuf->st_mode = st.uPerms;
-                        stbuf->st_nlink = st.iLinks;
-                        stbuf->st_uid = st.iUser;
-                        stbuf->st_gid = st.iGroup;
-                        stbuf->st_rdev = Bu::MyriadFs::devToSys( st.uDev );
-                        stbuf->st_size = st.iSize;
-                        stbuf->st_blocks = 8;
-                        stbuf->st_atime = st.iATime;
-                        stbuf->st_mtime = st.iMTime;
-                        stbuf->st_ctime = st.iCTime;
-                        return 0;
-                }
-                catch(...)
-                {
-                        return -ENOENT;
-                }
-        }
+        try
+        {
+            Bu::MyriadFs::Stat st;
+            pFs->stat( sPath, st );
+            stbuf->st_ino = st.iNode;
+            stbuf->st_mode = st.uPerms;
+            stbuf->st_nlink = st.iLinks;
+            stbuf->st_uid = st.iUser;
+            stbuf->st_gid = st.iGroup;
+            stbuf->st_rdev = Bu::MyriadFs::devToSys( st.uDev );
+            stbuf->st_size = st.iSize;
+            stbuf->st_blocks = 8;
+            stbuf->st_atime = st.iATime;
+            stbuf->st_mtime = st.iMTime;
+            stbuf->st_ctime = st.iCTime;
+            return 0;
+        }
+        catch(...)
+        {
+            return -ENOENT;
+        }
+    }
 
-        static int myriadfs_readdir( const char *sPath, void *buf,
-                        fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi )
-        {
+    static int myriadfs_readdir( const char *sPath, void *buf,
+            fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi )
+    {
 #ifdef TRACE
-                printf("myriadfs_readdir(\"%s\", ... );\n", sPath );
+        printf("myriadfs_readdir(\"%s\", ... );\n", sPath );
 #endif
-                Bu::MyriadFs::Dir lDir = pFs->readDir( sPath );
-                filler( buf, ".", NULL, 0 );
-                filler( buf, "..", NULL, 0 );
-                for( Bu::MyriadFs::Dir::iterator i = lDir.begin(); i; i++ )
-                {
-                        filler( buf, (*i).sName.getStr(), NULL, 0 );
-                }
+        Bu::MyriadFs::Dir lDir = pFs->readDir( sPath );
+        filler( buf, ".", NULL, 0 );
+        filler( buf, "..", NULL, 0 );
+        for( Bu::MyriadFs::Dir::iterator i = lDir.begin(); i; i++ )
+        {
+            filler( buf, (*i).sName.getStr(), NULL, 0 );
+        }
 
-                return 0;
-        }
+        return 0;
+    }
 
-        static int myriadfs_mkdir( const char *sPath, mode_t uMode )
-        {
+    static int myriadfs_mkdir( const char *sPath, mode_t uMode )
+    {
 #ifdef TRACE
-                printf("myriadfs_mkdir(\"%s\", 0%o );\n", sPath, uMode );
+        printf("myriadfs_mkdir(\"%s\", 0%o );\n", sPath, uMode );
 #endif
-                pFs->mkDir( sPath, uMode );
-                return 0;
-        }
+        pFs->mkDir( sPath, uMode );
+        return 0;
+    }
 
-        static int myriadfs_open( const char *sPath, struct fuse_file_info *fi )
-        {
+    static int myriadfs_open( const char *sPath, struct fuse_file_info *fi )
+    {
 #ifdef TRACE
-                printf("myriadfs_open(\"%s\", ... );\n", sPath );
+        printf("myriadfs_open(\"%s\", ... );\n", sPath );
 #endif
-                try
-                {
-                        Bu::MyriadStream ms = pFs->open( sPath, 0 );
-                        fi->fh = iNextFileId;
-                        hOpenFiles.insert( iNextFileId++, ms );
-//                      printf("File '%s' opened, %d files open now.\n",
-//                              sPath, hOpenFiles.getSize() );
-                        return 0;
-                }
-                catch(...)
-                {
-                        return -EACCES;
-                }
-        }
+        try
+        {
+            Bu::MyriadStream ms = pFs->open( sPath, 0 );
+            fi->fh = iNextFileId;
+            hOpenFiles.insert( iNextFileId++, ms );
+//          printf("File '%s' opened, %d files open now.\n",
+//              sPath, hOpenFiles.getSize() );
+            return 0;
+        }
+        catch(...)
+        {
+            return -EACCES;
+        }
+    }
 
-        static int myriadfs_read( const char *sPath, char *buf, size_t iSize,
-                        off_t iOffset, struct fuse_file_info *fi )
-        {
+    static int myriadfs_read( const char *sPath, char *buf, size_t iSize,
+            off_t iOffset, struct fuse_file_info *fi )
+    {
 #ifdef TRACE
-                printf("myriadfs_read(\"%s\", ..., %d, %d, ... );\n", sPath, iSize,
-                                iOffset );
+        printf("myriadfs_read(\"%s\", ..., %d, %d, ... );\n", sPath, iSize,
+                iOffset );
 #endif
-                Bu::MyriadStream &ms = hOpenFiles.get( fi->fh );
-                ms.setPos( iOffset );
-                return ms.read( buf, iSize );
-        }
+        Bu::MyriadStream &ms = hOpenFiles.get( fi->fh );
+        ms.setPos( iOffset );
+        return ms.read( buf, iSize );
+    }
 
-        static int myriadfs_write( const char *sPath, const char *buf, size_t iSize,
-                        off_t iOffset, struct fuse_file_info *fi )
-        {
+    static int myriadfs_write( const char *sPath, const char *buf, size_t iSize,
+            off_t iOffset, struct fuse_file_info *fi )
+    {
 #ifdef TRACE
-                printf("myriadfs_write(\"%s\", ..., %d, %d, ... );\n", sPath, iSize,
-                                iOffset );
+        printf("myriadfs_write(\"%s\", ..., %d, %d, ... );\n", sPath, iSize,
+                iOffset );
 #endif
-                Bu::MyriadStream &ms = hOpenFiles.get( fi->fh );
-                ms.setPos( iOffset );
-                return ms.write( buf, iSize );
-        }
+        Bu::MyriadStream &ms = hOpenFiles.get( fi->fh );
+        ms.setPos( iOffset );
+        return ms.write( buf, iSize );
+    }
 
-        static int myriadfs_create( const char *sPath, mode_t uPerms,
-                        struct fuse_file_info *fi )
-        {
+    static int myriadfs_create( const char *sPath, mode_t uPerms,
+            struct fuse_file_info *fi )
+    {
 #ifdef TRACE
-                printf("myriadfs_create(\"%s\", 0%o, ... );\n", sPath, uPerms );
+        printf("myriadfs_create(\"%s\", 0%o, ... );\n", sPath, uPerms );
 #endif
-                try
-                {
-                        Bu::MyriadStream ms = pFs->open( sPath, 0, uPerms );
-                        fi->fh = iNextFileId;
-                        hOpenFiles.insert( iNextFileId++, ms );
-//                      printf("File '%s' created, %d files open now.\n",
-//                              sPath, hOpenFiles.getSize() );
-                        return 0;
-                }
-                catch(...)
-                {
-                        return -EACCES;
-                }
-        }
-        
-        static int myriadfs_mknod( const char *sPath, mode_t uPerms, dev_t Dev )
-        {
+        try
+        {
+            Bu::MyriadStream ms = pFs->open( sPath, 0, uPerms );
+            fi->fh = iNextFileId;
+            hOpenFiles.insert( iNextFileId++, ms );
+//          printf("File '%s' created, %d files open now.\n",
+//              sPath, hOpenFiles.getSize() );
+            return 0;
+        }
+        catch(...)
+        {
+            return -EACCES;
+        }
+    }
+    
+    static int myriadfs_mknod( const char *sPath, mode_t uPerms, dev_t Dev )
+    {
 #ifdef TRACE
-                printf("myriadfs_mknod(\"%s\", 0%o, %x );\n", sPath, uPerms, Dev );
+        printf("myriadfs_mknod(\"%s\", 0%o, %x );\n", sPath, uPerms, Dev );
 #endif
-                try
-                {
-                        pFs->create( sPath, uPerms, Bu::MyriadFs::sysToDev( Dev ) );
-                        return 0;
-                }
-                catch(...)
-                {
-                        return -EACCES;
-                }
-        }
+        try
+        {
+            pFs->create( sPath, uPerms, Bu::MyriadFs::sysToDev( Dev ) );
+            return 0;
+        }
+        catch(...)
+        {
+            return -EACCES;
+        }
+    }
 
-        static int myriadfs_release( const char *sPath, struct fuse_file_info *fi )
-        {
+    static int myriadfs_release( const char *sPath, struct fuse_file_info *fi )
+    {
 #ifdef TRACE
-                printf("myriadfs_release(\"%s\", ... );\n", sPath );
+        printf("myriadfs_release(\"%s\", ... );\n", sPath );
 #endif
-                hOpenFiles.erase( fi->fh );
-//              printf("File '%s' released, %d files open now.\n",
-//                      sPath, hOpenFiles.getSize() );
+        hOpenFiles.erase( fi->fh );
+//      printf("File '%s' released, %d files open now.\n",
+//          sPath, hOpenFiles.getSize() );
 
-                return 0;
-        }
+        return 0;
+    }
 
-        static int myriadfs_utimens( const char *sPath,
-                        const struct timespec tv[2] )
-        {
+    static int myriadfs_utimens( const char *sPath,
+            const struct timespec tv[2] )
+    {
 #ifdef TRACE
-                printf("myriadfs_utimens(\"%s\", ... );\n", sPath );
+        printf("myriadfs_utimens(\"%s\", ... );\n", sPath );
 #endif
-                try
-                {
-                        pFs->setTimes( sPath, tv[0].tv_sec, tv[1].tv_sec );
-                }
-                catch(...)
-                {
-                        return -EACCES;
-                }
-                return 0;
-        }
+        try
+        {
+            pFs->setTimes( sPath, tv[0].tv_sec, tv[1].tv_sec );
+        }
+        catch(...)
+        {
+            return -EACCES;
+        }
+        return 0;
+    }
 
-        static int myriadfs_unlink( const char *sPath )
-        {
+    static int myriadfs_unlink( const char *sPath )
+    {
 #ifdef TRACE
-                printf("myriadfs_unlink(\"%s\");\n", sPath );
+        printf("myriadfs_unlink(\"%s\");\n", sPath );
 #endif
-                try
-                {
-                        pFs->unlink( sPath );
-                }
-                catch( Bu::MyriadFsException &e )
-                {
-                        printf("MyriadFsException: %s\n", e.what() );
-                        return -EACCES;
-                }
-                return 0;
-        }
+        try
+        {
+            pFs->unlink( sPath );
+        }
+        catch( Bu::MyriadFsException &e )
+        {
+            printf("MyriadFsException: %s\n", e.what() );
+            return -EACCES;
+        }
+        return 0;
+    }
 
-        static int myriadfs_symlink( const char *sTarget, const char *sPath )
-        {
+    static int myriadfs_symlink( const char *sTarget, const char *sPath )
+    {
 #ifdef TRACE
-                printf("myriadfs_symlink(\"%s\", \"%s\");\n", sTarget, sPath );
+        printf("myriadfs_symlink(\"%s\", \"%s\");\n", sTarget, sPath );
 #endif
-                try
-                {
-                        pFs->mkSymLink( sTarget, sPath );
-                }
-                catch( Bu::MyriadFsException &e )
-                {
-                        printf("MyriadFsException: %s\n", e.what() );
-                        return -EACCES;
-                }
-                return 0;
-        }
+        try
+        {
+            pFs->mkSymLink( sTarget, sPath );
+        }
+        catch( Bu::MyriadFsException &e )
+        {
+            printf("MyriadFsException: %s\n", e.what() );
+            return -EACCES;
+        }
+        return 0;
+    }
 
-        static int myriadfs_readlink( const char *sPath, char *sOut, size_t s )
-        {
+    static int myriadfs_readlink( const char *sPath, char *sOut, size_t s )
+    {
 #ifdef TRACE
-                printf("myriadfs_readlink(\"%s\", ... );\n", sPath );
+        printf("myriadfs_readlink(\"%s\", ... );\n", sPath );
 #endif
-                try
-                {
-                        Bu::String sTrg = pFs->readSymLink( sPath );
-                        size_t iLen = (s-1>sTrg.getSize())?(sTrg.getSize()):(s-1);
-                        memcpy( sOut, sTrg.getStr(), iLen );
-                        sOut[iLen] = '\0';
-                }
-                catch( Bu::MyriadFsException &e )
-                {
-                        printf("MyriadFsException: %s\n", e.what() );
-                        return -EACCES;
-                }
-                return 0;
-        }
+        try
+        {
+            Bu::String sTrg = pFs->readSymLink( sPath );
+            size_t iLen = (s-1>sTrg.getSize())?(sTrg.getSize()):(s-1);
+            memcpy( sOut, sTrg.getStr(), iLen );
+            sOut[iLen] = '\0';
+        }
+        catch( Bu::MyriadFsException &e )
+        {
+            printf("MyriadFsException: %s\n", e.what() );
+            return -EACCES;
+        }
+        return 0;
+    }
 
-        static int myriadfs_truncate( const char *sPath, off_t iSize )
-        {
+    static int myriadfs_truncate( const char *sPath, off_t iSize )
+    {
 #ifdef TRACE
-                printf("myriadfs_truncate(\"%s\", %d );\n", sPath, iSize );
+        printf("myriadfs_truncate(\"%s\", %d );\n", sPath, iSize );
 #endif
 
-                try
-                {
-                        pFs->setFileSize( sPath, iSize );
-                }
-                catch( Bu::MyriadFsException &e )
-                {
-                        printf("MyriadFsException: %s\n", e.what() );
-                        return -ENOENT;
-                }
-                return 0;
-        }
+        try
+        {
+            pFs->setFileSize( sPath, iSize );
+        }
+        catch( Bu::MyriadFsException &e )
+        {
+            printf("MyriadFsException: %s\n", e.what() );
+            return -ENOENT;
+        }
+        return 0;
+    }
 
-        static int myriadfs_link( const char *sTarget, const char *sPath )
-        {
+    static int myriadfs_link( const char *sTarget, const char *sPath )
+    {
 #ifdef TRACE
-                printf("myriadfs_link(\"%s\", \"%s\");\n", sTarget, sPath );
+        printf("myriadfs_link(\"%s\", \"%s\");\n", sTarget, sPath );
 #endif
 
-                try
-                {
-                        pFs->mkHardLink( sTarget, sPath );
-                }
-                catch( Bu::MyriadFsException &e )
-                {
-                        printf("MyriadFsException: %s\n", e.what() );
-                        return -EACCES;
-                }
-                return 0;
-        }
+        try
+        {
+            pFs->mkHardLink( sTarget, sPath );
+        }
+        catch( Bu::MyriadFsException &e )
+        {
+            printf("MyriadFsException: %s\n", e.what() );
+            return -EACCES;
+        }
+        return 0;
+    }
 
-        static int myriadfs_rename( const char *sFrom, const char *sTo )
-        {
+    static int myriadfs_rename( const char *sFrom, const char *sTo )
+    {
 #ifdef TRACE
-                printf("myriadfs_rename(\"%s\", \"%s\");\n", sFrom, sTo );
+        printf("myriadfs_rename(\"%s\", \"%s\");\n", sFrom, sTo );
 #endif
 
-                try
-                {
-                        pFs->rename( sFrom, sTo );
-                }
-                catch( Bu::MyriadFsException &e )
-                {
-                        printf("MyriadFsException: %s\n", e.what() );
-                        return -EACCES;
-                }
-                return 0;
-        }
+        try
+        {
+            pFs->rename( sFrom, sTo );
+        }
+        catch( Bu::MyriadFsException &e )
+        {
+            printf("MyriadFsException: %s\n", e.what() );
+            return -EACCES;
+        }
+        return 0;
+    }
 
-        static struct fuse_operations myriadfs_oper;
+    static struct fuse_operations myriadfs_oper;
 
-        int main( int argc, char *argv[] )
-        {
-                pF = new Bu::File("store.myr", Bu::File::Read|Bu::File::Write|Bu::File::Create );
-                pFs = new Bu::MyriadFs( *pF, 512 );
-                memset( &myriadfs_oper, sizeof(myriadfs_oper), 0 );
-                myriadfs_oper.getattr    = myriadfs_getattr;
-                myriadfs_oper.readdir    = myriadfs_readdir;
-                myriadfs_oper.mkdir              = myriadfs_mkdir;
-                myriadfs_oper.open       = myriadfs_open;
-                myriadfs_oper.read       = myriadfs_read;
-                myriadfs_oper.write      = myriadfs_write;
-                myriadfs_oper.create     = myriadfs_create;
-                myriadfs_oper.mknod              = myriadfs_mknod;
-                myriadfs_oper.release    = myriadfs_release;
-                myriadfs_oper.utimens    = myriadfs_utimens;
-                myriadfs_oper.unlink     = myriadfs_unlink;
-                myriadfs_oper.rmdir              = myriadfs_unlink;
-                myriadfs_oper.symlink    = myriadfs_symlink;
-                myriadfs_oper.readlink   = myriadfs_readlink;
-                myriadfs_oper.truncate   = myriadfs_truncate;
-                myriadfs_oper.link               = myriadfs_link;
-                myriadfs_oper.rename     = myriadfs_rename;
-                printf("Starting fuse_main.\n");
-                int iRet = fuse_main( argc, argv, &myriadfs_oper, NULL );
-                printf("Done with fuse_main.\n");
-                delete pFs;
-                delete pF;
-                return iRet;
-        }
+    int main( int argc, char *argv[] )
+    {
+        pF = new Bu::File("store.myr", Bu::File::Read|Bu::File::Write|Bu::File::Create );
+        pFs = new Bu::MyriadFs( *pF, 512 );
+        memset( &myriadfs_oper, sizeof(myriadfs_oper), 0 );
+        myriadfs_oper.getattr    = myriadfs_getattr;
+        myriadfs_oper.readdir    = myriadfs_readdir;
+        myriadfs_oper.mkdir      = myriadfs_mkdir;
+        myriadfs_oper.open       = myriadfs_open;
+        myriadfs_oper.read       = myriadfs_read;
+        myriadfs_oper.write      = myriadfs_write;
+        myriadfs_oper.create     = myriadfs_create;
+        myriadfs_oper.mknod      = myriadfs_mknod;
+        myriadfs_oper.release    = myriadfs_release;
+        myriadfs_oper.utimens    = myriadfs_utimens;
+        myriadfs_oper.unlink     = myriadfs_unlink;
+        myriadfs_oper.rmdir      = myriadfs_unlink;
+        myriadfs_oper.symlink    = myriadfs_symlink;
+        myriadfs_oper.readlink   = myriadfs_readlink;
+        myriadfs_oper.truncate   = myriadfs_truncate;
+        myriadfs_oper.link       = myriadfs_link;
+        myriadfs_oper.rename     = myriadfs_rename;
+        printf("Starting fuse_main.\n");
+        int iRet = fuse_main( argc, argv, &myriadfs_oper, NULL );
+        printf("Done with fuse_main.\n");
+        delete pFs;
+        delete pF;
+        return iRet;
+    }
 }
diff --git a/src/stable/archival.cpp b/src/stable/archival.cpp
index 5e6e612..9ba10f2 100644
--- a/src/stable/archival.cpp
+++ b/src/stable/archival.cpp
@@ -17,19 +17,19 @@ Bu::Archival::~Archival()
 
 Bu::ArchiveBase &Bu::operator<<(Bu::ArchiveBase &s, const Bu::Archival &p)
 {
-        const_cast<Bu::Archival &>(p).archive( s );
-        return s;
+    const_cast<Bu::Archival &>(p).archive( s );
+    return s;
 }
 
 Bu::ArchiveBase &Bu::operator<<(Bu::ArchiveBase &s, Bu::Archival &p)
 {
-        p.archive( s );
-        return s;
+    p.archive( s );
+    return s;
 }
 
 Bu::ArchiveBase &Bu::operator>>(Bu::ArchiveBase &s, Bu::Archival &p)
 {
-        p.archive( s );
-        return s;
+    p.archive( s );
+    return s;
 }
 
diff --git a/src/stable/archival.h b/src/stable/archival.h
index 664bc98..78faffb 100644
--- a/src/stable/archival.h
+++ b/src/stable/archival.h
@@ -12,40 +12,40 @@
 
 namespace Bu
 {
-        /**
-         * The base class for any class you want to archive.  Simply include this as
-         * a base class, implement the purely virtual archive function and you've
-         * got an easily archiveable class.
-         *
-         * Archival: "of or pertaining to archives or valuable records; contained
+    /**
+     * The base class for any class you want to archive.  Simply include this as
+     * a base class, implement the purely virtual archive function and you've
+     * got an easily archiveable class.
+     *
+     * Archival: "of or pertaining to archives or valuable records; contained
          * in or comprising such archives or records."
-         */
-        class Archival
-        {
-        public:
-                /**
-                 * Does nothing, here for completeness.
-                 */
-                Archival();
-
-                /**
-                 * Here to ensure the deconstructor is virtual.
-                 */
-                virtual ~Archival();
-
-                /**
-                 * This is the main workhorse of the archive system, just override and
-                 * you've got a archiveable class.  A reference to the Archive
-                 * used is passed in as your only parameter, query it to discover if
-                 * you are loading or saving.
-                 * @param ar A reference to the Archive object to use.
-                 */
-                virtual void archive( class ArchiveBase &ar )=0;
-        };
-
-        ArchiveBase &operator<<(ArchiveBase &, const class Bu::Archival &);
-        ArchiveBase &operator<<(ArchiveBase &, class Bu::Archival &);
-        ArchiveBase &operator>>(ArchiveBase &, class Bu::Archival &);
+     */
+    class Archival
+    {
+    public:
+        /**
+         * Does nothing, here for completeness.
+         */
+        Archival();
+
+        /**
+         * Here to ensure the deconstructor is virtual.
+         */
+        virtual ~Archival();
+
+        /**
+         * This is the main workhorse of the archive system, just override and
+         * you've got a archiveable class.  A reference to the Archive
+         * used is passed in as your only parameter, query it to discover if
+         * you are loading or saving.
+         * @param ar A reference to the Archive object to use.
+         */
+        virtual void archive( class ArchiveBase &ar )=0;
+    };
+
+    ArchiveBase &operator<<(ArchiveBase &, const class Bu::Archival &);
+    ArchiveBase &operator<<(ArchiveBase &, class Bu::Archival &);
+    ArchiveBase &operator>>(ArchiveBase &, class Bu::Archival &);
 
 }
 
diff --git a/src/stable/archive.cpp b/src/stable/archive.cpp
index 13480e1..3769e0e 100644
--- a/src/stable/archive.cpp
+++ b/src/stable/archive.cpp
@@ -12,9 +12,9 @@
 #include "bu/sio.h"
 
 Bu::Archive::Archive( Stream &rStream, bool bLoading ) :
-        bLoading( bLoading ),
-        rStream( rStream ),
-        nNextID( 1 )
+    bLoading( bLoading ),
+    rStream( rStream ),
+    nNextID( 1 )
 {
 }
 
@@ -24,66 +24,66 @@ Bu::Archive::~Archive()
 
 void Bu::Archive::write( const void *pData, size_t nSize )
 {
-        if( nSize == 0 || pData == NULL )
-                return;
+    if( nSize == 0 || pData == NULL )
+        return;
 
-        rStream.write( (const char *)pData, nSize );
+    rStream.write( (const char *)pData, nSize );
 }
 
 void Bu::Archive::read( void *pData, size_t nSize )
 {
-        if( nSize == 0 || pData == NULL )
-                return;
+    if( nSize == 0 || pData == NULL )
+        return;
 
-        if( (size_t)rStream.read( (char *)pData, nSize ) < nSize )
-                throw Bu::ExceptionBase("Insufficient data to unarchive object.");
+    if( (size_t)rStream.read( (char *)pData, nSize ) < nSize )
+        throw Bu::ExceptionBase("Insufficient data to unarchive object.");
 }
 
 void Bu::Archive::close()
 {
-        rStream.close();
+    rStream.close();
 }
 
 bool Bu::Archive::isLoading()
 {
-        return bLoading;
+    return bLoading;
 }
 
 uint32_t Bu::Archive::getID( const void *ptr )
 {
-        if( hPtrID.has( (ptrdiff_t)ptr ) )
-                return hPtrID.get( (ptrdiff_t)ptr );
-        hPtrID.insert( (ptrdiff_t)ptr, nNextID );
-        return nNextID++;
+    if( hPtrID.has( (ptrdiff_t)ptr ) )
+        return hPtrID.get( (ptrdiff_t)ptr );
+    hPtrID.insert( (ptrdiff_t)ptr, nNextID );
+    return nNextID++;
 }
 
 void Bu::Archive::assocPtrID( void **ptr, uint32_t id )
 {
-        if( hPtrID.has( id ) )
-        {
-                *ptr = (void *)hPtrID.get( id );
-                return;
-        }
-
-        if( !hPtrDest.has( id ) )
-                hPtrDest.insert( id, List<void **>() );
-                        
-        hPtrDest[id].getValue().append( ptr );
+    if( hPtrID.has( id ) )
+    {
+        *ptr = (void *)hPtrID.get( id );
+        return;
+    }
+
+    if( !hPtrDest.has( id ) )
+        hPtrDest.insert( id, List<void **>() );
+            
+    hPtrDest[id].getValue().append( ptr );
 }
 
 void Bu::Archive::readID( const void *ptr, uint32_t id )
 {
-        hPtrID.insert( id, (ptrdiff_t)ptr );
-
-        if( hPtrDest.has( id ) )
-        {
-                Bu::List<void **> &l = hPtrDest.get( id );
-                for( Bu::List<void **>::iterator i = l.begin(); i != l.end(); i++ )
-                {
-                        *(*i) = (void *)ptr;
-                }
-
-                hPtrDest.erase( id );
-        }
+    hPtrID.insert( id, (ptrdiff_t)ptr );
+
+    if( hPtrDest.has( id ) )
+    {
+        Bu::List<void **> &l = hPtrDest.get( id );
+        for( Bu::List<void **>::iterator i = l.begin(); i != l.end(); i++ )
+        {
+            *(*i) = (void *)ptr;
+        }
+
+        hPtrDest.erase( id );
+    }
 }
 
diff --git a/src/stable/archive.h b/src/stable/archive.h
index 9716bb1..f98402d 100644
--- a/src/stable/archive.h
+++ b/src/stable/archive.h
@@ -16,123 +16,123 @@
 
 namespace Bu
 {
-        class Archival;
-        class Stream;
+    class Archival;
+    class Stream;
 
-        /**
-         * Provides a framework for serialization of objects and primitives.  The
-         * archive will handle any basic primitive, a few special types, like char *
-         * strings, as well as STL classes and anything that inherits from the
-         * Archival class.  Each Archive operates on a Stream, so you can send the
-         * data using an Archive almost anywhere.
-         *
-         * In order to use an Archive to store something to a file, try something
-         * like:
-         *@code
+    /**
+     * Provides a framework for serialization of objects and primitives.  The
+     * archive will handle any basic primitive, a few special types, like char *
+     * strings, as well as STL classes and anything that inherits from the
+     * Archival class.  Each Archive operates on a Stream, so you can send the
+     * data using an Archive almost anywhere.
+     *
+     * In order to use an Archive to store something to a file, try something
+     * like:
+     *@code
      * File sOut("output", "wb"); // This is a stream subclass
-         * Archive ar( sOut, Archive::save );
-         * ar << myClass;
-         @endcode
-         * In this example myClass is any class that inherits from Archival.  When
-         * the storage operator is called, the Archival::archive() function in the
-         * myClass object is called with a reference to the Archive.  This can be
-         * handled in one of two ways:
-         *@code
-         * void MyClass::archive( Archive &ar )
-         * {
-         *      ar && sName && nAge && sJob;
-         * }
-         @endcode
-         * Here we don't worry about weather we're loading or saving by using the
-         * smart && operator.  This allows us to write very consistent, very simple
-         * archive functions that really do a lot of work.  If we wanted to do
-         * something different in the case of loading or saving we would do:
-         *@code
-         * void MyClass::archive( Archive &ar )
-         * {
-         *      if( ar.isLoading() )
-         *      {
-         *              ar >> sName >> nAge >> sJob;
-         *      } else
-         *      {
-         *              ar << sName << nAge << sJob;
-         *      }
-         * }
-         @endcode
-         * Archive currently does not provide facility to make fully portable
-         * archives.  For example, it will not convert between endianness for you,
-         * nor will it take into account differences between primitive sizes on
-         * different platforms.  This, at the moment, is up to the user to ensure.
-         * One way of dealing with the latter problem is to make sure and use
-         * explicit primitive types from the stdint.h header, i.e. int32_t.
-         */
-        class Archive : public ArchiveBase
-        {
-        private:
-                bool bLoading;
-        public:
-                bool isLoading();
+     * Archive ar( sOut, Archive::save );
+     * ar << myClass;
+     @endcode
+     * In this example myClass is any class that inherits from Archival.  When
+     * the storage operator is called, the Archival::archive() function in the
+     * myClass object is called with a reference to the Archive.  This can be
+     * handled in one of two ways:
+     *@code
+     * void MyClass::archive( Archive &ar )
+     * {
+     *  ar && sName && nAge && sJob;
+     * }
+     @endcode
+     * Here we don't worry about weather we're loading or saving by using the
+     * smart && operator.  This allows us to write very consistent, very simple
+     * archive functions that really do a lot of work.  If we wanted to do
+     * something different in the case of loading or saving we would do:
+     *@code
+     * void MyClass::archive( Archive &ar )
+     * {
+     *  if( ar.isLoading() )
+     *  {
+     *      ar >> sName >> nAge >> sJob;
+     *  } else
+     *  {
+     *      ar << sName << nAge << sJob;
+     *  }
+     * }
+     @endcode
+     * Archive currently does not provide facility to make fully portable
+     * archives.  For example, it will not convert between endianness for you,
+     * nor will it take into account differences between primitive sizes on
+     * different platforms.  This, at the moment, is up to the user to ensure.
+     * One way of dealing with the latter problem is to make sure and use
+     * explicit primitive types from the stdint.h header, i.e. int32_t.
+     */
+    class Archive : public ArchiveBase
+    {
+    private:
+        bool bLoading;
+    public:
+        bool isLoading();
 
-                enum
-                {
-                        load    =       true,
-                        save    =       false
-                };
-                
-                Archive( Stream &rStream, bool bLoading );
-                virtual ~Archive();
-                virtual void close();
+        enum
+        {
+            load    =   true,
+            save    =   false
+        };
+        
+        Archive( Stream &rStream, bool bLoading );
+        virtual ~Archive();
+        virtual void close();
 
-                virtual void write( const void *pData, size_t iSize );
-                virtual void read( void *pData, size_t iSize );
-                
-                /**
-                 * For storage, get an ID for the pointer to the object you're going to
-                 * write.
-                 */
-                uint32_t getID( const void *ptr );
+        virtual void write( const void *pData, size_t iSize );
+        virtual void read( void *pData, size_t iSize );
+        
+        /**
+         * For storage, get an ID for the pointer to the object you're going to
+         * write.
+         */
+        uint32_t getID( const void *ptr );
 
-                /**
-                 * For loading.  Assosiates an empty pointer with an id.  When you wind
-                 * up loading an id reference to a pointer for an object that may or
-                 * may not have loaded yet, call this with the id, if it has been loaded
-                 * already, you'll immediately get a pointer, if not, it will write one
-                 * for you when the time comes.
-                 */
-                void assocPtrID( void **ptr, uint32_t id );
+        /**
+         * For loading.  Assosiates an empty pointer with an id.  When you wind
+         * up loading an id reference to a pointer for an object that may or
+         * may not have loaded yet, call this with the id, if it has been loaded
+         * already, you'll immediately get a pointer, if not, it will write one
+         * for you when the time comes.
+         */
+        void assocPtrID( void **ptr, uint32_t id );
 
-                /**
-                 * For loading.  Call this when you load an object that other things may
-                 * have pointers to.  It will assosiate every pointer that's been
-                 * registered with assocPtrID to the pointer passed in, and id passed
-                 * in.  It will also set things up so future calls to assocPtrID will
-                 * automatically succeed immediately.
-                 */
-                void readID( const void *ptr, uint32_t id );
+        /**
+         * For loading.  Call this when you load an object that other things may
+         * have pointers to.  It will assosiate every pointer that's been
+         * registered with assocPtrID to the pointer passed in, and id passed
+         * in.  It will also set things up so future calls to assocPtrID will
+         * automatically succeed immediately.
+         */
+        void readID( const void *ptr, uint32_t id );
 
-                template<typename t>
-                void setProp( const Bu::String &sId, const t &val )
-                {
-                        if( !hProps.has( sId ) )
-                        {
-                                hProps.insert( sId, Variant() );
-                        }
-                        hProps.get( sId ) = val;
-                }
+        template<typename t>
+        void setProp( const Bu::String &sId, const t &val )
+        {
+            if( !hProps.has( sId ) )
+            {
+                hProps.insert( sId, Variant() );
+            }
+            hProps.get( sId ) = val;
+        }
 
-                template<typename t>
-                t getProp( const Bu::String &sId )
-                {
-                        return hProps.get( sId );
-                }
+        template<typename t>
+        t getProp( const Bu::String &sId )
+        {
+            return hProps.get( sId );
+        }
 
-        private:
-                Stream &rStream;
-                uint32_t nNextID;
-                Hash<uint32_t,uint32_t> hPtrID;
-                Hash<uint32_t,List<void **> > hPtrDest;
-                Hash<Bu::String, Variant> hProps;
-        };
+    private:
+        Stream &rStream;
+        uint32_t nNextID;
+        Hash<uint32_t,uint32_t> hPtrID;
+        Hash<uint32_t,List<void **> > hPtrDest;
+        Hash<Bu::String, Variant> hProps;
+    };
 }
 
 #endif
diff --git a/src/stable/archivebase.cpp b/src/stable/archivebase.cpp
index dcf08f4..d0d22ce 100644
--- a/src/stable/archivebase.cpp
+++ b/src/stable/archivebase.cpp
@@ -17,181 +17,181 @@ Bu::ArchiveBase::~ArchiveBase()
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, bool p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, char p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed char p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned char p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed short p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned short p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed int p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned int p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed long p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned long p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed long long p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned long long p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, float p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, double p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, long double p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, bool &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, char &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed char &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned char &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed short &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned short &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed int &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned int &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed long &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned long &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed long long &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned long long &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, float &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, double &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, long double &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
diff --git a/src/stable/archivebase.h b/src/stable/archivebase.h
index 34ec1af..3f9e30f 100644
--- a/src/stable/archivebase.h
+++ b/src/stable/archivebase.h
@@ -13,63 +13,63 @@
 
 namespace Bu
 {
-        class ArchiveBase
-        {
-        public:
-                ArchiveBase();
-                virtual ~ArchiveBase();
+    class ArchiveBase
+    {
+    public:
+        ArchiveBase();
+        virtual ~ArchiveBase();
 
-                virtual void close()=0;
-                virtual void write( const void *pData, size_t iLength )=0;
-                virtual void read( void *pData, size_t iLength )=0;
-                virtual bool isLoading()=0;
-        };
+        virtual void close()=0;
+        virtual void write( const void *pData, size_t iLength )=0;
+        virtual void read( void *pData, size_t iLength )=0;
+        virtual bool isLoading()=0;
+    };
 
-        template<typename T> ArchiveBase &operator&&( ArchiveBase &ar, T &dat )
-        {
-                if( ar.isLoading() )
-                {
-                        return ar >> dat;
-                }
-                else
-                {
-                        return ar << dat;
-                }
-        }
+    template<typename T> ArchiveBase &operator&&( ArchiveBase &ar, T &dat )
+    {
+        if( ar.isLoading() )
+        {
+            return ar >> dat;
+        }
+        else
+        {
+            return ar << dat;
+        }
+    }
 
-        ArchiveBase &operator<<( ArchiveBase &ar, bool p );
-        ArchiveBase &operator<<( ArchiveBase &ar, char p );
-        ArchiveBase &operator<<( ArchiveBase &ar, signed char p );
-        ArchiveBase &operator<<( ArchiveBase &ar, unsigned char p );
-        ArchiveBase &operator<<( ArchiveBase &ar, signed short p );
-        ArchiveBase &operator<<( ArchiveBase &ar, unsigned short p );
-        ArchiveBase &operator<<( ArchiveBase &ar, signed int p );
-        ArchiveBase &operator<<( ArchiveBase &ar, unsigned int p );
-        ArchiveBase &operator<<( ArchiveBase &ar, signed long p );
-        ArchiveBase &operator<<( ArchiveBase &ar, unsigned long p );
-        ArchiveBase &operator<<( ArchiveBase &ar, signed long long p );
-        ArchiveBase &operator<<( ArchiveBase &ar, unsigned long long p );
-        ArchiveBase &operator<<( ArchiveBase &ar, float p );
-        ArchiveBase &operator<<( ArchiveBase &ar, double p );
-        ArchiveBase &operator<<( ArchiveBase &ar, long double p );
-        
-        ArchiveBase &operator>>( ArchiveBase &ar, bool &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, char &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, signed char &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, unsigned char &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, signed short &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, unsigned short &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, signed int &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, unsigned int &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, signed long &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, unsigned long &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, signed long long &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, unsigned long long &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, float &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, double &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, long double &p );
+    ArchiveBase &operator<<( ArchiveBase &ar, bool p );
+    ArchiveBase &operator<<( ArchiveBase &ar, char p );
+    ArchiveBase &operator<<( ArchiveBase &ar, signed char p );
+    ArchiveBase &operator<<( ArchiveBase &ar, unsigned char p );
+    ArchiveBase &operator<<( ArchiveBase &ar, signed short p );
+    ArchiveBase &operator<<( ArchiveBase &ar, unsigned short p );
+    ArchiveBase &operator<<( ArchiveBase &ar, signed int p );
+    ArchiveBase &operator<<( ArchiveBase &ar, unsigned int p );
+    ArchiveBase &operator<<( ArchiveBase &ar, signed long p );
+    ArchiveBase &operator<<( ArchiveBase &ar, unsigned long p );
+    ArchiveBase &operator<<( ArchiveBase &ar, signed long long p );
+    ArchiveBase &operator<<( ArchiveBase &ar, unsigned long long p );
+    ArchiveBase &operator<<( ArchiveBase &ar, float p );
+    ArchiveBase &operator<<( ArchiveBase &ar, double p );
+    ArchiveBase &operator<<( ArchiveBase &ar, long double p );
+    
+    ArchiveBase &operator>>( ArchiveBase &ar, bool &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, char &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, signed char &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, unsigned char &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, signed short &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, unsigned short &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, signed int &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, unsigned int &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, signed long &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, unsigned long &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, signed long long &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, unsigned long long &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, float &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, double &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, long double &p );
 
-        
+    
 };
 
 #endif
diff --git a/src/stable/array.h b/src/stable/array.h
index f765e75..324c9ac 100644
--- a/src/stable/array.h
+++ b/src/stable/array.h
@@ -15,697 +15,697 @@
 
 namespace Bu
 {
-        subExceptionDecl( ArrayException )
-
-        template<typename value, int inc, typename valuealloc>
-        class Array;
-
-        /** @cond DEVEL */
-        template<typename value, int inc, typename valuealloc>
-        class ArrayCore
-        {
-        friend class Array<value, inc, valuealloc>;
-        friend class SharedCore<
-                Array<value, inc, valuealloc>,
-                ArrayCore<value, inc, valuealloc>
-                >;
-        private:                
-                ArrayCore() :
-                        pData( NULL ),
-                        iSize( 0 ),
-                        iCapacity( 0 )
-                { }
-
-                void setCapacity( int iNewLen )
-                {
-                        //clear();
-                        //iCapacity = iCapacity;
-                        //pData = va.allocate( iCapacity );
-                        if( iNewLen <= iCapacity ) return;
-                        value *pNewData = va.allocate( iNewLen );
-                        if( pData )
-                        {
-                                for( int j = 0; j < iSize; j++ )
-                                {
-                                        va.construct( &pNewData[j], pData[j] );
-                                        va.destroy( &pData[j] );
-                                }
-                                va.deallocate( pData, iCapacity );
-                        }
-                        pData = pNewData;
-                        iCapacity = iNewLen;
-                }
-
-                virtual ~ArrayCore()
-                {
-                        clear();
-                }
-
-                void clear()
-                {
-                        if( pData )
-                        {
-                                for( int j = 0; j < iSize; j++ )
-                                {
-                                        va.destroy( &pData[j] );
-                                }
-                                va.deallocate( pData, iCapacity );
-                                pData = NULL;
-                        }
-                        iSize = 0;
-                        iCapacity = 0;
-                }
-
-                void erase( int iPos )
-                {
-                        for( int j = iPos; j < iSize; j++ )
-                        {
-                                va.destroy( &pData[j] );
-                                if( j == iSize-1 )
-                                {
-                                        iSize--;
-                                        return;
-                                }
-                                va.construct( &pData[j], pData[j+1] );
-                        }
-                }
-
-                void swapErase( int iPos )
-                {
-                        if( iPos == iSize-1 )
-                        {
-                                erase( iPos );
-                                return;
-                        }
-                        va.destroy( &pData[iPos] );
-                        va.construct( &pData[iPos], pData[iSize-1] );
-                        va.destroy( &pData[iSize-1] );
-                        iSize--;
-                }
-
-                valuealloc va;
-                value *pData;
-                long iSize;
-                long iCapacity;
-        };
-        /** @endcond */
-
-        /**
-         * Array type container, just like a normal array only flexible and keeps
-         * track of your memory for you.
-         *
-         *@param value (typename) The type of data to store in your list
-         *@param valuealloc (typename) Memory Allocator for your value type
-         *@param linkalloc (typename) Memory Allocator for the list links.
-         *@ingroup Containers
-         */
-        template<typename value, int inc=10, typename valuealloc=std::allocator<value> >
-        class Array : public SharedCore<
-                                  Array<value, inc, valuealloc>,
-                                  ArrayCore<value, inc, valuealloc>
-                                  >
-        {
-        private:
-                typedef class Array<value, inc, valuealloc> MyType;
-                typedef class ArrayCore<value, inc, valuealloc> Core;
-
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_resetCore;
-                using SharedCore<MyType, Core>::_allocateCore;
-
-        public:
-                struct const_iterator;
-                struct iterator;
-
-                Array()
-                {
-                }
-
-                Array( const MyType &src ) :
-                        SharedCore<MyType, Core >( src )
-                {
-                }
-                
-                Array( long iSetCap )
-                {
-                        setCapacity( iSetCap );
-                }
-
-                ~Array()
-                {
-                }
-
-                bool operator==( const MyType &src ) const
-                {
-                        if( core == src.core )
-                                return true;
-                        if( core->iSize != src.core->iSize )
-                                return false;
-
-                        for( int j = 0; j < core->iSize; j++ )
-                        {
-                                if( core->pData[j] != src.core->pData[j] )
-                                        return false;
-                        }
-                        return true;
-                }
-
-                bool operator!=( const MyType &src ) const
-                {
-                        return !(*this == src);
-                }
-
-                /**
-                 * Clear the array.
-                 */
-                void clear()
-                {
-                        _resetCore();
-                }
-
-                MyType &append( const value &rVal )
-                {
-                        _hardCopy();
-                        if( core->iSize == core->iCapacity )
-                        {
-                                core->setCapacity( core->iCapacity + inc );
-                        }
-
-                        core->va.construct( &core->pData[core->iSize++], rVal );
-
-                        return *this;
-                }
-                
-                MyType &append( const MyType &rVal )
-                {
-                        _hardCopy();
-
-                        if( core->iSize + rVal.core->iSize > core->iCapacity )
-                        {
-                                core->setCapacity( core->iSize + rVal.core->iSize + inc );
-                        }
-                        
-                        for( int j = 0; j < rVal.core->iSize; j++ )
-                        {
-                                core->va.construct(
-                                        &core->pData[core->iSize++],
-                                        rVal.core->pData[j]
-                                        );
-                        }
-
-                        return *this;
-                }
-
-                //operator
-                value &operator[]( long iIndex )
-                {
-                        _hardCopy();
-                        if( iIndex < 0 || iIndex >= core->iSize )
-                                throw ArrayException(
-                                        "Index %d out of range 0:%d", iIndex, core->iSize );
-
-                        return core->pData[iIndex];
-                }
-                
-                const value &operator[]( long iIndex ) const
-                {
-                        if( iIndex < 0 || iIndex >= core->iSize )
-                                throw ArrayException(
-                                        "Index %d out of range 0:%d", iIndex, core->iSize );
-
-                        return core->pData[iIndex];
-                }
-
-                value &get( long iIndex )
-                {
-                        _hardCopy();
-                        if( iIndex < 0 || iIndex >= core->iSize )
-                                throw ArrayException(
-                                        "Index %d out of range 0:%d", iIndex, core->iSize );
-
-                        return core->pData[iIndex];
-                }
-
-                const value &get( long iIndex ) const
-                {
-                        if( iIndex < 0 || iIndex >= core->iSize )
-                                throw ArrayException(
-                                        "Index %d out of range 0:%d", iIndex, core->iSize );
-
-                        return core->pData[iIndex];
-                }
-
-                value &first()
-                {
-                        _hardCopy();
-                        return core->pData[0];
-                }
-
-                const value &first() const
-                {
-                        return core->pData[0];
-                }
-
-                value &last()
-                {
-                        _hardCopy();
-                        return core->pData[core->iSize-1];
-                }
-
-                const value &last() const
-                {
-                        return core->pData[core->iSize-1];
-                }
-
-                /**
-                 * Returns true if the array is empty.  The capacity has no bearing on
-                 * this, only the size.
-                 */
-                bool isEmpty() const
-                {
-                        return core->iSize==0;
-                }
-
-                /**
-                 * Get the current size of the array.
-                 *@returns The current size of the array.
-                 */
-                long getSize() const
-                {
-                        return core->iSize;
-                }
-
-                /**
-                 * Get the capacity of the array.  This number will grow as data is
-                 * added, and is mainly for the curious, it doesn't really determine
-                 * much for the end user.
-                 *@returns The current capacity of the array.
-                 */
-                long getCapacity() const
-                {
-                        return core->iCapacity;
-                }
-
-                /**
-                 * Change the capacity of the array, very useful if you know you'll be
-                 * adding a large amount of already counted items to the array, makes
-                 * the appending much faster afterwords.
-                 *@param iNewLen The new capacity of the array.
-                 *@todo Set this up so it can reduce the size of the array as well as
-                 * make it bigger.
-                 */
-                void setCapacity( long iNewLen )
-                {
-                        _hardCopy();
-                        core->setCapacity( iNewLen );
-                }
-
-                typedef struct iterator
-                {
-                        friend class Array<value, inc, valuealloc>;
-                private:
-                        iterator( MyType &src, long iPos=0 ) :
-                                src( src ),
-                                iPos( iPos )
-                        {
-                                if( this->iPos >= src.getSize() )
-                                        this->iPos = -1;
-                        }
-
-                        MyType &src;
-                        long iPos;
-
-                public:
-                        iterator operator++( int )
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot increment iterator past end of array.");
-                                        iPos++;
-                                if( iPos >= src.getSize() )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        iterator operator++()
-                        {
-                                if( iPos >= 0 )
-                                        iPos++;
-                                if( iPos >= src.getSize() )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        iterator operator+( int iAmnt )
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot increment iterator past end of array.");
-                                        iPos += iAmnt;
-                                if( iPos >= src.getSize() )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        iterator operator--( int )
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot increment iterator past end of array.");
-                                        iPos--;
-                                if( iPos < 0 )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        iterator operator--()
-                        {
-                                if( iPos < src.getSize() )
-                                        iPos--;
-                                if( iPos <= 0 )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        iterator operator-( int iAmnt )
-                        {
-                                if( iPos < src.getSize() )
-                                        iPos -= iAmnt;
-                                if( iPos <= 0 )
-                                        iPos = -1;
-                                return *this;
-                        }
-
-                        bool operator==( const iterator &oth ) const
-                        {
-                                return iPos == oth.iPos;
-                        }
-
-                        bool operator!=( const iterator &oth ) const
-                        {
-                                return iPos != oth.iPos;
-                        }
-
-                        iterator operator=( const iterator &oth )
-                        {
-                                if( &src != &oth.src )
-                                        throw ArrayException(
-                                                "Cannot mix iterators from different array objects.");
-                                iPos = oth.iPos;
-                        }
-
-                        value &operator*()
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot dereference finished iterator.");
-                                return src[iPos];
-                        }
-
-                        long getIndex() const
-                        {
-                                return iPos;
-                        }
-
-                        operator bool() const
-                        {
-                                return iPos >= 0;
-                        }
-
-                        bool isValid() const
-                        {
-                                return iPos >= 0;
-                        }
-                } iterator;
-                
-                typedef struct const_iterator
-                {
-                        friend class Array<value, inc, valuealloc>;
-                private:
-                        const_iterator( const MyType &src, long iPos=0 ) :
-                                src( src ),
-                                iPos( iPos )
-                        {
-                                if( this->iPos >= src.getSize() )
-                                        this->iPos = -1;
-                        }
-
-                        const MyType &src;
-                        long iPos;
-
-                public:
-                        const_iterator( iterator &rSrc ) :
-                                src( rSrc.src ),
-                                iPos( rSrc.iPos )
-                        {
-                        }
-                        const_iterator operator++( int )
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot increment iterator past end of array.");
-                                        iPos++;
-                                if( iPos >= src.getSize() )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        const_iterator operator++()
-                        {
-                                if( iPos >= 0 )
-                                        iPos++;
-                                if( iPos >= src.getSize() )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        const_iterator operator--( int )
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot increment iterator past end of array.");
-                                        iPos--;
-                                if( iPos < 0 )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        const_iterator operator--()
-                        {
-                                if( iPos < src.getSize() )
-                                        iPos--;
-                                if( iPos <= 0 )
-                                        iPos = -1;
-                                return *this;
-                        }
-
-                        bool operator==( const const_iterator &oth ) const
-                        {
-                                return iPos == oth.iPos;
-                        }
-
-                        bool operator!=( const const_iterator &oth ) const
-                        {
-                                return iPos != oth.iPos;
-                        }
-
-                        const_iterator operator=( const const_iterator &oth )
-                        {
-                                if( &src != &oth.src )
-                                        throw ArrayException(
-                                                "Cannot mix iterators from different array objects.");
-                                iPos = oth.iPos;
-                        }
-
-                        const value &operator*() const
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot dereference finished iterator.");
-                                return src[iPos];
-                        }
-
-                        long getIndex() const
-                        {
-                                return iPos;
-                        }
-                        
-                        operator bool() const
-                        {
-                                return iPos >= 0;
-                        }
-
-                        bool isValid() const
-                        {
-                                return iPos >= 0;
-                        }
-                } const_iterator;
-
-                iterator begin()
-                {
-                        return iterator( *this );
-                }
-
-                const_iterator begin() const
-                {
-                        return const_iterator( *this );
-                }
-
-                iterator end()
-                {
-                        return iterator( *this, -1 );
-                }
-
-                const_iterator end() const
-                {
-                        return const_iterator( *this, -1 );
-                }
-
-                MyType &insert( iterator i, const value &rVal )
-                {
-                        if( i.iPos == -1 )
-                        {
-                                append( rVal );
-                                return *this;
-                        }
-
-                        _hardCopy();
-                        if( core->iSize == core->iCapacity )
-                        {
-                                core->setCapacity( core->iCapacity + inc );
-                        }
-                        core->iSize++;
-
-                        core->va.construct(
-                                &core->pData[core->iSize-1],
-                                core->pData[core->iSize-2]
-                                );
-                        for( int iPos = core->iSize-2; iPos > i.iPos; iPos-- )
-                        {
-                                core->va.destroy( &core->pData[iPos] );
-                                core->va.construct( &core->pData[iPos], core->pData[iPos-1] );
-                        }
-                        core->va.destroy( &core->pData[i.iPos] );
-                        core->va.construct( &core->pData[i.iPos], rVal );
-
-                        return *this;
-                }
-
-                /**
-                 * If order is important, use this.  It will delete the suggested item
-                 * and move the rest of the data up a spot.  This is a time O(n)
-                 * operation.  If the order isn't important, check swapErase
-                 */
-                void erase( iterator i )
-                {
-                        _hardCopy();
-                        core->erase( i.iPos );
-                }
-
-                void erase( const value &v )
-                {
-                        _hardCopy();
-                        for( int j = 0; j < core->iSize; j++ )
-                        {
-                                if( core->pData[j] == v )
-                                {
-                                        core->erase( j );
-                                        return;
-                                }
-                        }
-                }
-
-                void eraseLast()
-                {
-                        _hardCopy();
-                        core->erase( core->iSize-1 );
-                }
-
-                void eraseFirst()
-                {
-                        _hardCopy();
-                        core->erase( 0 );
-                }
-
-                /**
-                 * In order to make swapErase faster, what it does is swap the given
-                 * item in the array with the last item, then make the array shorter
-                 * by one.  It changes the order of the elements in the array, so it
-                 * should be used carefully, but it is time O(1) instead of O(n) like
-                 * erase.
-                 */
-                void swapErase( iterator i )
-                {
-                        _hardCopy();
-                        core->swapErase( i.iPos );
-                }
-
-        protected:
-                virtual Core *_copyCore( Core *src )
-                {
-                        Core *pRet = _allocateCore();
-                        pRet->setCapacity( src->iCapacity );
-                        pRet->iSize = src->iSize;
-                        for( int j = 0; j < src->iSize; j++ )
-                        {       
-                                pRet->va.construct( &pRet->pData[j], src->pData[j] );
-                        }
-                        return pRet;
-                }
-
-        private:
-        };
-
-        class Formatter;
-        Formatter &operator<<( Formatter &rOut, char *sStr );
-        Formatter &operator<<( Formatter &rOut, signed char c );
-        template<typename value>
-        Formatter &operator<<( Formatter &f, const Bu::Array<value> &a )
-        {
-                f << '[';
-                for( typename Bu::Array<value>::const_iterator i = a.begin(); i; i++ )
-                {
-                        if( i != a.begin() )
-                                f << ", ";
-                        f << *i;
-                }
-                f << ']';
-
-                return f;
-        }
-
-        template<typename value, int inc, typename valuealloc>
-        ArchiveBase &operator<<( ArchiveBase &ar,
-                        const Array<value, inc, valuealloc> &h )
-        {
-                ar << h.getSize();
-                for( typename Array<value, inc, valuealloc>::const_iterator i =
-                         h.begin(); i != h.end(); i++ )
-                {
-                        ar << (*i);
-                }
-
-                return ar;
-        }
-
-        template<typename value, int inc, typename valuealloc>
-        ArchiveBase &operator>>(ArchiveBase &ar, Array<value, inc, valuealloc> &h )
-        {
-                h.clear();
-                long nSize;
-                ar >> nSize;
-
-                h.setCapacity( nSize );
-                for( long j = 0; j < nSize; j++ )
-                {
-                        value v;
-                        ar >> v;
-                        h.append( v );
-                }
-                return ar;
-        }
+    subExceptionDecl( ArrayException )
+
+    template<typename value, int inc, typename valuealloc>
+    class Array;
+
+    /** @cond DEVEL */
+    template<typename value, int inc, typename valuealloc>
+    class ArrayCore
+    {
+    friend class Array<value, inc, valuealloc>;
+    friend class SharedCore<
+        Array<value, inc, valuealloc>,
+        ArrayCore<value, inc, valuealloc>
+        >;
+    private:        
+        ArrayCore() :
+            pData( NULL ),
+            iSize( 0 ),
+            iCapacity( 0 )
+        { }
+
+        void setCapacity( int iNewLen )
+        {
+            //clear();
+            //iCapacity = iCapacity;
+            //pData = va.allocate( iCapacity );
+            if( iNewLen <= iCapacity ) return;
+            value *pNewData = va.allocate( iNewLen );
+            if( pData )
+            {
+                for( int j = 0; j < iSize; j++ )
+                {
+                    va.construct( &pNewData[j], pData[j] );
+                    va.destroy( &pData[j] );
+                }
+                va.deallocate( pData, iCapacity );
+            }
+            pData = pNewData;
+            iCapacity = iNewLen;
+        }
+
+        virtual ~ArrayCore()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            if( pData )
+            {
+                for( int j = 0; j < iSize; j++ )
+                {
+                    va.destroy( &pData[j] );
+                }
+                va.deallocate( pData, iCapacity );
+                pData = NULL;
+            }
+            iSize = 0;
+            iCapacity = 0;
+        }
+
+        void erase( int iPos )
+        {
+            for( int j = iPos; j < iSize; j++ )
+            {
+                va.destroy( &pData[j] );
+                if( j == iSize-1 )
+                {
+                    iSize--;
+                    return;
+                }
+                va.construct( &pData[j], pData[j+1] );
+            }
+        }
+
+        void swapErase( int iPos )
+        {
+            if( iPos == iSize-1 )
+            {
+                erase( iPos );
+                return;
+            }
+            va.destroy( &pData[iPos] );
+            va.construct( &pData[iPos], pData[iSize-1] );
+            va.destroy( &pData[iSize-1] );
+            iSize--;
+        }
+
+        valuealloc va;
+        value *pData;
+        long iSize;
+        long iCapacity;
+    };
+    /** @endcond */
+
+    /**
+     * Array type container, just like a normal array only flexible and keeps
+     * track of your memory for you.
+     *
+     *@param value (typename) The type of data to store in your list
+     *@param valuealloc (typename) Memory Allocator for your value type
+     *@param linkalloc (typename) Memory Allocator for the list links.
+     *@ingroup Containers
+     */
+    template<typename value, int inc=10, typename valuealloc=std::allocator<value> >
+    class Array : public SharedCore<
+                  Array<value, inc, valuealloc>,
+                  ArrayCore<value, inc, valuealloc>
+                  >
+    {
+    private:
+        typedef class Array<value, inc, valuealloc> MyType;
+        typedef class ArrayCore<value, inc, valuealloc> Core;
+
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_resetCore;
+        using SharedCore<MyType, Core>::_allocateCore;
+
+    public:
+        struct const_iterator;
+        struct iterator;
+
+        Array()
+        {
+        }
+
+        Array( const MyType &src ) :
+            SharedCore<MyType, Core >( src )
+        {
+        }
+        
+        Array( long iSetCap )
+        {
+            setCapacity( iSetCap );
+        }
+
+        ~Array()
+        {
+        }
+
+        bool operator==( const MyType &src ) const
+        {
+            if( core == src.core )
+                return true;
+            if( core->iSize != src.core->iSize )
+                return false;
+
+            for( int j = 0; j < core->iSize; j++ )
+            {
+                if( core->pData[j] != src.core->pData[j] )
+                    return false;
+            }
+            return true;
+        }
+
+        bool operator!=( const MyType &src ) const
+        {
+            return !(*this == src);
+        }
+
+        /**
+         * Clear the array.
+         */
+        void clear()
+        {
+            _resetCore();
+        }
+
+        MyType &append( const value &rVal )
+        {
+            _hardCopy();
+            if( core->iSize == core->iCapacity )
+            {
+                core->setCapacity( core->iCapacity + inc );
+            }
+
+            core->va.construct( &core->pData[core->iSize++], rVal );
+
+            return *this;
+        }
+        
+        MyType &append( const MyType &rVal )
+        {
+            _hardCopy();
+
+            if( core->iSize + rVal.core->iSize > core->iCapacity )
+            {
+                core->setCapacity( core->iSize + rVal.core->iSize + inc );
+            }
+            
+            for( int j = 0; j < rVal.core->iSize; j++ )
+            {
+                core->va.construct(
+                    &core->pData[core->iSize++],
+                    rVal.core->pData[j]
+                    );
+            }
+
+            return *this;
+        }
+
+        //operator
+        value &operator[]( long iIndex )
+        {
+            _hardCopy();
+            if( iIndex < 0 || iIndex >= core->iSize )
+                throw ArrayException(
+                    "Index %d out of range 0:%d", iIndex, core->iSize );
+
+            return core->pData[iIndex];
+        }
+        
+        const value &operator[]( long iIndex ) const
+        {
+            if( iIndex < 0 || iIndex >= core->iSize )
+                throw ArrayException(
+                    "Index %d out of range 0:%d", iIndex, core->iSize );
+
+            return core->pData[iIndex];
+        }
+
+        value &get( long iIndex )
+        {
+            _hardCopy();
+            if( iIndex < 0 || iIndex >= core->iSize )
+                throw ArrayException(
+                    "Index %d out of range 0:%d", iIndex, core->iSize );
+
+            return core->pData[iIndex];
+        }
+
+        const value &get( long iIndex ) const
+        {
+            if( iIndex < 0 || iIndex >= core->iSize )
+                throw ArrayException(
+                    "Index %d out of range 0:%d", iIndex, core->iSize );
+
+            return core->pData[iIndex];
+        }
+
+        value &first()
+        {
+            _hardCopy();
+            return core->pData[0];
+        }
+
+        const value &first() const
+        {
+            return core->pData[0];
+        }
+
+        value &last()
+        {
+            _hardCopy();
+            return core->pData[core->iSize-1];
+        }
+
+        const value &last() const
+        {
+            return core->pData[core->iSize-1];
+        }
+
+        /**
+         * Returns true if the array is empty.  The capacity has no bearing on
+         * this, only the size.
+         */
+        bool isEmpty() const
+        {
+            return core->iSize==0;
+        }
+
+        /**
+         * Get the current size of the array.
+         *@returns The current size of the array.
+         */
+        long getSize() const
+        {
+            return core->iSize;
+        }
+
+        /**
+         * Get the capacity of the array.  This number will grow as data is
+         * added, and is mainly for the curious, it doesn't really determine
+         * much for the end user.
+         *@returns The current capacity of the array.
+         */
+        long getCapacity() const
+        {
+            return core->iCapacity;
+        }
+
+        /**
+         * Change the capacity of the array, very useful if you know you'll be
+         * adding a large amount of already counted items to the array, makes
+         * the appending much faster afterwords.
+         *@param iNewLen The new capacity of the array.
+         *@todo Set this up so it can reduce the size of the array as well as
+         * make it bigger.
+         */
+        void setCapacity( long iNewLen )
+        {
+            _hardCopy();
+            core->setCapacity( iNewLen );
+        }
+
+        typedef struct iterator
+        {
+            friend class Array<value, inc, valuealloc>;
+        private:
+            iterator( MyType &src, long iPos=0 ) :
+                src( src ),
+                iPos( iPos )
+            {
+                if( this->iPos >= src.getSize() )
+                    this->iPos = -1;
+            }
+
+            MyType &src;
+            long iPos;
+
+        public:
+            iterator operator++( int )
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot increment iterator past end of array.");
+                    iPos++;
+                if( iPos >= src.getSize() )
+                    iPos = -1;
+                return *this;
+            }
+            
+            iterator operator++()
+            {
+                if( iPos >= 0 )
+                    iPos++;
+                if( iPos >= src.getSize() )
+                    iPos = -1;
+                return *this;
+            }
+            
+            iterator operator+( int iAmnt )
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot increment iterator past end of array.");
+                    iPos += iAmnt;
+                if( iPos >= src.getSize() )
+                    iPos = -1;
+                return *this;
+            }
+            
+            iterator operator--( int )
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot increment iterator past end of array.");
+                    iPos--;
+                if( iPos < 0 )
+                    iPos = -1;
+                return *this;
+            }
+            
+            iterator operator--()
+            {
+                if( iPos < src.getSize() )
+                    iPos--;
+                if( iPos <= 0 )
+                    iPos = -1;
+                return *this;
+            }
+            
+            iterator operator-( int iAmnt )
+            {
+                if( iPos < src.getSize() )
+                    iPos -= iAmnt;
+                if( iPos <= 0 )
+                    iPos = -1;
+                return *this;
+            }
+
+            bool operator==( const iterator &oth ) const
+            {
+                return iPos == oth.iPos;
+            }
+
+            bool operator!=( const iterator &oth ) const
+            {
+                return iPos != oth.iPos;
+            }
+
+            iterator operator=( const iterator &oth )
+            {
+                if( &src != &oth.src )
+                    throw ArrayException(
+                        "Cannot mix iterators from different array objects.");
+                iPos = oth.iPos;
+            }
+
+            value &operator*()
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot dereference finished iterator.");
+                return src[iPos];
+            }
+
+            long getIndex() const
+            {
+                return iPos;
+            }
+
+            operator bool() const
+            {
+                return iPos >= 0;
+            }
+
+            bool isValid() const
+            {
+                return iPos >= 0;
+            }
+        } iterator;
+        
+        typedef struct const_iterator
+        {
+            friend class Array<value, inc, valuealloc>;
+        private:
+            const_iterator( const MyType &src, long iPos=0 ) :
+                src( src ),
+                iPos( iPos )
+            {
+                if( this->iPos >= src.getSize() )
+                    this->iPos = -1;
+            }
+
+            const MyType &src;
+            long iPos;
+
+        public:
+            const_iterator( iterator &rSrc ) :
+                src( rSrc.src ),
+                iPos( rSrc.iPos )
+            {
+            }
+            const_iterator operator++( int )
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot increment iterator past end of array.");
+                    iPos++;
+                if( iPos >= src.getSize() )
+                    iPos = -1;
+                return *this;
+            }
+            
+            const_iterator operator++()
+            {
+                if( iPos >= 0 )
+                    iPos++;
+                if( iPos >= src.getSize() )
+                    iPos = -1;
+                return *this;
+            }
+            
+            const_iterator operator--( int )
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot increment iterator past end of array.");
+                    iPos--;
+                if( iPos < 0 )
+                    iPos = -1;
+                return *this;
+            }
+            
+            const_iterator operator--()
+            {
+                if( iPos < src.getSize() )
+                    iPos--;
+                if( iPos <= 0 )
+                    iPos = -1;
+                return *this;
+            }
+
+            bool operator==( const const_iterator &oth ) const
+            {
+                return iPos == oth.iPos;
+            }
+
+            bool operator!=( const const_iterator &oth ) const
+            {
+                return iPos != oth.iPos;
+            }
+
+            const_iterator operator=( const const_iterator &oth )
+            {
+                if( &src != &oth.src )
+                    throw ArrayException(
+                        "Cannot mix iterators from different array objects.");
+                iPos = oth.iPos;
+            }
+
+            const value &operator*() const
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot dereference finished iterator.");
+                return src[iPos];
+            }
+
+            long getIndex() const
+            {
+                return iPos;
+            }
+            
+            operator bool() const
+            {
+                return iPos >= 0;
+            }
+
+            bool isValid() const
+            {
+                return iPos >= 0;
+            }
+        } const_iterator;
+
+        iterator begin()
+        {
+            return iterator( *this );
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator( *this );
+        }
+
+        iterator end()
+        {
+            return iterator( *this, -1 );
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator( *this, -1 );
+        }
+
+        MyType &insert( iterator i, const value &rVal )
+        {
+            if( i.iPos == -1 )
+            {
+                append( rVal );
+                return *this;
+            }
+
+            _hardCopy();
+            if( core->iSize == core->iCapacity )
+            {
+                core->setCapacity( core->iCapacity + inc );
+            }
+            core->iSize++;
+
+            core->va.construct(
+                &core->pData[core->iSize-1],
+                core->pData[core->iSize-2]
+                );
+            for( int iPos = core->iSize-2; iPos > i.iPos; iPos-- )
+            {
+                core->va.destroy( &core->pData[iPos] );
+                core->va.construct( &core->pData[iPos], core->pData[iPos-1] );
+            }
+            core->va.destroy( &core->pData[i.iPos] );
+            core->va.construct( &core->pData[i.iPos], rVal );
+
+            return *this;
+        }
+
+        /**
+         * If order is important, use this.  It will delete the suggested item
+         * and move the rest of the data up a spot.  This is a time O(n)
+         * operation.  If the order isn't important, check swapErase
+         */
+        void erase( iterator i )
+        {
+            _hardCopy();
+            core->erase( i.iPos );
+        }
+
+        void erase( const value &v )
+        {
+            _hardCopy();
+            for( int j = 0; j < core->iSize; j++ )
+            {
+                if( core->pData[j] == v )
+                {
+                    core->erase( j );
+                    return;
+                }
+            }
+        }
+
+        void eraseLast()
+        {
+            _hardCopy();
+            core->erase( core->iSize-1 );
+        }
+
+        void eraseFirst()
+        {
+            _hardCopy();
+            core->erase( 0 );
+        }
+
+        /**
+         * In order to make swapErase faster, what it does is swap the given
+         * item in the array with the last item, then make the array shorter
+         * by one.  It changes the order of the elements in the array, so it
+         * should be used carefully, but it is time O(1) instead of O(n) like
+         * erase.
+         */
+        void swapErase( iterator i )
+        {
+            _hardCopy();
+            core->swapErase( i.iPos );
+        }
+
+    protected:
+        virtual Core *_copyCore( Core *src )
+        {
+            Core *pRet = _allocateCore();
+            pRet->setCapacity( src->iCapacity );
+            pRet->iSize = src->iSize;
+            for( int j = 0; j < src->iSize; j++ )
+            {   
+                pRet->va.construct( &pRet->pData[j], src->pData[j] );
+            }
+            return pRet;
+        }
+
+    private:
+    };
+
+    class Formatter;
+    Formatter &operator<<( Formatter &rOut, char *sStr );
+    Formatter &operator<<( Formatter &rOut, signed char c );
+    template<typename value>
+    Formatter &operator<<( Formatter &f, const Bu::Array<value> &a )
+    {
+        f << '[';
+        for( typename Bu::Array<value>::const_iterator i = a.begin(); i; i++ )
+        {
+            if( i != a.begin() )
+                f << ", ";
+            f << *i;
+        }
+        f << ']';
+
+        return f;
+    }
+
+    template<typename value, int inc, typename valuealloc>
+    ArchiveBase &operator<<( ArchiveBase &ar,
+            const Array<value, inc, valuealloc> &h )
+    {
+        ar << h.getSize();
+        for( typename Array<value, inc, valuealloc>::const_iterator i =
+             h.begin(); i != h.end(); i++ )
+        {
+            ar << (*i);
+        }
+
+        return ar;
+    }
+
+    template<typename value, int inc, typename valuealloc>
+    ArchiveBase &operator>>(ArchiveBase &ar, Array<value, inc, valuealloc> &h )
+    {
+        h.clear();
+        long nSize;
+        ar >> nSize;
+
+        h.setCapacity( nSize );
+        for( long j = 0; j < nSize; j++ )
+        {
+            value v;
+            ar >> v;
+            h.append( v );
+        }
+        return ar;
+    }
 
 }
 
diff --git a/src/stable/atom.h b/src/stable/atom.h
index 105c29a..9679ab6 100644
--- a/src/stable/atom.h
+++ b/src/stable/atom.h
@@ -15,133 +15,133 @@
 
 namespace Bu
 {
-        /**
-         *
-         *@ingroup Containers
-         */
-        template <typename t, typename talloc=std::allocator<t> >
-        class Atom
-        {
-        private:
-                typedef struct Atom<t, talloc> MyType;
-
-        public:
-                Atom() :
-                        pData( NULL )
-                {
-                }
-
-                Atom( const MyType &oth ) :
-                        pData( NULL )
-                {
-                        if( oth.pData )
-                                set( *oth.pData );
-                }
-
-                Atom( const t &oth ) :
-                        pData( NULL )
-                {
-                        set( oth );
-                }
-
-                virtual ~Atom()
-                {
-                        clear();
-                }
-
-                bool has() const
-                {
-                        return (pData != NULL);
-                }
-
-                void set( const t &val )
-                {
-                        clear();
-                        pData = ta.allocate( 1 );
-                        ta.construct( pData, val );
-                }
-
-                t &get()
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return *pData;
-                }
-
-                const t &get() const
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return *pData;
-                }
-
-                void clear()
-                {
-                        if( pData )
-                        {
-                                ta.destroy( pData );
-                                ta.deallocate( pData, 1 );
-                                pData = NULL;
-                        }
-                }
-
-                operator const t &() const
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return *pData;
-                }
-                
-                operator t &()
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return *pData;
-                }
-
-                MyType &operator =( const t &oth )
-                {
-                        set( oth );
-
-                        return *this;
-                }
-                
-                MyType &operator =( const MyType &oth )
-                {
-                        if( oth.pData )
-                                set( *oth.pData );
-
-                        return *this;
-                }
-                
-                bool operator ==( const MyType &oth )
-                {
-                        return (*pData) == (*oth.pData);
-                }
-
-                bool operator ==( const t &oth )
-                {
-                        return (*pData) == oth;
-                }
-
-                t *operator ->()
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return pData;
-                }
-
-                t &operator *()
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return *pData;
-                }
-
-        private:
-                t *pData;
-                talloc ta;
-        };
+    /**
+     *
+     *@ingroup Containers
+     */
+    template <typename t, typename talloc=std::allocator<t> >
+    class Atom
+    {
+    private:
+        typedef struct Atom<t, talloc> MyType;
+
+    public:
+        Atom() :
+            pData( NULL )
+        {
+        }
+
+        Atom( const MyType &oth ) :
+            pData( NULL )
+        {
+            if( oth.pData )
+                set( *oth.pData );
+        }
+
+        Atom( const t &oth ) :
+            pData( NULL )
+        {
+            set( oth );
+        }
+
+        virtual ~Atom()
+        {
+            clear();
+        }
+
+        bool has() const
+        {
+            return (pData != NULL);
+        }
+
+        void set( const t &val )
+        {
+            clear();
+            pData = ta.allocate( 1 );
+            ta.construct( pData, val );
+        }
+
+        t &get()
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return *pData;
+        }
+
+        const t &get() const
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return *pData;
+        }
+
+        void clear()
+        {
+            if( pData )
+            {
+                ta.destroy( pData );
+                ta.deallocate( pData, 1 );
+                pData = NULL;
+            }
+        }
+
+        operator const t &() const
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return *pData;
+        }
+        
+        operator t &()
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return *pData;
+        }
+
+        MyType &operator =( const t &oth )
+        {
+            set( oth );
+
+            return *this;
+        }
+        
+        MyType &operator =( const MyType &oth )
+        {
+            if( oth.pData )
+                set( *oth.pData );
+
+            return *this;
+        }
+        
+        bool operator ==( const MyType &oth )
+        {
+            return (*pData) == (*oth.pData);
+        }
+
+        bool operator ==( const t &oth )
+        {
+            return (*pData) == oth;
+        }
+
+        t *operator ->()
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return pData;
+        }
+
+        t &operator *()
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return *pData;
+        }
+
+    private:
+        t *pData;
+        talloc ta;
+    };
 }
 
 #endif
diff --git a/src/stable/base64.cpp b/src/stable/base64.cpp
index 5ace999..2dc123f 100644
--- a/src/stable/base64.cpp
+++ b/src/stable/base64.cpp
@@ -10,210 +10,210 @@
 namespace Bu { subExceptionDef( Base64Exception ) }
 
 const char Bu::Base64::tblEnc[65] = {
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 };
 
 Bu::Base64::Base64( Bu::Stream &rNext, int iChunkSize ) :
-        Bu::Filter( rNext ),
-        iBPos( 0 ),
-        iBuf( 0 ),
-        iRPos( 0 ),
-        iChars( 0 ),
-        bEosIn( false ),
-        iTotalIn( 0 ),
-        iTotalOut( 0 ),
-        eMode( Nothing ),
-        iChunkSize( iChunkSize ),
-        iCurChunk( 0 )
+    Bu::Filter( rNext ),
+    iBPos( 0 ),
+    iBuf( 0 ),
+    iRPos( 0 ),
+    iChars( 0 ),
+    bEosIn( false ),
+    iTotalIn( 0 ),
+    iTotalOut( 0 ),
+    eMode( Nothing ),
+    iChunkSize( iChunkSize ),
+    iCurChunk( 0 )
 {
-        start();
-
-        memset( tblDec, 0, 80 );
-        for( int j = 0; j < 64; j++ )
-        {
-                tblDec[tblEnc[j]-'+'] = j;
-        //      printf("'%c' = %d\n", tblEnc[j], j );
-        }
-        /*
-        for( int j = 0; j < 64; j++ )
-        {
-                printf("'%c' = '%c' (%d = %d)\n",
-                        tblEnc[j], tblEnc[tblDec[tblEnc[j]-'+']],
-                        j, tblDec[tblEnc[j]-'+'] );
-        }*/
-
-        // The following is used to compute the table size for the decoding table.
-        /*
-        char low='A', high='A';
-        for( int j = 0; j < 64; j++ )
-        {
-                if( tblEnc[j] < low )
-                        low = tblEnc[j];
-                if( tblEnc[j] > high )
-                        high = tblEnc[j];
-        }
-
-        printf("'%c' - '%c' (%d - %d) (%d)\n", low, high, low, high, high-low );
-        */
+    start();
+
+    memset( tblDec, 0, 80 );
+    for( int j = 0; j < 64; j++ )
+    {
+        tblDec[tblEnc[j]-'+'] = j;
+    //  printf("'%c' = %d\n", tblEnc[j], j );
+    }
+    /*
+    for( int j = 0; j < 64; j++ )
+    {
+        printf("'%c' = '%c' (%d = %d)\n",
+            tblEnc[j], tblEnc[tblDec[tblEnc[j]-'+']],
+            j, tblDec[tblEnc[j]-'+'] );
+    }*/
+
+    // The following is used to compute the table size for the decoding table.
+    /*
+    char low='A', high='A';
+    for( int j = 0; j < 64; j++ )
+    {
+        if( tblEnc[j] < low )
+            low = tblEnc[j];
+        if( tblEnc[j] > high )
+            high = tblEnc[j];
+    }
+
+    printf("'%c' - '%c' (%d - %d) (%d)\n", low, high, low, high, high-low );
+    */
 }
 
 Bu::Base64::~Base64()
 {
-        stop();
+    stop();
 }
 
 void Bu::Base64::start()
 {
-        iCurChunk = 0;
+    iCurChunk = 0;
 }
 
 Bu::size Bu::Base64::stop()
 {
-        if( eMode == Encode )
-        {
-                char outBuf[4];
-                int iBUsed = 4-(3-iBPos);
-                if( iBPos == 0 )
-                        return iTotalOut;
-                for( int k = 0; k < 4; k++ )
-                {
-                        outBuf[3-k] = tblEnc[(iBuf>>(6*k))&0x3f];
-                }
-                for( int k = iBUsed; k < 4; k++ )
-                {
-                        outBuf[k] = '=';
-                }
-                iCurChunk += 4;
-                if( iChunkSize && iCurChunk >= iChunkSize )
-                {
-                        iCurChunk = iCurChunk-iChunkSize;
-                        iTotalOut += rNext.write( outBuf, 4-iCurChunk );
-                        iTotalOut += rNext.write("\r\n", 2 );
-                        iTotalOut += rNext.write( outBuf+(4-iCurChunk), iCurChunk );
-                }
-                else
-                        iTotalOut += rNext.write( outBuf, 4 );
-                return iTotalOut;
-        }
-        else
-        {
-                return iTotalIn;
-        }
+    if( eMode == Encode )
+    {
+        char outBuf[4];
+        int iBUsed = 4-(3-iBPos);
+        if( iBPos == 0 )
+            return iTotalOut;
+        for( int k = 0; k < 4; k++ )
+        {
+            outBuf[3-k] = tblEnc[(iBuf>>(6*k))&0x3f];
+        }
+        for( int k = iBUsed; k < 4; k++ )
+        {
+            outBuf[k] = '=';
+        }
+        iCurChunk += 4;
+        if( iChunkSize && iCurChunk >= iChunkSize )
+        {
+            iCurChunk = iCurChunk-iChunkSize;
+            iTotalOut += rNext.write( outBuf, 4-iCurChunk );
+            iTotalOut += rNext.write("\r\n", 2 );
+            iTotalOut += rNext.write( outBuf+(4-iCurChunk), iCurChunk );
+        }
+        else
+            iTotalOut += rNext.write( outBuf, 4 );
+        return iTotalOut;
+    }
+    else
+    {
+        return iTotalIn;
+    }
 }
 
 Bu::size Bu::Base64::read( void *pBuf, Bu::size nBytes )
 {
-        if( eMode == Encode )
-                throw Bu::Base64Exception("Cannot read from an output stream.");
-        eMode = Decode;
-
-        if( bEosIn == true && iRPos == iChars )
-                return 0;
-        Bu::size sIn = 0;
-        char buf[4];
-        while( sIn < nBytes )
-        {
-                for(; iRPos < iChars && sIn < nBytes; iRPos++, sIn++ )
-                {
-                        ((unsigned char *)pBuf)[sIn] = (iBuf>>(8*(2-iRPos)))&0xFF;
-                }
-                if( iRPos == iChars )
-                {
-                        if( bEosIn == true )
-                                return sIn;
-                        else
-                                iRPos = 0;
-                }
-                else if( sIn == nBytes )
-                        return sIn;
-                //if( rNext.read( buf, 4 ) == 0 )
-                //      return sIn;
-                for( int j = 0; j < 4; j++ )
-                {
-                        if( rNext.read( &buf[j], 1 ) == 0 )
-                        {
-                                if( rNext.isEos() )
-                                {
-                                        if( iRPos == 0 )
-                                                iRPos = iChars;
-                                        bEosIn = true;
-                                        if( j != 0 )
-                                        {
-                                                throw Base64Exception(
-                                                        "Premature end of stream detected while "
-                                                        "decoding Base64 data."
-                                                        );
-                                        }
-                                }
-                                return sIn;
-                        }
-                        if( buf[j] == ' ' || buf[j] == '\t' ||
-                                buf[j] == '\n' || buf[j] == '\r' )
-                        {
-                                j--;
-                        }
-                }
-                iChars = 3;
-                iBuf = 0;
-                for( int j = 0; j < 4; j++ )
-                {
-                        if( buf[j] == '=' )
-                        {
-                                iChars--;
-                                bEosIn = true;
-                        }
-                        else
-                                iBuf |= (tblDec[buf[j]-'+']&0x3f)<<((3-j)*6);
-                        //printf("%d:  %06X (%02X)\n", j, iBuf, (tblDec[buf[j]-'+']&0x3f) );
-                }
-        }
-
-        return sIn;
+    if( eMode == Encode )
+        throw Bu::Base64Exception("Cannot read from an output stream.");
+    eMode = Decode;
+
+    if( bEosIn == true && iRPos == iChars )
+        return 0;
+    Bu::size sIn = 0;
+    char buf[4];
+    while( sIn < nBytes )
+    {
+        for(; iRPos < iChars && sIn < nBytes; iRPos++, sIn++ )
+        {
+            ((unsigned char *)pBuf)[sIn] = (iBuf>>(8*(2-iRPos)))&0xFF;
+        }
+        if( iRPos == iChars )
+        {
+            if( bEosIn == true )
+                return sIn;
+            else
+                iRPos = 0;
+        }
+        else if( sIn == nBytes )
+            return sIn;
+        //if( rNext.read( buf, 4 ) == 0 )
+        //  return sIn;
+        for( int j = 0; j < 4; j++ )
+        {
+            if( rNext.read( &buf[j], 1 ) == 0 )
+            {
+                if( rNext.isEos() )
+                {
+                    if( iRPos == 0 )
+                        iRPos = iChars;
+                    bEosIn = true;
+                    if( j != 0 )
+                    {
+                        throw Base64Exception(
+                            "Premature end of stream detected while "
+                            "decoding Base64 data."
+                            );
+                    }
+                }
+                return sIn;
+            }
+            if( buf[j] == ' ' || buf[j] == '\t' ||
+                buf[j] == '\n' || buf[j] == '\r' )
+            {
+                j--;
+            }
+        }
+        iChars = 3;
+        iBuf = 0;
+        for( int j = 0; j < 4; j++ )
+        {
+            if( buf[j] == '=' )
+            {
+                iChars--;
+                bEosIn = true;
+            }
+            else
+                iBuf |= (tblDec[buf[j]-'+']&0x3f)<<((3-j)*6);
+            //printf("%d:  %06X (%02X)\n", j, iBuf, (tblDec[buf[j]-'+']&0x3f) );
+        }
+    }
+
+    return sIn;
 }
 
 Bu::size Bu::Base64::write( const void *pBuf, Bu::size nBytes )
 {
-        if( eMode == Decode )
-                throw Bu::Base64Exception("Cannot write to an input stream.");
-        eMode = Encode;
-
-        Bu::size sOut = 0;
-        char outBuf[4];
-        for( Bu::size j = 0; j < nBytes; j++ )
-        {
-                iBuf |= (((uint8_t *)pBuf)[j])<<((2-iBPos++)*8);
-                if( iBPos == 3 )
-                {
-                        for( int k = 0; k < 4; k++ )
-                        {
-                                outBuf[3-k] = tblEnc[(iBuf>>(6*k))&0x3f];
-                        }
-                        iCurChunk += 4;
-                        if( iChunkSize && iCurChunk >= iChunkSize )
-                        {
-                                iCurChunk = iCurChunk-iChunkSize;
-                                sOut += rNext.write( outBuf, 4-iCurChunk );
-                                sOut += rNext.write("\r\n", 2 );
-                                sOut += rNext.write( outBuf+(4-iCurChunk), iCurChunk );
-                        }
-                        else
-                                sOut += rNext.write( outBuf, 4 );
-                        iBPos = iBuf = 0;
-                }
-        }
-        iTotalOut += sOut;
-        return sOut;
+    if( eMode == Decode )
+        throw Bu::Base64Exception("Cannot write to an input stream.");
+    eMode = Encode;
+
+    Bu::size sOut = 0;
+    char outBuf[4];
+    for( Bu::size j = 0; j < nBytes; j++ )
+    {
+        iBuf |= (((uint8_t *)pBuf)[j])<<((2-iBPos++)*8);
+        if( iBPos == 3 )
+        {
+            for( int k = 0; k < 4; k++ )
+            {
+                outBuf[3-k] = tblEnc[(iBuf>>(6*k))&0x3f];
+            }
+            iCurChunk += 4;
+            if( iChunkSize && iCurChunk >= iChunkSize )
+            {
+                iCurChunk = iCurChunk-iChunkSize;
+                sOut += rNext.write( outBuf, 4-iCurChunk );
+                sOut += rNext.write("\r\n", 2 );
+                sOut += rNext.write( outBuf+(4-iCurChunk), iCurChunk );
+            }
+            else
+                sOut += rNext.write( outBuf, 4 );
+            iBPos = iBuf = 0;
+        }
+    }
+    iTotalOut += sOut;
+    return sOut;
 }
 
 bool Bu::Base64::isOpen()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Base64::isEos()
 {
-        if( bEosIn == true && iRPos == iChars )
-                return true;
-        return false;
+    if( bEosIn == true && iRPos == iChars )
+        return true;
+    return false;
 }
 
diff --git a/src/stable/base64.h b/src/stable/base64.h
index b10aaeb..695a5ea 100644
--- a/src/stable/base64.h
+++ b/src/stable/base64.h
@@ -13,47 +13,47 @@
 
 namespace Bu
 {
-        subExceptionDecl( Base64Exception );
-        
-        /**
-         *
-         *@ingroup Streams
-         */
-        class Base64 : public Bu::Filter
-        {
-        public:
-                Base64( Bu::Stream &rNext, int iChunkSize=0 );
-                virtual ~Base64();
-
-                virtual void start();
-                virtual Bu::size stop();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-
-                virtual bool isOpen();
-
-                virtual bool isEos();
-
-        private:
-                int iBPos;
-                int iBuf;
-                int iRPos;
-                int iChars;
-                bool bEosIn;
-                Bu::size iTotalIn;
-                Bu::size iTotalOut;
-                static const char tblEnc[65];
-                char tblDec[80];
-                enum Mode
-                {
-                        Nothing         = 0x00,
-                        Encode          = 0x01,
-                        Decode          = 0x02,
-                };
-                Mode eMode;
-                int iChunkSize;
-                int iCurChunk;
-        };
+    subExceptionDecl( Base64Exception );
+    
+    /**
+     *
+     *@ingroup Streams
+     */
+    class Base64 : public Bu::Filter
+    {
+    public:
+        Base64( Bu::Stream &rNext, int iChunkSize=0 );
+        virtual ~Base64();
+
+        virtual void start();
+        virtual Bu::size stop();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+        virtual bool isOpen();
+
+        virtual bool isEos();
+
+    private:
+        int iBPos;
+        int iBuf;
+        int iRPos;
+        int iChars;
+        bool bEosIn;
+        Bu::size iTotalIn;
+        Bu::size iTotalOut;
+        static const char tblEnc[65];
+        char tblDec[80];
+        enum Mode
+        {
+            Nothing     = 0x00,
+            Encode      = 0x01,
+            Decode      = 0x02,
+        };
+        Mode eMode;
+        int iChunkSize;
+        int iCurChunk;
+    };
 };
 
 #endif
diff --git a/src/stable/buffer.cpp b/src/stable/buffer.cpp
index 16c3e2f..c787499 100644
--- a/src/stable/buffer.cpp
+++ b/src/stable/buffer.cpp
@@ -8,26 +8,26 @@
 #include "bu/buffer.h"
 
 Bu::Buffer::Buffer( Bu::Stream &rNext, int iWhat, int iBufSize ) :
-        Bu::Filter( rNext ),
-        sSoFar( 0 ),
-        iBufSize( iBufSize ),
-        sReadBuf( NULL ),
-        sWriteBuf( NULL ),
-        iReadBufFill( 0 ),
-        iReadPos( 0 ),
-        iWriteBufFill( 0 ),
-        iWritePos( 0 ),
-        iWhat( iWhat )
+    Bu::Filter( rNext ),
+    sSoFar( 0 ),
+    iBufSize( iBufSize ),
+    sReadBuf( NULL ),
+    sWriteBuf( NULL ),
+    iReadBufFill( 0 ),
+    iReadPos( 0 ),
+    iWriteBufFill( 0 ),
+    iWritePos( 0 ),
+    iWhat( iWhat )
 {
-        sReadBuf = new char[iBufSize];
-        sWriteBuf = new char[iBufSize];
+    sReadBuf = new char[iBufSize];
+    sWriteBuf = new char[iBufSize];
 }
 
 Bu::Buffer::~Buffer()
 {
-        flush();
-        delete[] sReadBuf;
-        delete[] sWriteBuf;
+    flush();
+    delete[] sReadBuf;
+    delete[] sWriteBuf;
 }
 
 void Bu::Buffer::start()
@@ -36,135 +36,135 @@ void Bu::Buffer::start()
 
 Bu::size Bu::Buffer::stop()
 {
-        flush();
-        iReadBufFill = iReadPos = iWriteBufFill = iWritePos = 0;
-        return sSoFar;
+    flush();
+    iReadBufFill = iReadPos = iWriteBufFill = iWritePos = 0;
+    return sSoFar;
 }
 
 void Bu::Buffer::fillReadBuf()
 {
-        if( iReadBufFill+iReadPos < iBufSize )
-        {
-                iReadBufFill += rNext.read(
-                        sReadBuf+iReadPos+iReadBufFill,
-                        iBufSize-iReadBufFill-iReadPos
-                        );
-        }
+    if( iReadBufFill+iReadPos < iBufSize )
+    {
+        iReadBufFill += rNext.read(
+            sReadBuf+iReadPos+iReadBufFill,
+            iBufSize-iReadBufFill-iReadPos
+            );
+    }
 }
 
 Bu::size Bu::Buffer::read( void *pBuf, Bu::size nBytes )
 {
-        if( (iWhat&Read) == 0 )
-                return rNext.read( pBuf, nBytes );
-
-        if( nBytes <= 0 )
-        {
-                fillReadBuf();
-                return 0;
-        }
-
-        Bu::size nTotRead = 0;
-//      fillReadBuf();
-
-        do
-        {
-                int iAmnt = nBytes-nTotRead;
-                if( iAmnt > iReadBufFill )
-                {
-                        iAmnt = iReadBufFill;
-                }
-                if( iAmnt > 0 )
-                {
-                        memcpy( ((char *)pBuf)+nTotRead, sReadBuf+iReadPos, iAmnt );
-                        iReadPos += iAmnt;
-                        nTotRead += iAmnt;
-                        iReadBufFill -= iAmnt;
-                }
-                if( iReadBufFill == 0 )
-                {
-                        iReadPos = 0;
-                        fillReadBuf();
-                }
-        }
-        while( nTotRead < nBytes && iReadBufFill > 0 );
-
-        //printf("Buffer:  %db returned, %db remain in buffer.\n", nTotRead, iReadBufFill );
-
-        return nTotRead;
+    if( (iWhat&Read) == 0 )
+        return rNext.read( pBuf, nBytes );
+
+    if( nBytes <= 0 )
+    {
+        fillReadBuf();
+        return 0;
+    }
+
+    Bu::size nTotRead = 0;
+//  fillReadBuf();
+
+    do
+    {
+        int iAmnt = nBytes-nTotRead;
+        if( iAmnt > iReadBufFill )
+        {
+            iAmnt = iReadBufFill;
+        }
+        if( iAmnt > 0 )
+        {
+            memcpy( ((char *)pBuf)+nTotRead, sReadBuf+iReadPos, iAmnt );
+            iReadPos += iAmnt;
+            nTotRead += iAmnt;
+            iReadBufFill -= iAmnt;
+        }
+        if( iReadBufFill == 0 )
+        {
+            iReadPos = 0;
+            fillReadBuf();
+        }
+    }
+    while( nTotRead < nBytes && iReadBufFill > 0 );
+
+    //printf("Buffer:  %db returned, %db remain in buffer.\n", nTotRead, iReadBufFill );
+
+    return nTotRead;
 }
 
 Bu::size Bu::Buffer::write( const void *pBuf, Bu::size nBytes )
 {
-        if( (iWhat&Write) == 0 )
-                return rNext.write( pBuf, nBytes );
-
-        Bu::size nTotWrote = 0;
-
-        do
-        {
-                int iAmnt = nBytes-nTotWrote;
-                if( iAmnt > iBufSize-iWritePos-iWriteBufFill )
-                {
-                        iAmnt = iBufSize-iWritePos-iWriteBufFill;
-                }
-                if( iAmnt > 0 )
-                {
-                        memcpy(
-                                sWriteBuf+iWritePos+iWriteBufFill,
-                                ((char *)pBuf)+nTotWrote,
-                                iAmnt
-                                );
-                        nTotWrote += iAmnt;
-                        iWriteBufFill += iAmnt;
-                        //printf("Buffer: Moved %db to write buffer, %db filled now.\n",
-                                        //iAmnt, iWriteBufFill );
-                }
-                while( iWritePos+iWriteBufFill == iBufSize )
-                {
-                        //printf("iWritePos = %d\n", iWritePos );
-                        int iWr = rNext.write( sWriteBuf+iWritePos, iWriteBufFill );
-                        //printf("Buffer: Wrote %db from buffer to stream, %db filled now.\n", iWr, iWriteBufFill-iWr );
-                        if( iWr == 0 )
-                        {
-                                return nTotWrote;
-                        }
-                        else if( iWr == iWriteBufFill )
-                        {
-                                iWritePos = iWriteBufFill = 0;
-                        }
-                        else
-                        {
-                                iWritePos += iWr;
-                                iWriteBufFill -= iWr;
-                        }
-                }
-        }
-        while( nTotWrote < nBytes && iWriteBufFill < iBufSize+iWritePos );
-
-        return nTotWrote;
+    if( (iWhat&Write) == 0 )
+        return rNext.write( pBuf, nBytes );
+
+    Bu::size nTotWrote = 0;
+
+    do
+    {
+        int iAmnt = nBytes-nTotWrote;
+        if( iAmnt > iBufSize-iWritePos-iWriteBufFill )
+        {
+            iAmnt = iBufSize-iWritePos-iWriteBufFill;
+        }
+        if( iAmnt > 0 )
+        {
+            memcpy(
+                sWriteBuf+iWritePos+iWriteBufFill,
+                ((char *)pBuf)+nTotWrote,
+                iAmnt
+                );
+            nTotWrote += iAmnt;
+            iWriteBufFill += iAmnt;
+            //printf("Buffer: Moved %db to write buffer, %db filled now.\n",
+                    //iAmnt, iWriteBufFill );
+        }
+        while( iWritePos+iWriteBufFill == iBufSize )
+        {
+            //printf("iWritePos = %d\n", iWritePos );
+            int iWr = rNext.write( sWriteBuf+iWritePos, iWriteBufFill );
+            //printf("Buffer: Wrote %db from buffer to stream, %db filled now.\n", iWr, iWriteBufFill-iWr );
+            if( iWr == 0 )
+            {
+                return nTotWrote;
+            }
+            else if( iWr == iWriteBufFill )
+            {
+                iWritePos = iWriteBufFill = 0;
+            }
+            else
+            {
+                iWritePos += iWr;
+                iWriteBufFill -= iWr;
+            }
+        }
+    }
+    while( nTotWrote < nBytes && iWriteBufFill < iBufSize+iWritePos );
+
+    return nTotWrote;
 }
 
 void Bu::Buffer::flush()
 {
-        if( (iWhat&Write) == 0 )
-                return rNext.flush();
-
-        if( iWriteBufFill > 0 )
-        {
-                //printf("Buffer: Flushing remaining data, %db.\n", iWriteBufFill );
-                int iWr = 0;
-                do
-                {
-                        iWr = rNext.write( sWriteBuf+iWritePos, iWriteBufFill );
-                        //printf("Buffer: %db written to stream.\n", iWr );
-                        iWritePos += iWr;
-                        iWriteBufFill -= iWr;
-                } while( iWriteBufFill > 0 && iWr > 0 );
-        }
+    if( (iWhat&Write) == 0 )
+        return rNext.flush();
+
+    if( iWriteBufFill > 0 )
+    {
+        //printf("Buffer: Flushing remaining data, %db.\n", iWriteBufFill );
+        int iWr = 0;
+        do
+        {
+            iWr = rNext.write( sWriteBuf+iWritePos, iWriteBufFill );
+            //printf("Buffer: %db written to stream.\n", iWr );
+            iWritePos += iWr;
+            iWriteBufFill -= iWr;
+        } while( iWriteBufFill > 0 && iWr > 0 );
+    }
 }
 
 bool Bu::Buffer::isEos()
 {
-        return (iReadPos >= (iReadBufFill-1)) && (rNext.isEos());
+    return (iReadPos >= (iReadBufFill-1)) && (rNext.isEos());
 }
 
diff --git a/src/stable/buffer.h b/src/stable/buffer.h
index a8303fa..21a5812 100644
--- a/src/stable/buffer.h
+++ b/src/stable/buffer.h
@@ -12,47 +12,47 @@
 
 namespace Bu
 {
-        class Buffer : public Bu::Filter
-        {
-        public:
-                Buffer( Bu::Stream &rNext, int iWhat=Both, int iBufSize=4096 );
-                virtual ~Buffer();
-
-                enum
-                {
-                        Write   = 1,
-                        Read    = 2,
-                        Both    = 3
-                };
-
-                virtual void start();
-                virtual Bu::size stop();
-
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
-
-                Bu::size getReadFill() { return iReadBufFill; }
-                bool isWritePending() { return iWriteBufFill > 0; }
-
-                virtual void flush();
-
-                virtual bool isEos();
-
-        private:
-                void fillReadBuf();
-
-        private:
-                Bu::size sSoFar;
-                int iBufSize;
-                char *sReadBuf;
-                char *sWriteBuf;
-                int iReadBufFill;
-                int iReadPos;
-                int iWriteBufFill;
-                int iWritePos;
-                int iWhat;
-        };
+    class Buffer : public Bu::Filter
+    {
+    public:
+        Buffer( Bu::Stream &rNext, int iWhat=Both, int iBufSize=4096 );
+        virtual ~Buffer();
+
+        enum
+        {
+            Write   = 1,
+            Read    = 2,
+            Both    = 3
+        };
+
+        virtual void start();
+        virtual Bu::size stop();
+
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
+
+        Bu::size getReadFill() { return iReadBufFill; }
+        bool isWritePending() { return iWriteBufFill > 0; }
+
+        virtual void flush();
+
+        virtual bool isEos();
+
+    private:
+        void fillReadBuf();
+
+    private:
+        Bu::size sSoFar;
+        int iBufSize;
+        char *sReadBuf;
+        char *sWriteBuf;
+        int iReadBufFill;
+        int iReadPos;
+        int iWriteBufFill;
+        int iWritePos;
+        int iWhat;
+    };
 };
 
 #endif
diff --git a/src/stable/bzip2.cpp b/src/stable/bzip2.cpp
index 11b8873..5e660d0 100644
--- a/src/stable/bzip2.cpp
+++ b/src/stable/bzip2.cpp
@@ -15,222 +15,222 @@
 using namespace Bu;
 
 Bu::BZip2::BZip2( Bu::Stream &rNext, int nCompression ) :
-        Bu::Filter( rNext ),
-        prState( NULL ),
-        nCompression( nCompression ),
-        sTotalOut( 0 )
+    Bu::Filter( rNext ),
+    prState( NULL ),
+    nCompression( nCompression ),
+    sTotalOut( 0 )
 {
-        TRACE( nCompression );
-        start();
+    TRACE( nCompression );
+    start();
 }
 
 Bu::BZip2::~BZip2()
 {
-        TRACE();
-        stop();
+    TRACE();
+    stop();
 }
 
 void Bu::BZip2::start()
 {
-        TRACE();
+    TRACE();
 
-        prState = new bz_stream;
-        pState->state = NULL;
-        pState->bzalloc = NULL;
-        pState->bzfree = NULL;
-        pState->opaque = NULL;
+    prState = new bz_stream;
+    pState->state = NULL;
+    pState->bzalloc = NULL;
+    pState->bzfree = NULL;
+    pState->opaque = NULL;
 
-        nBufSize = 64*1024;
-        pBuf = new char[nBufSize];
+    nBufSize = 64*1024;
+    pBuf = new char[nBufSize];
 }
 
 Bu::size Bu::BZip2::stop()
 {
-        TRACE();
-        if( !pState )
-                return 0;
-
-        if( pState->state )
-        {
-                if( bReading )
-                {
-                        BZ2_bzDecompressEnd( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return 0;
-                }
-                else
-                {
-//                      Bu::size sTotal = 0;
-                        for(;;)
-                        {
-                                pState->next_in = NULL;
-                                pState->avail_in = 0;
-                                pState->avail_out = nBufSize;
-                                pState->next_out = pBuf;
-                                int res = BZ2_bzCompress( pState, BZ_FINISH );
-                                if( pState->avail_out < nBufSize )
-                                {
-                                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                                }
-                                if( res == BZ_STREAM_END )
-                                        break;
-                        }
-                        BZ2_bzCompressEnd( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return sTotalOut;
-                }
-        }
-        return 0;
+    TRACE();
+    if( !pState )
+        return 0;
+
+    if( pState->state )
+    {
+        if( bReading )
+        {
+            BZ2_bzDecompressEnd( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return 0;
+        }
+        else
+        {
+//          Bu::size sTotal = 0;
+            for(;;)
+            {
+                pState->next_in = NULL;
+                pState->avail_in = 0;
+                pState->avail_out = nBufSize;
+                pState->next_out = pBuf;
+                int res = BZ2_bzCompress( pState, BZ_FINISH );
+                if( pState->avail_out < nBufSize )
+                {
+                    sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                }
+                if( res == BZ_STREAM_END )
+                    break;
+            }
+            BZ2_bzCompressEnd( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return sTotalOut;
+        }
+    }
+    return 0;
 }
 
 void Bu::BZip2::bzError( int code )
 {
-        TRACE( code );
-        switch( code )
-        {
-                case BZ_OK:
-                case BZ_RUN_OK:
-                case BZ_FLUSH_OK:
-                case BZ_FINISH_OK:
-                        return;
+    TRACE( code );
+    switch( code )
+    {
+        case BZ_OK:
+        case BZ_RUN_OK:
+        case BZ_FLUSH_OK:
+        case BZ_FINISH_OK:
+            return;
 
-                case BZ_CONFIG_ERROR:
-                        throw ExceptionBase("BZip2: Library configured improperly, reinstall.");
+        case BZ_CONFIG_ERROR:
+            throw ExceptionBase("BZip2: Library configured improperly, reinstall.");
 
-                case BZ_SEQUENCE_ERROR:
-                        throw ExceptionBase("BZip2: Functions were called in an invalid sequence.");
+        case BZ_SEQUENCE_ERROR:
+            throw ExceptionBase("BZip2: Functions were called in an invalid sequence.");
 
-                case BZ_PARAM_ERROR:
-                        throw ExceptionBase("BZip2: Invalid parameter was passed into a function.");
+        case BZ_PARAM_ERROR:
+            throw ExceptionBase("BZip2: Invalid parameter was passed into a function.");
 
-                case BZ_MEM_ERROR:
-                        throw ExceptionBase("BZip2: Couldn't allocate sufficient memory.");
+        case BZ_MEM_ERROR:
+            throw ExceptionBase("BZip2: Couldn't allocate sufficient memory.");
 
-                case BZ_DATA_ERROR:
-                        throw ExceptionBase("BZip2: Data was corrupted before decompression.");
+        case BZ_DATA_ERROR:
+            throw ExceptionBase("BZip2: Data was corrupted before decompression.");
 
-                case BZ_DATA_ERROR_MAGIC:
-                        throw ExceptionBase("BZip2: Stream does not appear to be bzip2 data.");
+        case BZ_DATA_ERROR_MAGIC:
+            throw ExceptionBase("BZip2: Stream does not appear to be bzip2 data.");
 
-                case BZ_IO_ERROR:
-                        throw ExceptionBase("BZip2: File couldn't be read from / written to.");
+        case BZ_IO_ERROR:
+            throw ExceptionBase("BZip2: File couldn't be read from / written to.");
 
-                case BZ_UNEXPECTED_EOF:
-                        throw ExceptionBase("BZip2: End of file encountered before end of stream.");
+        case BZ_UNEXPECTED_EOF:
+            throw ExceptionBase("BZip2: End of file encountered before end of stream.");
 
-                case BZ_OUTBUFF_FULL:
-                        throw ExceptionBase("BZip2: Buffer not large enough to accomidate data.");
+        case BZ_OUTBUFF_FULL:
+            throw ExceptionBase("BZip2: Buffer not large enough to accomidate data.");
 
-                default:
-                        throw ExceptionBase("BZip2: Unknown error encountered.");
-        
-        }
+        default:
+            throw ExceptionBase("BZip2: Unknown error encountered.");
+    
+    }
 }
 
 Bu::size Bu::BZip2::read( void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( !pState->state )
-        {
-                bReading = true;
-                BZ2_bzDecompressInit( pState, 0, 0 );
-                pState->next_in = pBuf;
-                pState->avail_in = 0;
-        }
-        if( bReading == false )
-                throw ExceptionBase("This bzip2 filter is in writing mode, you can't read.");
-
-        int nRead = 0;
-        int nReadTotal = pState->total_out_lo32;
-        pState->next_out = (char *)pData;
-        pState->avail_out = nBytes;
-        for(;;)
-        {
-                int ret = BZ2_bzDecompress( pState );
-        
-                nReadTotal += nRead-pState->avail_out;
-
-                if( ret == BZ_STREAM_END )
-                {
-                        if( pState->avail_in > 0 )
-                        {
-                                if( rNext.isSeekable() )
-                                {
-                                        rNext.seek( -(Bu::size)pState->avail_in );
-                                }
-                        }
-                        return nBytes-pState->avail_out;
-                }
-                bzError( ret );
-
-                if( pState->avail_out )
-                {
-                        if( pState->avail_in == 0 )
-                        {
-                                nRead = rNext.read( pBuf, nBufSize );
-                                if( nRead == 0 && rNext.isEos() )
-                                {
-                                        throw Bu::ExceptionBase("Premature end of underlying "
-                                                        "stream found reading bzip2 stream.");
-                                }
-                                pState->next_in = pBuf;
-                                pState->avail_in = nRead;
-                        }
-                }
-                else
-                {
-                        return nBytes-pState->avail_out;
-                }
-        }
-        return 0;
+    TRACE( pData, nBytes );
+    if( !pState->state )
+    {
+        bReading = true;
+        BZ2_bzDecompressInit( pState, 0, 0 );
+        pState->next_in = pBuf;
+        pState->avail_in = 0;
+    }
+    if( bReading == false )
+        throw ExceptionBase("This bzip2 filter is in writing mode, you can't read.");
+
+    int nRead = 0;
+    int nReadTotal = pState->total_out_lo32;
+    pState->next_out = (char *)pData;
+    pState->avail_out = nBytes;
+    for(;;)
+    {
+        int ret = BZ2_bzDecompress( pState );
+    
+        nReadTotal += nRead-pState->avail_out;
+
+        if( ret == BZ_STREAM_END )
+        {
+            if( pState->avail_in > 0 )
+            {
+                if( rNext.isSeekable() )
+                {
+                    rNext.seek( -(Bu::size)pState->avail_in );
+                }
+            }
+            return nBytes-pState->avail_out;
+        }
+        bzError( ret );
+
+        if( pState->avail_out )
+        {
+            if( pState->avail_in == 0 )
+            {
+                nRead = rNext.read( pBuf, nBufSize );
+                if( nRead == 0 && rNext.isEos() )
+                {
+                    throw Bu::ExceptionBase("Premature end of underlying "
+                            "stream found reading bzip2 stream.");
+                }
+                pState->next_in = pBuf;
+                pState->avail_in = nRead;
+            }
+        }
+        else
+        {
+            return nBytes-pState->avail_out;
+        }
+    }
+    return 0;
 }
 
 Bu::size Bu::BZip2::write( const void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( !pState->state )
-        {
-                bReading = false;
-                BZ2_bzCompressInit( pState, nCompression, 0, 30 );
-        }
-        if( bReading == true )
-                throw ExceptionBase("This bzip2 filter is in reading mode, you can't write.");
-
-//      Bu::size sTotalOut = 0;
-        pState->next_in = (char *)pData;
-        pState->avail_in = nBytes;
-        for(;;)
-        {
-                pState->avail_out = nBufSize;
-                pState->next_out = pBuf;
-
-                bzError( BZ2_bzCompress( pState, BZ_RUN ) );
-
-                if( pState->avail_out < nBufSize )
-                {
-                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                }
-                if( pState->avail_in == 0 )
-                        break;
-        }
-
-        return nBytes;
+    TRACE( pData, nBytes );
+    if( !pState->state )
+    {
+        bReading = false;
+        BZ2_bzCompressInit( pState, nCompression, 0, 30 );
+    }
+    if( bReading == true )
+        throw ExceptionBase("This bzip2 filter is in reading mode, you can't write.");
+
+//  Bu::size sTotalOut = 0;
+    pState->next_in = (char *)pData;
+    pState->avail_in = nBytes;
+    for(;;)
+    {
+        pState->avail_out = nBufSize;
+        pState->next_out = pBuf;
+
+        bzError( BZ2_bzCompress( pState, BZ_RUN ) );
+
+        if( pState->avail_out < nBufSize )
+        {
+            sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+        }
+        if( pState->avail_in == 0 )
+            break;
+    }
+
+    return nBytes;
 }
 
 bool Bu::BZip2::isOpen()
 {
-        TRACE();
-        return (pState->state != NULL);
+    TRACE();
+    return (pState->state != NULL);
 }
 
 Bu::size Bu::BZip2::getCompressedSize()
 {
-        return sTotalOut;
+    return sTotalOut;
 }
 
diff --git a/src/stable/bzip2.h b/src/stable/bzip2.h
index d92dd2f..d53f325 100644
--- a/src/stable/bzip2.h
+++ b/src/stable/bzip2.h
@@ -14,36 +14,36 @@
 
 namespace Bu
 {
-        /**
-         * Provides BZip2 type compression and decompression.
-         *
-         *@ingroup Streams
-         *@ingroup Compression
-         */
-        class BZip2 : public Bu::Filter
-        {
-        public:
-                BZip2( Bu::Stream &rNext, int nCompression=9 );
-                virtual ~BZip2();
-
-                virtual void start();
-                virtual Bu::size stop();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-
-                virtual bool isOpen();
-
-                Bu::size getCompressedSize();
-
-        private:
-                void bzError( int code );
-                void *prState;
-                bool bReading;
-                int nCompression;
-                char *pBuf;
-                uint32_t nBufSize;
-                Bu::size sTotalOut;
-        };
+    /**
+     * Provides BZip2 type compression and decompression.
+     *
+     *@ingroup Streams
+     *@ingroup Compression
+     */
+    class BZip2 : public Bu::Filter
+    {
+    public:
+        BZip2( Bu::Stream &rNext, int nCompression=9 );
+        virtual ~BZip2();
+
+        virtual void start();
+        virtual Bu::size stop();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+        virtual bool isOpen();
+
+        Bu::size getCompressedSize();
+
+    private:
+        void bzError( int code );
+        void *prState;
+        bool bReading;
+        int nCompression;
+        char *pBuf;
+        uint32_t nBufSize;
+        Bu::size sTotalOut;
+    };
 }
 
 #endif
diff --git a/src/stable/client.cpp b/src/stable/client.cpp
index 7ae10f7..f5cc75f 100644
--- a/src/stable/client.cpp
+++ b/src/stable/client.cpp
@@ -14,307 +14,307 @@
 #include "bu/clientlinkfactory.h"
 
 /** Read buffer size. */
-#define RBS             (2000) // 1500 is the nominal MTU for ethernet, it's a good guess
+#define RBS     (2000) // 1500 is the nominal MTU for ethernet, it's a good guess
 
 Bu::Client::Client( Bu::TcpSocket *pSocket,
-                class Bu::ClientLinkFactory *pfLink ) :
-        pTopStream( pSocket ),
-        pSocket( pSocket ),
-        pProto( NULL ),
-        bWantsDisconnect( false ),
-        pfLink( pfLink )
+        class Bu::ClientLinkFactory *pfLink ) :
+    pTopStream( pSocket ),
+    pSocket( pSocket ),
+    pProto( NULL ),
+    bWantsDisconnect( false ),
+    pfLink( pfLink )
 {
-        lFilts.prepend( pSocket );
+    lFilts.prepend( pSocket );
 }
 
 Bu::Client::~Client()
 {
-        for( FilterList::iterator i = lFilts.begin(); i; i++ )
-        {
-                delete *i;
-        }
-        pTopStream = pSocket = NULL;
-        delete pfLink;
+    for( FilterList::iterator i = lFilts.begin(); i; i++ )
+    {
+        delete *i;
+    }
+    pTopStream = pSocket = NULL;
+    delete pfLink;
 }
 
 void Bu::Client::processInput()
 {
-        char buf[RBS];
-        Bu::size nRead, nTotal=0;
-
-        for(;;)
-        {
-                try
-                {
-                        nRead = pTopStream->read( buf, RBS );
-
-                        if( nRead == 0 )
-                        {
-                                break;
-                        }
-                        else
-                        {
-                                nTotal += nRead;
-                                qbRead.write( buf, nRead );
-                                if( !pTopStream->canRead() )
-                                        break;
-                        }
-                }
-                catch( Bu::TcpSocketException &e )
-                {
-                        pTopStream->close();
-                        bWantsDisconnect = true;
-                        break;
-                }
-        }
-
-        if( nTotal == 0 )
-        {
-                pTopStream->close();
-                bWantsDisconnect = true;
-        }
-
-        if( pProto && nTotal )
-        {
-                pProto->onNewData( this );
-        }
+    char buf[RBS];
+    Bu::size nRead, nTotal=0;
+
+    for(;;)
+    {
+        try
+        {
+            nRead = pTopStream->read( buf, RBS );
+
+            if( nRead == 0 )
+            {
+                break;
+            }
+            else
+            {
+                nTotal += nRead;
+                qbRead.write( buf, nRead );
+                if( !pTopStream->canRead() )
+                    break;
+            }
+        }
+        catch( Bu::TcpSocketException &e )
+        {
+            pTopStream->close();
+            bWantsDisconnect = true;
+            break;
+        }
+    }
+
+    if( nTotal == 0 )
+    {
+        pTopStream->close();
+        bWantsDisconnect = true;
+    }
+
+    if( pProto && nTotal )
+    {
+        pProto->onNewData( this );
+    }
 }
 
 void Bu::Client::processOutput()
 {
-        char buf[RBS];
-        if( qbWrite.getSize() > 0 )
-        {
-                int nAmnt = RBS;
-                nAmnt = qbWrite.peek( buf, nAmnt );
-                int nReal = pTopStream->write( buf, nAmnt );
-                qbWrite.seek( nReal );
-                pTopStream->flush();
-        }
+    char buf[RBS];
+    if( qbWrite.getSize() > 0 )
+    {
+        int nAmnt = RBS;
+        nAmnt = qbWrite.peek( buf, nAmnt );
+        int nReal = pTopStream->write( buf, nAmnt );
+        qbWrite.seek( nReal );
+        pTopStream->flush();
+    }
 }
 
 void Bu::Client::setProtocol( Protocol *pProto )
 {
-        this->pProto = pProto;
-        this->pProto->onNewConnection( this );
+    this->pProto = pProto;
+    this->pProto->onNewConnection( this );
 }
 
 Bu::Protocol *Bu::Client::getProtocol()
 {
-        return pProto;
+    return pProto;
 }
 
 void Bu::Client::clearProtocol()
 {
-        pProto = NULL;
+    pProto = NULL;
 }
 /*
 Bu::String &Bu::Client::getInput()
 {
-        return sReadBuf;
+    return sReadBuf;
 }
 
 Bu::String &Bu::Client::getOutput()
 {
-        return sWriteBuf;
+    return sWriteBuf;
 }
 */
 
 bool Bu::Client::isOpen()
 {
-        if( !pTopStream ) return false;
-        return pTopStream->isOpen();
+    if( !pTopStream ) return false;
+    return pTopStream->isOpen();
 }
 
 Bu::size Bu::Client::write( const Bu::String &sData )
 {
-        return qbWrite.write( sData.getStr(), sData.getSize() );
+    return qbWrite.write( sData.getStr(), sData.getSize() );
 }
 
 Bu::size Bu::Client::write( const void *pData, Bu::size nBytes )
 {
-        return qbWrite.write( pData, nBytes );
+    return qbWrite.write( pData, nBytes );
 }
 
 Bu::size Bu::Client::write( int8_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( int16_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( int32_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( int64_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( uint8_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( uint16_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( uint32_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( uint64_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::read( void *pData, Bu::size nBytes )
 {
-        return qbRead.read( pData, nBytes );
+    return qbRead.read( pData, nBytes );
 }
 
 Bu::size Bu::Client::peek( void *pData, int nBytes, int nOffset )
 {
-        return qbRead.peek( pData, nBytes, nOffset );
+    return qbRead.peek( pData, nBytes, nOffset );
 }
 
 Bu::size Bu::Client::getInputSize()
 {
-        return qbRead.getSize();
+    return qbRead.getSize();
 }
 
 Bu::size Bu::Client::getOutputSize()
 {
-        return qbWrite.getSize();
+    return qbWrite.getSize();
 }
 
 const Bu::TcpSocket *Bu::Client::getSocket() const
 {
-        return pSocket;
+    return pSocket;
 }
 
 void Bu::Client::disconnect()
 {
-        bWantsDisconnect = true;
+    bWantsDisconnect = true;
 }
 
 bool Bu::Client::wantsDisconnect()
 {
-        return bWantsDisconnect;
+    return bWantsDisconnect;
 }
 
 void Bu::Client::close()
 {
-        pTopStream->close();
+    pTopStream->close();
 }
 
 Bu::ClientLink *Bu::Client::getLink()
 {
-        return pfLink->createLink( this );
+    return pfLink->createLink( this );
 }
 
 void Bu::Client::onMessage( const Bu::String &sMsg )
 {
-        if( pProto )
-                pProto->onMessage( this, sMsg );
+    if( pProto )
+        pProto->onMessage( this, sMsg );
 }
 
 void Bu::Client::tick()
 {
-        if( pProto )
-                pProto->onTick( this );
+    if( pProto )
+        pProto->onTick( this );
 }
 
 Bu::size Bu::Client::tell()
 {
-        return 0;
+    return 0;
 }
 
 void Bu::Client::seek( Bu::size offset )
 {
-        return qbRead.seek( offset );
+    return qbRead.seek( offset );
 }
 
 void Bu::Client::setPos( Bu::size )
 {
-        throw Bu::ExceptionBase();
+    throw Bu::ExceptionBase();
 }
 
 void Bu::Client::setPosEnd( Bu::size )
 {
-        throw Bu::ExceptionBase();
+    throw Bu::ExceptionBase();
 }
 
 bool Bu::Client::isEos()
 {
-        return true;
+    return true;
 }
 
 void Bu::Client::flush()
 {
-        processOutput();
+    processOutput();
 }
 
 bool Bu::Client::canRead()
 {
-        return qbRead.getSize() > 0;
+    return qbRead.getSize() > 0;
 }
 
 bool Bu::Client::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Client::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Client::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Client::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::Client::isBlocking()
 {
-        return false;
+    return false;
 }
 
 void Bu::Client::setBlocking( bool )
 {
-        throw Bu::ExceptionBase();
+    throw Bu::ExceptionBase();
 }
 
 void Bu::Client::setSize( Bu::size )
 {
-        throw Bu::ExceptionBase();
+    throw Bu::ExceptionBase();
 }
 
 Bu::size Bu::Client::getSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::Client::getBlockSize() const
 {
-        return pSocket->getBlockSize();
+    return pSocket->getBlockSize();
 }
 
 Bu::String Bu::Client::getLocation() const
 {
-        return pSocket->getLocation();
+    return pSocket->getLocation();
 }
 
diff --git a/src/stable/client.h b/src/stable/client.h
index 6bd41af..cacc8aa 100644
--- a/src/stable/client.h
+++ b/src/stable/client.h
@@ -16,118 +16,118 @@
 
 namespace Bu
 {
-        class Protocol;
-        class Stream;
-        class TcpSocket;
-        class ClientLinkFactory;
-
-        /**
-         *@ingroup Serving
-         */
-        class Client : public Bu::Stream
-        {
-        public:
-                Client( Bu::TcpSocket *pSocket, Bu::ClientLinkFactory *pfLink );
-                virtual ~Client();
-
-                void processInput();
-                void processOutput();
-
-                //Bu::String &getInput();
-                //Bu::String &getOutput();
-                Bu::size write( const Bu::String &sData );
-                Bu::size write( const void *pData, Bu::size nBytes );
-                Bu::size write( int8_t nData );
-                Bu::size write( int16_t nData );
-                Bu::size write( int32_t nData );
-                Bu::size write( int64_t nData );
-                Bu::size write( uint8_t nData );
-                Bu::size write( uint16_t nData );
-                Bu::size write( uint32_t nData );
-                Bu::size write( uint64_t nData );
-                Bu::size read( void *pData, Bu::size nBytes );
-                Bu::size peek( void *pData, int nBytes, int nOffset=0 );
-//              void seek( int nBytes );
-                Bu::size getInputSize();
-                Bu::size getOutputSize();
-
-                void setProtocol( Protocol *pProto );
-                Bu::Protocol *getProtocol();
-                void clearProtocol();
-
-                bool isOpen();
-                void close();
-                void tick();
-
-                const Bu::TcpSocket *getSocket() const;
-
-                void disconnect();
-                bool wantsDisconnect();
-
-                class ClientLink *getLink();
-
-                void onMessage( const Bu::String &sMsg );
-
-                bool hasOutput() { return qbWrite.getSize() > 0; }
-                bool hasInput() { return qbRead.getSize() > 0; }
-
-                template<typename filter>
-                void pushFilter()
-                {
-                        filter *pFlt = new filter( *pTopStream );
-                        pTopStream = pFlt;
-                        lFilts.prepend( pFlt );
-                }
-                
-                template<typename filter, typename p1t>
-                void pushFilter( p1t p1 )
-                {
-                        filter *pFlt = new filter( *pTopStream, p1 );
-                        pTopStream = pFlt;
-                        lFilts.prepend( pFlt );
-                }
-                
-                template<typename filter, typename p1t, typename p2t>
-                void pushFilter( p1t p1, p2t p2 )
-                {
-                        filter *pFlt = new filter( *pTopStream, p1, p2 );
-                        pTopStream = pFlt;
-                        lFilts.prepend( pFlt );
-                }
-
-                /*
-                 * These are required to qualify as a stream, I dunno how many will
-                 * be implemented.
-                 */
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-
-        private:
-                typedef Bu::List<Bu::Stream *> FilterList;
-                FilterList lFilts;
-                Bu::Stream *pTopStream;
-                Bu::TcpSocket *pSocket;
-                Bu::Protocol *pProto;
-                Bu::QueueBuf qbRead;
-                Bu::QueueBuf qbWrite;
-                bool bWantsDisconnect;
-                class Bu::ClientLinkFactory *pfLink;
-        };
+    class Protocol;
+    class Stream;
+    class TcpSocket;
+    class ClientLinkFactory;
+
+    /**
+     *@ingroup Serving
+     */
+    class Client : public Bu::Stream
+    {
+    public:
+        Client( Bu::TcpSocket *pSocket, Bu::ClientLinkFactory *pfLink );
+        virtual ~Client();
+
+        void processInput();
+        void processOutput();
+
+        //Bu::String &getInput();
+        //Bu::String &getOutput();
+        Bu::size write( const Bu::String &sData );
+        Bu::size write( const void *pData, Bu::size nBytes );
+        Bu::size write( int8_t nData );
+        Bu::size write( int16_t nData );
+        Bu::size write( int32_t nData );
+        Bu::size write( int64_t nData );
+        Bu::size write( uint8_t nData );
+        Bu::size write( uint16_t nData );
+        Bu::size write( uint32_t nData );
+        Bu::size write( uint64_t nData );
+        Bu::size read( void *pData, Bu::size nBytes );
+        Bu::size peek( void *pData, int nBytes, int nOffset=0 );
+//      void seek( int nBytes );
+        Bu::size getInputSize();
+        Bu::size getOutputSize();
+
+        void setProtocol( Protocol *pProto );
+        Bu::Protocol *getProtocol();
+        void clearProtocol();
+
+        bool isOpen();
+        void close();
+        void tick();
+
+        const Bu::TcpSocket *getSocket() const;
+
+        void disconnect();
+        bool wantsDisconnect();
+
+        class ClientLink *getLink();
+
+        void onMessage( const Bu::String &sMsg );
+
+        bool hasOutput() { return qbWrite.getSize() > 0; }
+        bool hasInput() { return qbRead.getSize() > 0; }
+
+        template<typename filter>
+        void pushFilter()
+        {
+            filter *pFlt = new filter( *pTopStream );
+            pTopStream = pFlt;
+            lFilts.prepend( pFlt );
+        }
+        
+        template<typename filter, typename p1t>
+        void pushFilter( p1t p1 )
+        {
+            filter *pFlt = new filter( *pTopStream, p1 );
+            pTopStream = pFlt;
+            lFilts.prepend( pFlt );
+        }
+        
+        template<typename filter, typename p1t, typename p2t>
+        void pushFilter( p1t p1, p2t p2 )
+        {
+            filter *pFlt = new filter( *pTopStream, p1, p2 );
+            pTopStream = pFlt;
+            lFilts.prepend( pFlt );
+        }
+
+        /*
+         * These are required to qualify as a stream, I dunno how many will
+         * be implemented.
+         */
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+
+    private:
+        typedef Bu::List<Bu::Stream *> FilterList;
+        FilterList lFilts;
+        Bu::Stream *pTopStream;
+        Bu::TcpSocket *pSocket;
+        Bu::Protocol *pProto;
+        Bu::QueueBuf qbRead;
+        Bu::QueueBuf qbWrite;
+        bool bWantsDisconnect;
+        class Bu::ClientLinkFactory *pfLink;
+    };
 }
 
 #endif
diff --git a/src/stable/clientlink.h b/src/stable/clientlink.h
index b5cd74d..d822c93 100644
--- a/src/stable/clientlink.h
+++ b/src/stable/clientlink.h
@@ -12,14 +12,14 @@
 
 namespace Bu
 {
-        class ClientLink
-        {
-        public:
-                ClientLink();
-                virtual ~ClientLink();
+    class ClientLink
+    {
+    public:
+        ClientLink();
+        virtual ~ClientLink();
 
-                virtual void sendMessage( const Bu::String &sMsg )=0;
-        };
+        virtual void sendMessage( const Bu::String &sMsg )=0;
+    };
 };
 
 #endif
diff --git a/src/stable/clientlinkfactory.h b/src/stable/clientlinkfactory.h
index b1b7670..bd64f6b 100644
--- a/src/stable/clientlinkfactory.h
+++ b/src/stable/clientlinkfactory.h
@@ -10,17 +10,17 @@
 
 namespace Bu
 {
-        class Client;
-        class ClientLink;
+    class Client;
+    class ClientLink;
 
-        class ClientLinkFactory
-        {
-        public:
-                ClientLinkFactory();
-                virtual ~ClientLinkFactory();
+    class ClientLinkFactory
+    {
+    public:
+        ClientLinkFactory();
+        virtual ~ClientLinkFactory();
 
-                virtual Bu::ClientLink *createLink( Bu::Client *pClient )=0;
-        };
+        virtual Bu::ClientLink *createLink( Bu::Client *pClient )=0;
+    };
 };
 
 #endif
diff --git a/src/stable/condition.cpp b/src/stable/condition.cpp
index 79af262..f02eca7 100644
--- a/src/stable/condition.cpp
+++ b/src/stable/condition.cpp
@@ -11,39 +11,39 @@
 
 Bu::Condition::Condition()
 {
-        pthread_cond_init( &cond, NULL );
+    pthread_cond_init( &cond, NULL );
 }
 
 Bu::Condition::~Condition()
 {
-        pthread_cond_destroy( &cond );
+    pthread_cond_destroy( &cond );
 }
 
 int Bu::Condition::wait()
 {
-        return pthread_cond_wait( &cond, &mutex );
+    return pthread_cond_wait( &cond, &mutex );
 }
 
 int Bu::Condition::wait( int nSec, int nUSec )
 {
-        struct timeval now;
-        struct timespec timeout;
-        struct timezone tz;
-        
-        gettimeofday( &now, &tz );
-        timeout.tv_sec = now.tv_sec + nSec + ((now.tv_usec + nUSec)/1000000);
-        timeout.tv_nsec = ((now.tv_usec + nUSec)%1000000)*1000;
-
-        return pthread_cond_timedwait( &cond, &mutex, &timeout );
+    struct timeval now;
+    struct timespec timeout;
+    struct timezone tz;
+    
+    gettimeofday( &now, &tz );
+    timeout.tv_sec = now.tv_sec + nSec + ((now.tv_usec + nUSec)/1000000);
+    timeout.tv_nsec = ((now.tv_usec + nUSec)%1000000)*1000;
+
+    return pthread_cond_timedwait( &cond, &mutex, &timeout );
 }
 
 int Bu::Condition::signal()
 {
-        return pthread_cond_signal( &cond );
+    return pthread_cond_signal( &cond );
 }
 
 int Bu::Condition::broadcast()
 {
-        return pthread_cond_broadcast( &cond );
+    return pthread_cond_broadcast( &cond );
 }
 
diff --git a/src/stable/condition.h b/src/stable/condition.h
index 2c27720..53eb9ff 100644
--- a/src/stable/condition.h
+++ b/src/stable/condition.h
@@ -14,77 +14,77 @@
 
 namespace Bu
 {
-        /**
-         * Ito condition.  This is a fairly simple condition mechanism.  As you may
-         * notice this class inherits from the Mutex class, this is because all
-         * conditions must be within a locked block.  The standard usage of a
-         * condition is to pause one thread, perhaps indefinately, until another
-         * thread signals that it is alright to procede.
-         * <br>
-         * Standard usage for the thread that wants to wait is as follows:
-         * <pre>
-         * Condition cond;
-         * ... // Perform setup and enter your run loop
-         * cond.lock();
-         * while( !isFinished() ) // Could be anything you're waiting for
-         *     cond.wait();
-         * ...  // Take care of what you have to.
-         * cond.unlock();
-         * </pre>
-         * The usage for the triggering thread is much simpler, when it needs to
-         * tell the others that it's time to grab some data it calls either signal
-         * or broadcast.  See both of those functions for the difference.
-         *@ingroup Threading
-         */
-        class Condition : public Mutex
-        {
-        public:
-                /**
-                 * Create a condition.
-                 */
-                Condition();
+    /**
+     * Ito condition.  This is a fairly simple condition mechanism.  As you may
+     * notice this class inherits from the Mutex class, this is because all
+     * conditions must be within a locked block.  The standard usage of a
+     * condition is to pause one thread, perhaps indefinately, until another
+     * thread signals that it is alright to procede.
+     * <br>
+     * Standard usage for the thread that wants to wait is as follows:
+     * <pre>
+     * Condition cond;
+     * ... // Perform setup and enter your run loop
+     * cond.lock();
+     * while( !isFinished() ) // Could be anything you're waiting for
+     *     cond.wait();
+     * ...  // Take care of what you have to.
+     * cond.unlock();
+     * </pre>
+     * The usage for the triggering thread is much simpler, when it needs to
+     * tell the others that it's time to grab some data it calls either signal
+     * or broadcast.  See both of those functions for the difference.
+     *@ingroup Threading
+     */
+    class Condition : public Mutex
+    {
+    public:
+        /**
+         * Create a condition.
+         */
+        Condition();
 
-                /**
-                 * Destroy a condition.
-                 */
-                ~Condition();
+        /**
+         * Destroy a condition.
+         */
+        ~Condition();
 
-                /**
-                 * Wait forever, or until signalled.  This has to be called from within
-                 * a locked section, i.e. before calling this this object's lock
-                 * function should be called.
-                 */
-                int wait();
+        /**
+         * Wait forever, or until signalled.  This has to be called from within
+         * a locked section, i.e. before calling this this object's lock
+         * function should be called.
+         */
+        int wait();
 
-                /**
-                 * Wait for a maximum of nSec seconds and nUSec micro-seconds or until
-                 * signalled.  This is a little more friendly function if you want to
-                 * perform other operations in the thrad loop that calls this function.
-                 * Like the other wait function, this must be inside a locked section.
-                 *@param nSec The seconds to wait.
-                 *@param nUSec the micro-seconds to wait.
-                 */
-                int wait( int nSec, int nUSec );
+        /**
+         * Wait for a maximum of nSec seconds and nUSec micro-seconds or until
+         * signalled.  This is a little more friendly function if you want to
+         * perform other operations in the thrad loop that calls this function.
+         * Like the other wait function, this must be inside a locked section.
+         *@param nSec The seconds to wait.
+         *@param nUSec the micro-seconds to wait.
+         */
+        int wait( int nSec, int nUSec );
 
-                /**
-                 * Notify the next thread waiting on this condition that they can go
-                 * ahead.  This only signals one thread, the next one in the condition
-                 * queue, that it is safe to procede with whatever operation was being
-                 * waited on.
-                 */
-                int signal();
+        /**
+         * Notify the next thread waiting on this condition that they can go
+         * ahead.  This only signals one thread, the next one in the condition
+         * queue, that it is safe to procede with whatever operation was being
+         * waited on.
+         */
+        int signal();
 
-                /**
-                 * Notify all threads waiting on this condition that they can go ahead
-                 * now. This function is slower than signal, but more effective in
-                 * certain situations where you may not know how many threads should be
-                 * activated.
-                 */
-                int broadcast();
+        /**
+         * Notify all threads waiting on this condition that they can go ahead
+         * now. This function is slower than signal, but more effective in
+         * certain situations where you may not know how many threads should be
+         * activated.
+         */
+        int broadcast();
 
-        private:
-                pthread_cond_t cond;    /**< Internal condition reference. */
-        };
+    private:
+        pthread_cond_t cond;    /**< Internal condition reference. */
+    };
 }
 
 #endif
diff --git a/src/stable/conduit.cpp b/src/stable/conduit.cpp
index 8f5eba5..4c2fda6 100644
--- a/src/stable/conduit.cpp
+++ b/src/stable/conduit.cpp
@@ -8,9 +8,9 @@
 #include "bu/conduit.h"
 
 Bu::Conduit::Conduit( int iBlockSize ) :
-        qb( iBlockSize ),
-        bBlocking( true ),
-        bOpen( true )
+    qb( iBlockSize ),
+    bBlocking( true ),
+    bOpen( true )
 {
 }
 
@@ -20,100 +20,100 @@ Bu::Conduit::~Conduit()
 
 void Bu::Conduit::close()
 {
-        im.lock();
-//      qb.close();
-        bOpen = false;
-        
-        cBlock.signal();
-        im.unlock();
+    im.lock();
+//  qb.close();
+    bOpen = false;
+    
+    cBlock.signal();
+    im.unlock();
 }
 
 #include <stdio.h>
 Bu::size Bu::Conduit::read( void *pBuf, Bu::size nBytes )
 {
-        if( !isOpen() )
-        {
-                return 0;
-        }
-        im.lock();
-        if( bBlocking )
-        {
-                im.unlock();
-                cBlock.lock();
-                for(;;)
-                {
-                        im.lock();
-                        if( qb.getSize() == 0 && bOpen == false )
-                        {
-                                im.unlock();
-                                cBlock.unlock();
-                                return 0;
-                        }
-                        else if( qb.getSize() > 0 )
-                        {
-                                im.unlock();
-                                break;
-                        }
-                        im.unlock();
-
-                        cBlock.wait();
-                }
-
-                im.lock();
-                Bu::size iRet = qb.read( pBuf, nBytes );
-                im.unlock();
-
-                cBlock.unlock();
-                return iRet;
-        }
-        else
-        {
-                Bu::size iRet = qb.read( pBuf, nBytes );
-                im.unlock();
-
-                return iRet;
-        }
+    if( !isOpen() )
+    {
+        return 0;
+    }
+    im.lock();
+    if( bBlocking )
+    {
+        im.unlock();
+        cBlock.lock();
+        for(;;)
+        {
+            im.lock();
+            if( qb.getSize() == 0 && bOpen == false )
+            {
+                im.unlock();
+                cBlock.unlock();
+                return 0;
+            }
+            else if( qb.getSize() > 0 )
+            {
+                im.unlock();
+                break;
+            }
+            im.unlock();
+
+            cBlock.wait();
+        }
+
+        im.lock();
+        Bu::size iRet = qb.read( pBuf, nBytes );
+        im.unlock();
+
+        cBlock.unlock();
+        return iRet;
+    }
+    else
+    {
+        Bu::size iRet = qb.read( pBuf, nBytes );
+        im.unlock();
+
+        return iRet;
+    }
 }
 
 Bu::size Bu::Conduit::peek( void *pBuf, Bu::size nBytes )
 {
-        im.lock();
-        Bu::size iRet = qb.peek( pBuf, nBytes );
-        im.unlock();
+    im.lock();
+    Bu::size iRet = qb.peek( pBuf, nBytes );
+    im.unlock();
 
-        return iRet;
+    return iRet;
 }
 
 Bu::size Bu::Conduit::peek( void *pBuf, Bu::size nBytes, Bu::size nSkip )
 {
-        im.lock();
-        Bu::size iRet = qb.peek( pBuf, nBytes, nSkip );
-        im.unlock();
+    im.lock();
+    Bu::size iRet = qb.peek( pBuf, nBytes, nSkip );
+    im.unlock();
 
-        return iRet;
+    return iRet;
 }
 
 Bu::size Bu::Conduit::write( const void *pBuf, Bu::size nBytes )
 {
-        im.lock();
-        if( bOpen == false )
-        {
-                im.unlock();
-                return 0;
-        }
-        Bu::size sRet = qb.write( pBuf, nBytes );
-        cBlock.signal();
-        im.unlock();
+    im.lock();
+    if( bOpen == false )
+    {
+        im.unlock();
+        return 0;
+    }
+    Bu::size sRet = qb.write( pBuf, nBytes );
+    cBlock.signal();
+    im.unlock();
 
-        return sRet;
+    return sRet;
 }
 
 Bu::size Bu::Conduit::tell()
 {
-        im.lock();
-        Bu::size sRet = qb.tell();
-        im.unlock();
-        return sRet;
+    im.lock();
+    Bu::size sRet = qb.tell();
+    im.unlock();
+    return sRet;
 }
 
 void Bu::Conduit::seek( Bu::size )
@@ -130,18 +130,18 @@ void Bu::Conduit::setPosEnd( Bu::size )
 
 bool Bu::Conduit::isEos()
 {
-        im.lock();
-        bool bRet = qb.isEos();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.isEos();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::isOpen()
 {
-        im.lock();
-        bool bRet = bOpen || (qb.getSize() > 0);
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = bOpen || (qb.getSize() > 0);
+    im.unlock();
+    return bRet;
 }
 
 void Bu::Conduit::flush()
@@ -150,57 +150,57 @@ void Bu::Conduit::flush()
 
 bool Bu::Conduit::canRead()
 {
-        im.lock();
-        bool bRet = qb.canRead();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.canRead();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::canWrite()
 {
-        im.lock();
-        bool bRet = qb.canWrite();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.canWrite();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::isReadable()
 {
-        im.lock();
-        bool bRet = qb.isReadable();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.isReadable();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::isWritable()
 {
-        im.lock();
-        bool bRet = qb.isWritable();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.isWritable();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::isSeekable()
 {
-        im.lock();
-        bool bRet = qb.isSeekable();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.isSeekable();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::isBlocking()
 {
-        im.lock();
-        bool bRet = bBlocking;
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = bBlocking;
+    im.unlock();
+    return bRet;
 }
 
 void Bu::Conduit::setBlocking( bool bBlocking )
 {
-        im.lock();
-        this->bBlocking = bBlocking;
-        im.unlock();
+    im.lock();
+    this->bBlocking = bBlocking;
+    im.unlock();
 }
 
 void Bu::Conduit::setSize( Bu::size )
@@ -209,25 +209,25 @@ void Bu::Conduit::setSize( Bu::size )
 
 Bu::size Bu::Conduit::getSize() const
 {
-        im.lock();
-        Bu::size sRet = qb.getSize();
-        im.unlock();
-        return sRet;
+    im.lock();
+    Bu::size sRet = qb.getSize();
+    im.unlock();
+    return sRet;
 }
 
 Bu::size Bu::Conduit::getBlockSize() const
 {
-        im.lock();
-        Bu::size sRet = qb.getBlockSize();
-        im.unlock();
-        return sRet;
+    im.lock();
+    Bu::size sRet = qb.getBlockSize();
+    im.unlock();
+    return sRet;
 }
 
 Bu::String Bu::Conduit::getLocation() const
 {
-        im.lock();
-        Bu::String sRet = qb.getLocation();
-        im.unlock();
-        return sRet;
+    im.lock();
+    Bu::String sRet = qb.getLocation();
+    im.unlock();
+    return sRet;
 }
 
diff --git a/src/stable/conduit.h b/src/stable/conduit.h
index a1959a9..78d24eb 100644
--- a/src/stable/conduit.h
+++ b/src/stable/conduit.h
@@ -16,49 +16,49 @@
 
 namespace Bu
 {
-        /**
-         * Simple inter-thread communication stream.  This acts like a pair of
-         * pipes for stream communication between any two things, but without the
-         * use of pipes, making this a bad choice for IPC.
-         */
-        class Conduit : public Stream
-        {
-        public:
-                Conduit( int iBlockSize=256 );
-                virtual ~Conduit();
+    /**
+     * Simple inter-thread communication stream.  This acts like a pair of
+     * pipes for stream communication between any two things, but without the
+     * use of pipes, making this a bad choice for IPC.
+     */
+    class Conduit : public Stream
+    {
+    public:
+        Conduit( int iBlockSize=256 );
+        virtual ~Conduit();
 
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size peek( void *pBuf, Bu::size nBytes );
-                virtual Bu::size peek( void *pBuf, Bu::size nBytes, Bu::size nSkip );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size peek( void *pBuf, Bu::size nBytes );
+        virtual Bu::size peek( void *pBuf, Bu::size nBytes, Bu::size nSkip );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-        private:
-                QueueBuf qb;
-                mutable Mutex im;
-                Condition cBlock;
-                bool bBlocking;
-                bool bOpen;
-        };
+    private:
+        QueueBuf qb;
+        mutable Mutex im;
+        Condition cBlock;
+        bool bBlocking;
+        bool bOpen;
+    };
 }
 
 #endif
diff --git a/src/stable/crypt.cpp b/src/stable/crypt.cpp
index 3f7fc83..2915cf4 100644
--- a/src/stable/crypt.cpp
+++ b/src/stable/crypt.cpp
@@ -13,35 +13,35 @@
 
 Bu::String Bu::cryptPass( const Bu::String &sPass, const Bu::String &sSalt )
 {
-        Bu::Md5 md5;
-        Bu::MemBuf mbOut;
-        Bu::Base64 b64Out( mbOut );
-        
-        Bu::String::const_iterator i = sSalt.find('$');
-        Bu::String sSaltSml = sSalt.getSubStr( sSalt.begin(), i );
+    Bu::Md5 md5;
+    Bu::MemBuf mbOut;
+    Bu::Base64 b64Out( mbOut );
+    
+    Bu::String::const_iterator i = sSalt.find('$');
+    Bu::String sSaltSml = sSalt.getSubStr( sSalt.begin(), i );
 
-        md5.addData( sPass );
-        md5.addData( sSaltSml );
-        md5.writeResult( b64Out );
+    md5.addData( sPass );
+    md5.addData( sSaltSml );
+    md5.writeResult( b64Out );
 
-        b64Out.stop();
+    b64Out.stop();
 
-        return sSaltSml + "$" + mbOut.getString();
+    return sSaltSml + "$" + mbOut.getString();
 }
 
 Bu::String Bu::cryptPass( const Bu::String &sPass )
 {
-        Bu::MemBuf mbSalt;
-        Bu::Base64 b64Salt( mbSalt );
-        Bu::File fRand("/dev/urandom", Bu::File::Read );
+    Bu::MemBuf mbSalt;
+    Bu::Base64 b64Salt( mbSalt );
+    Bu::File fRand("/dev/urandom", Bu::File::Read );
 
 #define STR 6
-        char buf[STR];
-        fRand.read( buf, STR );
-        b64Salt.write( buf, STR );
+    char buf[STR];
+    fRand.read( buf, STR );
+    b64Salt.write( buf, STR );
 
-        b64Salt.stop();
+    b64Salt.stop();
 
-        return cryptPass( sPass, mbSalt.getString() );
+    return cryptPass( sPass, mbSalt.getString() );
 }
 
diff --git a/src/stable/crypt.h b/src/stable/crypt.h
index 14adc3a..5093610 100644
--- a/src/stable/crypt.h
+++ b/src/stable/crypt.h
@@ -12,8 +12,8 @@
 
 namespace Bu
 {
-        String cryptPass( const Bu::String &sPass, const Bu::String &sSalt );
-        String cryptPass( const Bu::String &sPass );
+    String cryptPass( const Bu::String &sPass, const Bu::String &sSalt );
+    String cryptPass( const Bu::String &sPass );
 };
 
 #endif
diff --git a/src/stable/cryptohash.cpp b/src/stable/cryptohash.cpp
index dda734c..99a7d92 100644
--- a/src/stable/cryptohash.cpp
+++ b/src/stable/cryptohash.cpp
@@ -17,22 +17,22 @@ Bu::CryptoHash::~CryptoHash()
 
 void Bu::CryptoHash::addData( const Bu::String &sData )
 {
-        addData( sData.getStr(), sData.getSize() );
+    addData( sData.getStr(), sData.getSize() );
 }
 
 Bu::String Bu::CryptoHash::getHexResult()
 {
-        Bu::String sResult = getResult();
-        Bu::String sRet( 2*sResult.getSize() );
-        static const char hex_tab[] = {"0123456789abcdef"};
-
-        int k = 0;
-        for( int i = 0; i < sResult.getSize(); i++ )
-        {
-                sRet[k++] = hex_tab[(((unsigned char)sResult[i])>>4) & 0xF];
-                sRet[k++] = hex_tab[((unsigned char)sResult[i]) & 0xF];
-        }
-
-        return sRet;    
+    Bu::String sResult = getResult();
+    Bu::String sRet( 2*sResult.getSize() );
+    static const char hex_tab[] = {"0123456789abcdef"};
+
+    int k = 0;
+    for( int i = 0; i < sResult.getSize(); i++ )
+    {
+        sRet[k++] = hex_tab[(((unsigned char)sResult[i])>>4) & 0xF];
+        sRet[k++] = hex_tab[((unsigned char)sResult[i]) & 0xF];
+    }
+
+    return sRet;    
 }
 
diff --git a/src/stable/cryptohash.h b/src/stable/cryptohash.h
index 3f13b05..a943590 100644
--- a/src/stable/cryptohash.h
+++ b/src/stable/cryptohash.h
@@ -12,22 +12,22 @@
 
 namespace Bu
 {
-        class Stream;
+    class Stream;
 
-        class CryptoHash
-        {
-        public:
-                CryptoHash();
-                virtual ~CryptoHash();
+    class CryptoHash
+    {
+    public:
+        CryptoHash();
+        virtual ~CryptoHash();
 
-                virtual void reset() = 0;
-                virtual void setSalt( const Bu::String &sSalt ) = 0;
-                virtual void addData( const void *sData, int iSize ) = 0;
-                virtual void addData( const Bu::String &sData );
-                virtual String getResult() = 0;
-                virtual void writeResult( Stream &sOut ) = 0;
-                virtual Bu::String getHexResult();
-        };
+        virtual void reset() = 0;
+        virtual void setSalt( const Bu::String &sSalt ) = 0;
+        virtual void addData( const void *sData, int iSize ) = 0;
+        virtual void addData( const Bu::String &sData );
+        virtual String getResult() = 0;
+        virtual void writeResult( Stream &sOut ) = 0;
+        virtual Bu::String getHexResult();
+    };
 };
 
 #endif
diff --git a/src/stable/csvreader.cpp b/src/stable/csvreader.cpp
index ddc68f0..c27c8ee 100644
--- a/src/stable/csvreader.cpp
+++ b/src/stable/csvreader.cpp
@@ -12,24 +12,24 @@
 using namespace Bu;
 
 Bu::CsvReader::CsvReader( Bu::Stream &sIn, Bu::CsvReader::Style eStyle ) :
-        sIn( sIn )
+    sIn( sIn )
 {
-        switch( eStyle )
-        {
-                case styleExcel:
-                        sDecode = Bu::slot( &decodeExcel );
-                        break;
-
-                case styleC:
-                        sDecode = Bu::slot( &decodeC );
-                        break;
-        }
+    switch( eStyle )
+    {
+        case styleExcel:
+            sDecode = Bu::slot( &decodeExcel );
+            break;
+
+        case styleC:
+            sDecode = Bu::slot( &decodeC );
+            break;
+    }
 }
 
 Bu::CsvReader::CsvReader( Bu::Stream &sIn,
-                Bu::CsvReader::DecodeSignal sDecode ) :
-        sIn( sIn ),
-        sDecode( sDecode )
+        Bu::CsvReader::DecodeSignal sDecode ) :
+    sIn( sIn ),
+    sDecode( sDecode )
 {
 }
 
@@ -39,61 +39,61 @@ Bu::CsvReader::~CsvReader()
 
 Bu::StrArray Bu::CsvReader::readLine()
 {
-        Bu::StrArray aVals;
-
-        Bu::String sLine = sIn.readLine();
-
-        if( !sLine.isSet() )
-                return Bu::StrArray();
-
-        Bu::String::iterator i = sLine.begin();
-
-        aVals.append( sDecode( i ) );
-
-        while( i )
-        {
-                if( *i == ',' )
-                {
-                        i++;
-                        if( !i )
-                        {
-                                aVals.append("");
-                                break;
-                        }
-                        aVals.append( sDecode( i ) );
-                }
-                else
-                {
-                        // Blanks and stuff?
-                        sio << "Out of bound:  '" << *i << "'" << sio.nl;
-                        i++;
-                }
-        }
-
-        return aVals;
+    Bu::StrArray aVals;
+
+    Bu::String sLine = sIn.readLine();
+
+    if( !sLine.isSet() )
+        return Bu::StrArray();
+
+    Bu::String::iterator i = sLine.begin();
+
+    aVals.append( sDecode( i ) );
+
+    while( i )
+    {
+        if( *i == ',' )
+        {
+            i++;
+            if( !i )
+            {
+                aVals.append("");
+                break;
+            }
+            aVals.append( sDecode( i ) );
+        }
+        else
+        {
+            // Blanks and stuff?
+            sio << "Out of bound:  '" << *i << "'" << sio.nl;
+            i++;
+        }
+    }
+
+    return aVals;
 }
 
 Bu::String Bu::CsvReader::decodeExcel( Bu::String::iterator &i )
 {
-        Bu::String sRet;
+    Bu::String sRet;
 
-        for(; i && (*i == ' ' || *i == '\t'); i++ ) { }
-        
-        if( !i )
-                return sRet;
+    for(; i && (*i == ' ' || *i == '\t'); i++ ) { }
+    
+    if( !i )
+        return sRet;
 
-        if( *i == '\"' )
+    if( *i == '\"' )
         {
                 for( i++ ; i; i++ )
                 {
                         if( *i == '\"' )
-                        {
-                                i++;
-                                if( !i )
-                                {
-                                        return sRet;
-                                }
-                                else if( *i == '\"' )
+            {
+                i++;
+                if( !i )
+                {
+                    return sRet;
+                }
+                else if( *i == '\"' )
                                 {
                                         sRet += *i;
                                 }
diff --git a/src/stable/csvreader.h b/src/stable/csvreader.h
index 6825da3..cb2a560 100644
--- a/src/stable/csvreader.h
+++ b/src/stable/csvreader.h
@@ -14,32 +14,32 @@
 
 namespace Bu
 {
-        class Stream;
-        typedef Bu::Array<Bu::String> StrArray;
-
-        class CsvReader
-        {
-        public:
-                typedef Bu::Signal1<Bu::String, Bu::String::iterator &> DecodeSignal;
-                enum Style
-                {
-                        styleExcel, ///< Excel style quotes around things that need em
-                        styleC          ///< Escape things that need it C-style
-                };
-
-                CsvReader( Stream &sIn, Style eStyle=styleExcel );
-                CsvReader( Stream &sIn, DecodeSignal sDecode );
-                virtual ~CsvReader();
-
-                StrArray readLine();
-
-        private:
-                Stream &sIn;
-                DecodeSignal sDecode;
-
-                static Bu::String decodeExcel( Bu::String::iterator &i );
-                static Bu::String decodeC( Bu::String::iterator &i );
-        };
+    class Stream;
+    typedef Bu::Array<Bu::String> StrArray;
+
+    class CsvReader
+    {
+    public:
+        typedef Bu::Signal1<Bu::String, Bu::String::iterator &> DecodeSignal;
+        enum Style
+        {
+            styleExcel, ///< Excel style quotes around things that need em
+            styleC      ///< Escape things that need it C-style
+        };
+
+        CsvReader( Stream &sIn, Style eStyle=styleExcel );
+        CsvReader( Stream &sIn, DecodeSignal sDecode );
+        virtual ~CsvReader();
+
+        StrArray readLine();
+
+    private:
+        Stream &sIn;
+        DecodeSignal sDecode;
+
+        static Bu::String decodeExcel( Bu::String::iterator &i );
+        static Bu::String decodeC( Bu::String::iterator &i );
+    };
 };
 
 #endif
diff --git a/src/stable/csvwriter.cpp b/src/stable/csvwriter.cpp
index a89b309..8b51115 100644
--- a/src/stable/csvwriter.cpp
+++ b/src/stable/csvwriter.cpp
@@ -9,24 +9,24 @@
 #include "bu/stream.h"
 
 Bu::CsvWriter::CsvWriter( Bu::Stream &sOut, Bu::CsvWriter::Style eStyle ) :
-        sOut( sOut )
+    sOut( sOut )
 {
-        switch( eStyle )
-        {
-                case styleExcel:
-                        sEncode = Bu::slot( &encodeExcel );
-                        break;
+    switch( eStyle )
+    {
+        case styleExcel:
+            sEncode = Bu::slot( &encodeExcel );
+            break;
 
-                case styleC:
-                        sEncode = Bu::slot( &encodeExcel );
-                        break;
-        }
+        case styleC:
+            sEncode = Bu::slot( &encodeExcel );
+            break;
+    }
 }
 
 Bu::CsvWriter::CsvWriter( Bu::Stream &sOut,
-                Bu::CsvWriter::EncodeSignal sEncode ) :
-        sOut( sOut ),
-        sEncode( sEncode )
+        Bu::CsvWriter::EncodeSignal sEncode ) :
+    sOut( sOut ),
+    sEncode( sEncode )
 {
 }
 
@@ -36,46 +36,46 @@ Bu::CsvWriter::~CsvWriter()
 
 void Bu::CsvWriter::writeLine( const StrArray &aStrs )
 {
-        Bu::String sBuf;
-        for( StrArray::const_iterator i = aStrs.begin(); i; i++ )
-        {
-                if( i != aStrs.begin() )
-                        sBuf += ",";
-                sBuf += sEncode( *i );
-        }
-        sBuf += "\n";
+    Bu::String sBuf;
+    for( StrArray::const_iterator i = aStrs.begin(); i; i++ )
+    {
+        if( i != aStrs.begin() )
+            sBuf += ",";
+        sBuf += sEncode( *i );
+    }
+    sBuf += "\n";
 
-        sOut.write( sBuf );
+    sOut.write( sBuf );
 }
 
 Bu::String Bu::CsvWriter::encodeExcel( const Bu::String &sIn )
 {
-        if( sIn.find('\"') || sIn.find(',') )
+    if( sIn.find('\"') || sIn.find(',') )
         {
                 Bu::String sOut = "\"";
-                for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
-                {
-                        if( *i == '\"' )
+        for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
+        {
+            if( *i == '\"' )
                                 sOut += "\"\"";
                         else
                                 sOut += *i;
                 }
                 sOut += '\"';
-                return sOut;
-        }
-        return sIn;
+        return sOut;
+    }
+    return sIn;
 }
 
 Bu::String Bu::CsvWriter::encodeC( const Bu::String &sIn )
 {
-        Bu::String sOut = "";
-        for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
-        {
-                if( *i == ',' )
-                        sOut += "\\,";
-                else
-                        sOut += *i;
-        }
-        return sOut;
+    Bu::String sOut = "";
+    for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
+    {
+        if( *i == ',' )
+            sOut += "\\,";
+        else
+            sOut += *i;
+    }
+    return sOut;
 }
 
diff --git a/src/stable/csvwriter.h b/src/stable/csvwriter.h
index bae1e1d..233f4ed 100644
--- a/src/stable/csvwriter.h
+++ b/src/stable/csvwriter.h
@@ -14,32 +14,32 @@
 
 namespace Bu
 {
-        class Stream;
-        typedef Bu::Array<Bu::String> StrArray;
-
-        class CsvWriter
-        {
-        public:
-                typedef Bu::Signal1<Bu::String, const Bu::String &> EncodeSignal;
-                enum Style
-                {
-                        styleExcel, ///< Excel style quotes around things that need em
-                        styleC          ///< Escape things that need it C-style
-                };
-
-                CsvWriter( Stream &sOut, Style eStyle=styleExcel );
-                CsvWriter( Stream &sOut, EncodeSignal sEncode );
-                virtual ~CsvWriter();
-
-                void writeLine( const StrArray &aStrs );
-
-        private:
-                Stream &sOut;
-                EncodeSignal sEncode;
-
-                static Bu::String encodeExcel( const Bu::String &sIn );
-                static Bu::String encodeC( const Bu::String &sIn );
-        };
+    class Stream;
+    typedef Bu::Array<Bu::String> StrArray;
+
+    class CsvWriter
+    {
+    public:
+        typedef Bu::Signal1<Bu::String, const Bu::String &> EncodeSignal;
+        enum Style
+        {
+            styleExcel, ///< Excel style quotes around things that need em
+            styleC      ///< Escape things that need it C-style
+        };
+
+        CsvWriter( Stream &sOut, Style eStyle=styleExcel );
+        CsvWriter( Stream &sOut, EncodeSignal sEncode );
+        virtual ~CsvWriter();
+
+        void writeLine( const StrArray &aStrs );
+
+    private:
+        Stream &sOut;
+        EncodeSignal sEncode;
+
+        static Bu::String encodeExcel( const Bu::String &sIn );
+        static Bu::String encodeC( const Bu::String &sIn );
+    };
 };
 
 #endif
diff --git a/src/stable/deflate.cpp b/src/stable/deflate.cpp
index b7e1804..57aa4aa 100644
--- a/src/stable/deflate.cpp
+++ b/src/stable/deflate.cpp
@@ -15,239 +15,239 @@
 using namespace Bu;
 
 Bu::Deflate::Deflate( Bu::Stream &rNext, int nCompression, Format eFmt ) :
-        Bu::Filter( rNext ),
-        prState( NULL ),
-        nCompression( nCompression ),
-        sTotalOut( 0 ),
-        eFmt( eFmt ),
-        bEos( false )
+    Bu::Filter( rNext ),
+    prState( NULL ),
+    nCompression( nCompression ),
+    sTotalOut( 0 ),
+    eFmt( eFmt ),
+    bEos( false )
 {
-        TRACE( nCompression );
-        start();
+    TRACE( nCompression );
+    start();
 }
 
 Bu::Deflate::~Deflate()
 {
-        TRACE();
-        stop();
+    TRACE();
+    stop();
 }
 
 void Bu::Deflate::start()
 {
-        TRACE();
-        prState = new z_stream;
-        pState->zalloc = NULL;
-        pState->zfree = NULL;
-        pState->opaque = NULL;
-        pState->state = NULL;
-
-        nBufSize = 64*1024;
-        pBuf = new char[nBufSize];
+    TRACE();
+    prState = new z_stream;
+    pState->zalloc = NULL;
+    pState->zfree = NULL;
+    pState->opaque = NULL;
+    pState->state = NULL;
+
+    nBufSize = 64*1024;
+    pBuf = new char[nBufSize];
 }
 
 Bu::size Bu::Deflate::stop()
 {
-        TRACE();
-        if( pState && pState->state )
-        {
-                if( bReading )
-                {
-                        inflateEnd( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return 0;
-                }
-                else
-                {
-                        for(;;)
-                        {
-                                pState->next_in = NULL;
-                                pState->avail_in = 0;
-                                pState->avail_out = nBufSize;
-                                pState->next_out = (Bytef *)pBuf;
-                                int res = deflate( pState, Z_FINISH );
-                                if( pState->avail_out < nBufSize )
-                                {
-                                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                                }
-                                if( res == Z_STREAM_END )
-                                        break;
-                        }
-                        deflateEnd( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return sTotalOut;
-                }
-        }
-        return 0;
+    TRACE();
+    if( pState && pState->state )
+    {
+        if( bReading )
+        {
+            inflateEnd( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return 0;
+        }
+        else
+        {
+            for(;;)
+            {
+                pState->next_in = NULL;
+                pState->avail_in = 0;
+                pState->avail_out = nBufSize;
+                pState->next_out = (Bytef *)pBuf;
+                int res = deflate( pState, Z_FINISH );
+                if( pState->avail_out < nBufSize )
+                {
+                    sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                }
+                if( res == Z_STREAM_END )
+                    break;
+            }
+            deflateEnd( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return sTotalOut;
+        }
+    }
+    return 0;
 }
 
 void Bu::Deflate::zError( int code )
 {
-        TRACE( code );
-        switch( code )
-        {
-                case Z_OK:
-                case Z_STREAM_END:
-                case Z_NEED_DICT:
-                        return;
+    TRACE( code );
+    switch( code )
+    {
+        case Z_OK:
+        case Z_STREAM_END:
+        case Z_NEED_DICT:
+            return;
 
-                case Z_ERRNO:
-                        throw ExceptionBase("Deflate: Errno - %s", pState->msg );
+        case Z_ERRNO:
+            throw ExceptionBase("Deflate: Errno - %s", pState->msg );
 
-                case Z_STREAM_ERROR:
-                        throw ExceptionBase("Deflate: Stream Error - %s", pState->msg );
+        case Z_STREAM_ERROR:
+            throw ExceptionBase("Deflate: Stream Error - %s", pState->msg );
 
-                case Z_DATA_ERROR:
-                        throw ExceptionBase("Deflate: Data Error - %s", pState->msg );
+        case Z_DATA_ERROR:
+            throw ExceptionBase("Deflate: Data Error - %s", pState->msg );
 
-                case Z_MEM_ERROR:
-                        throw ExceptionBase("Deflate: Mem Error - %s", pState->msg );
+        case Z_MEM_ERROR:
+            throw ExceptionBase("Deflate: Mem Error - %s", pState->msg );
 
-                case Z_BUF_ERROR:
-                        throw ExceptionBase("Deflate: Buf Error - %s", pState->msg );
+        case Z_BUF_ERROR:
+            throw ExceptionBase("Deflate: Buf Error - %s", pState->msg );
 
-                case Z_VERSION_ERROR:
-                        throw ExceptionBase("Deflate: Version Error - %s", pState->msg );
+        case Z_VERSION_ERROR:
+            throw ExceptionBase("Deflate: Version Error - %s", pState->msg );
 
-                default:
-                        throw ExceptionBase("Deflate: Unknown error encountered - %s.", pState->msg );
-        
-        }
+        default:
+            throw ExceptionBase("Deflate: Unknown error encountered - %s.", pState->msg );
+    
+    }
 }
 
 Bu::size Bu::Deflate::read( void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( nBytes  <= 0 )
-                return 0;
-        if( !pState->state )
-        {
-                bReading = true;
-                if( eFmt&AutoDetect )
-                        inflateInit2( pState, 32+15 ); // Auto-detect, large window
-                else if( eFmt == Raw )
-                        inflateInit2( pState, -15 ); // Raw
-                else if( eFmt == Zlib )
-                        inflateInit2( pState, 15 ); // Zlib
-                else if( eFmt == Gzip )
-                        inflateInit2( pState, 16+15 ); // GZip
-                else
-                        throw Bu::ExceptionBase("Format mode for deflate read.");
-                pState->next_in = (Bytef *)pBuf;
-                pState->avail_in = 0;
-        }
-        if( bReading == false )
-                throw ExceptionBase("This deflate filter is in writing mode, you can't read.");
-
-        int nRead = 0;
-        int nReadTotal = pState->total_out;
-        pState->next_out = (Bytef *)pData;
-        pState->avail_out = nBytes;
-        for(;;)
-        {
-                int ret = inflate( pState, Z_NO_FLUSH );
-                nReadTotal += nRead-pState->avail_out;
-
-                if( ret == Z_STREAM_END )
-                {
-                        bEos = true;
-                        if( pState->avail_in > 0 )
-                        {
-                                if( rNext.isSeekable() )
-                                {
-                                        rNext.seek( -pState->avail_in );
-                                }
-                        }
-                        return nBytes-pState->avail_out;
-                }
-                if( ret != Z_BUF_ERROR )
-                        zError( ret );
-
-                if( pState->avail_out )
-                {
-                        if( pState->avail_in == 0 )
-                        {
-                                nRead = rNext.read( pBuf, nBufSize );
-                                if( nRead == 0 && rNext.isEos() )
-                                {
-                                        throw Bu::ExceptionBase("Premature end of underlying "
-                                                        "stream found reading deflate stream.");
-                                }
-                                pState->next_in = (Bytef *)pBuf;
-                                pState->avail_in = nRead;
-                        }
-                }
-                else
-                {
-                        return nBytes-pState->avail_out;
-                }
-        }
-        return 0;
+    TRACE( pData, nBytes );
+    if( nBytes  <= 0 )
+        return 0;
+    if( !pState->state )
+    {
+        bReading = true;
+        if( eFmt&AutoDetect )
+            inflateInit2( pState, 32+15 ); // Auto-detect, large window
+        else if( eFmt == Raw )
+            inflateInit2( pState, -15 ); // Raw
+        else if( eFmt == Zlib )
+            inflateInit2( pState, 15 ); // Zlib
+        else if( eFmt == Gzip )
+            inflateInit2( pState, 16+15 ); // GZip
+        else
+            throw Bu::ExceptionBase("Format mode for deflate read.");
+        pState->next_in = (Bytef *)pBuf;
+        pState->avail_in = 0;
+    }
+    if( bReading == false )
+        throw ExceptionBase("This deflate filter is in writing mode, you can't read.");
+
+    int nRead = 0;
+    int nReadTotal = pState->total_out;
+    pState->next_out = (Bytef *)pData;
+    pState->avail_out = nBytes;
+    for(;;)
+    {
+        int ret = inflate( pState, Z_NO_FLUSH );
+        nReadTotal += nRead-pState->avail_out;
+
+        if( ret == Z_STREAM_END )
+        {
+            bEos = true;
+            if( pState->avail_in > 0 )
+            {
+                if( rNext.isSeekable() )
+                {
+                    rNext.seek( -pState->avail_in );
+                }
+            }
+            return nBytes-pState->avail_out;
+        }
+        if( ret != Z_BUF_ERROR )
+            zError( ret );
+
+        if( pState->avail_out )
+        {
+            if( pState->avail_in == 0 )
+            {
+                nRead = rNext.read( pBuf, nBufSize );
+                if( nRead == 0 && rNext.isEos() )
+                {
+                    throw Bu::ExceptionBase("Premature end of underlying "
+                            "stream found reading deflate stream.");
+                }
+                pState->next_in = (Bytef *)pBuf;
+                pState->avail_in = nRead;
+            }
+        }
+        else
+        {
+            return nBytes-pState->avail_out;
+        }
+    }
+    return 0;
 }
 
 Bu::size Bu::Deflate::write( const void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( nBytes  <= 0 )
-                return 0;
-        if( !pState->state )
-        {
-                bReading = false;
-                int iFmt = eFmt&Gzip;
-                if( iFmt == Raw )
-                        deflateInit2( pState, nCompression, Z_DEFLATED, -15, 9,
-                                Z_DEFAULT_STRATEGY );
-                else if( iFmt == Zlib )
-                        deflateInit2( pState, nCompression, Z_DEFLATED, 15, 9,
-                                Z_DEFAULT_STRATEGY );
-                else if( iFmt == Gzip )
-                        deflateInit2( pState, nCompression, Z_DEFLATED, 16+15, 9,
-                                Z_DEFAULT_STRATEGY );
-                else
-                        throw Bu::ExceptionBase("Invalid format for deflate.");
-        }
-        if( bReading == true )
-                throw ExceptionBase("This deflate filter is in reading mode, you can't write.");
-
-        pState->next_in = (Bytef *)pData;
-        pState->avail_in = nBytes;
-        for(;;)
-        {
-                pState->avail_out = nBufSize;
-                pState->next_out = (Bytef *)pBuf;
-
-                zError( deflate( pState, Z_NO_FLUSH ) );
-
-                if( pState->avail_out < nBufSize )
-                {
-                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                }
-                if( pState->avail_in == 0 )
-                        break;
-        }
-
-        return nBytes;
+    TRACE( pData, nBytes );
+    if( nBytes  <= 0 )
+        return 0;
+    if( !pState->state )
+    {
+        bReading = false;
+        int iFmt = eFmt&Gzip;
+        if( iFmt == Raw )
+            deflateInit2( pState, nCompression, Z_DEFLATED, -15, 9,
+                Z_DEFAULT_STRATEGY );
+        else if( iFmt == Zlib )
+            deflateInit2( pState, nCompression, Z_DEFLATED, 15, 9,
+                Z_DEFAULT_STRATEGY );
+        else if( iFmt == Gzip )
+            deflateInit2( pState, nCompression, Z_DEFLATED, 16+15, 9,
+                Z_DEFAULT_STRATEGY );
+        else
+            throw Bu::ExceptionBase("Invalid format for deflate.");
+    }
+    if( bReading == true )
+        throw ExceptionBase("This deflate filter is in reading mode, you can't write.");
+
+    pState->next_in = (Bytef *)pData;
+    pState->avail_in = nBytes;
+    for(;;)
+    {
+        pState->avail_out = nBufSize;
+        pState->next_out = (Bytef *)pBuf;
+
+        zError( deflate( pState, Z_NO_FLUSH ) );
+
+        if( pState->avail_out < nBufSize )
+        {
+            sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+        }
+        if( pState->avail_in == 0 )
+            break;
+    }
+
+    return nBytes;
 }
 
 bool Bu::Deflate::isOpen()
 {
-        TRACE();
-        return (pState != NULL && pState->state != NULL);
+    TRACE();
+    return (pState != NULL && pState->state != NULL);
 }
 
 bool Bu::Deflate::isEos()
 {
-        TRACE();
-        return bEos;
+    TRACE();
+    return bEos;
 }
 
 Bu::size Bu::Deflate::getCompressedSize()
 {
-        return sTotalOut;
+    return sTotalOut;
 }
 
diff --git a/src/stable/deflate.h b/src/stable/deflate.h
index 114b173..2ccd53f 100644
--- a/src/stable/deflate.h
+++ b/src/stable/deflate.h
@@ -14,53 +14,53 @@
 
 namespace Bu
 {
-        /**
-         * Provides Deflate (LZ77) support via zlib.  This provides zlib, raw, and
-         * gzip stream types.  By default it will autodetect the input type and
-         * encode into a raw deflate stream.
-         *
-         *@ingroup Streams
-         *@ingroup Compression
-         */
-        class Deflate : public Bu::Filter
-        {
-        public:
-                enum Format
-                {
-                        Raw                     = 0x01,
-                        Zlib            = 0x02,
-                        Gzip            = 0x03,
-                        AutoDetect      = 0x04,
+    /**
+     * Provides Deflate (LZ77) support via zlib.  This provides zlib, raw, and
+     * gzip stream types.  By default it will autodetect the input type and
+     * encode into a raw deflate stream.
+     *
+     *@ingroup Streams
+     *@ingroup Compression
+     */
+    class Deflate : public Bu::Filter
+    {
+    public:
+        enum Format
+        {
+            Raw         = 0x01,
+            Zlib        = 0x02,
+            Gzip        = 0x03,
+            AutoDetect  = 0x04,
 
-                        AutoRaw         = 0x04|0x01,
-                        AutoZlib        = 0x04|0x02,
-                        AutoGzip        = 0x04|0x03
-                };
+            AutoRaw     = 0x04|0x01,
+            AutoZlib    = 0x04|0x02,
+            AutoGzip    = 0x04|0x03
+        };
 
-                Deflate( Bu::Stream &rNext, int nCompression=-1, Format eFmt=AutoZlib );
-                virtual ~Deflate();
+        Deflate( Bu::Stream &rNext, int nCompression=-1, Format eFmt=AutoZlib );
+        virtual ~Deflate();
 
-                virtual void start();
-                virtual Bu::size stop();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        virtual void start();
+        virtual Bu::size stop();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
 
-                virtual bool isOpen();
-                virtual bool isEos();
+        virtual bool isOpen();
+        virtual bool isEos();
 
-                Bu::size getCompressedSize();
+        Bu::size getCompressedSize();
 
-        private:
-                void zError( int code );
-                void *prState;
-                bool bReading;
-                int nCompression;
-                char *pBuf;
-                uint32_t nBufSize;
-                Bu::size sTotalOut;
-                Format eFmt;
-                bool bEos;
-        };
+    private:
+        void zError( int code );
+        void *prState;
+        bool bReading;
+        int nCompression;
+        char *pBuf;
+        uint32_t nBufSize;
+        Bu::size sTotalOut;
+        Format eFmt;
+        bool bEos;
+    };
 }
 
 #endif
diff --git a/src/stable/exceptionbase.cpp b/src/stable/exceptionbase.cpp
index 87e7127..22f338f 100644
--- a/src/stable/exceptionbase.cpp
+++ b/src/stable/exceptionbase.cpp
@@ -11,83 +11,83 @@
 #include <stdio.h>
 
 Bu::ExceptionBase::ExceptionBase( const char *lpFormat, ... ) throw() :
-        nErrorCode( 0 ),
-        sWhat( NULL )
+    nErrorCode( 0 ),
+    sWhat( NULL )
 {
-        va_list ap;
+    va_list ap;
 
-        va_start(ap, lpFormat);
-        setWhat( lpFormat, ap );
-        va_end(ap);
+    va_start(ap, lpFormat);
+    setWhat( lpFormat, ap );
+    va_end(ap);
 }
 
 Bu::ExceptionBase::ExceptionBase( int nCode, const char *lpFormat, ... ) throw() :
-        nErrorCode( nCode ),
-        sWhat( NULL )
+    nErrorCode( nCode ),
+    sWhat( NULL )
 {
-        va_list ap;
+    va_list ap;
 
-        va_start(ap, lpFormat);
-        setWhat( lpFormat, ap );
-        va_end(ap);
+    va_start(ap, lpFormat);
+    setWhat( lpFormat, ap );
+    va_end(ap);
 }
 
 Bu::ExceptionBase::ExceptionBase( int nCode ) throw() :
-        nErrorCode( nCode ),
-        sWhat( NULL )
+    nErrorCode( nCode ),
+    sWhat( NULL )
 {
 }
 
 Bu::ExceptionBase::ExceptionBase( const ExceptionBase &e ) throw () :
-        std::exception( e ),
-        nErrorCode( e.nErrorCode ),
-        sWhat( NULL )
+    std::exception( e ),
+    nErrorCode( e.nErrorCode ),
+    sWhat( NULL )
 {
-        setWhat( e.sWhat );
+    setWhat( e.sWhat );
 }
 
 Bu::ExceptionBase::~ExceptionBase() throw()
 {
-        delete[] sWhat;
-        sWhat = NULL;
+    delete[] sWhat;
+    sWhat = NULL;
 }
 
 void Bu::ExceptionBase::setWhat( const char *lpFormat, va_list &vargs )
 {
-        if( sWhat ) delete[] sWhat;
-        int nSize;
-
-        va_list vargs2;
-        va_copy( vargs2, vargs );
-        nSize = vsnprintf( NULL, 0, lpFormat, vargs2 );
-        va_end( vargs2 );
-        sWhat = new char[nSize+1];
-        vsnprintf( sWhat, nSize+1, lpFormat, vargs );
+    if( sWhat ) delete[] sWhat;
+    int nSize;
+
+    va_list vargs2;
+    va_copy( vargs2, vargs );
+    nSize = vsnprintf( NULL, 0, lpFormat, vargs2 );
+    va_end( vargs2 );
+    sWhat = new char[nSize+1];
+    vsnprintf( sWhat, nSize+1, lpFormat, vargs );
 }
 
 void Bu::ExceptionBase::setWhat( const char *lpText )
 {
-        if( sWhat ) delete[] sWhat;
-        int nSize;
+    if( sWhat ) delete[] sWhat;
+    int nSize;
 
-        nSize = strlen( lpText );
-        sWhat = new char[nSize+1];
-        strcpy( sWhat, lpText );
+    nSize = strlen( lpText );
+    sWhat = new char[nSize+1];
+    strcpy( sWhat, lpText );
 }
 
 const char *Bu::ExceptionBase::what() const throw()
 {
-        return sWhat;
+    return sWhat;
 }
 
 int Bu::ExceptionBase::getErrorCode()
 {
-        return nErrorCode;
+    return nErrorCode;
 }
 
 Bu::UnsupportedException::UnsupportedException() throw() :
-        ExceptionBase( 0 )
+    ExceptionBase( 0 )
 {
-        setWhat("An unsupperted operation was attempted.");
+    setWhat("An unsupperted operation was attempted.");
 }
 
diff --git a/src/stable/exceptionbase.h b/src/stable/exceptionbase.h
index 9e6c72d..8f651b7 100644
--- a/src/stable/exceptionbase.h
+++ b/src/stable/exceptionbase.h
@@ -18,173 +18,173 @@
 
 namespace Bu
 {
-        /**
-         * A generalized Exception base class.  This is nice for making general and
-         * flexible child classes that can create new error code classes.
-         *
-         * In order to create your own exception class use these two lines.
-         * 
-         * in your header:  subExceptionDecl( NewClassName );
-         * 
-         * in your source:  subExcpetienDef( NewClassName );
-         */
-        class ExceptionBase : public std::exception
-        {
-        public:
-                /**
-                 * Construct an exception with an error code of zero, but with a
-                 * description.  The use of this is not reccomended most of the time,
-                 * it's generally best to include an error code with the exception so
-                 * your program can handle the exception in a better way.
-                 * @param sFormat The format of the text.  See printf for more info.
-                 */
-                ExceptionBase( const char *sFormat, ... ) throw();
-                
-                /**
-                 * 
-                 * @param nCode 
-                 * @param sFormat
-                 */
-                ExceptionBase( int nCode, const char *sFormat, ... ) throw();
-                
-                /**
-                 * 
-                 * @param nCode 
-                 * @return 
-                 */
-                ExceptionBase( int nCode=0 ) throw();
-
-                ExceptionBase( const ExceptionBase &e ) throw ();
-                
-                /**
-                 * 
-                 * @return 
-                 */
-                virtual ~ExceptionBase() throw();
-
-                /**
-                 * 
-                 * @return 
-                 */
-                virtual const char *what() const throw();
-                
-                /**
-                 * 
-                 * @return 
-                 */
-                int getErrorCode();
-                
-                /**
-                 * 
-                 * @param lpFormat 
-                 * @param vargs 
-                 */
-                void setWhat( const char *lpFormat, va_list &vargs );
-
-                /**
-                 *
-                 * @param lpText
-                 */
-                void setWhat( const char *lpText );
-
-        private:
-                int nErrorCode; /**< The code for the error that occured. */
-                char *sWhat;    /**< The text string telling people what went wrong. */
-        };
+    /**
+     * A generalized Exception base class.  This is nice for making general and
+     * flexible child classes that can create new error code classes.
+     *
+     * In order to create your own exception class use these two lines.
+     * 
+     * in your header:  subExceptionDecl( NewClassName );
+     * 
+     * in your source:  subExcpetienDef( NewClassName );
+     */
+    class ExceptionBase : public std::exception
+    {
+    public:
+        /**
+         * Construct an exception with an error code of zero, but with a
+         * description.  The use of this is not reccomended most of the time,
+         * it's generally best to include an error code with the exception so
+         * your program can handle the exception in a better way.
+         * @param sFormat The format of the text.  See printf for more info.
+         */
+        ExceptionBase( const char *sFormat, ... ) throw();
+        
+        /**
+         * 
+         * @param nCode 
+         * @param sFormat
+         */
+        ExceptionBase( int nCode, const char *sFormat, ... ) throw();
+        
+        /**
+         * 
+         * @param nCode 
+         * @return 
+         */
+        ExceptionBase( int nCode=0 ) throw();
+
+        ExceptionBase( const ExceptionBase &e ) throw ();
+        
+        /**
+         * 
+         * @return 
+         */
+        virtual ~ExceptionBase() throw();
+
+        /**
+         * 
+         * @return 
+         */
+        virtual const char *what() const throw();
+        
+        /**
+         * 
+         * @return 
+         */
+        int getErrorCode();
+        
+        /**
+         * 
+         * @param lpFormat 
+         * @param vargs 
+         */
+        void setWhat( const char *lpFormat, va_list &vargs );
+
+        /**
+         *
+         * @param lpText
+         */
+        void setWhat( const char *lpText );
+
+    private:
+        int nErrorCode; /**< The code for the error that occured. */
+        char *sWhat;    /**< The text string telling people what went wrong. */
+    };
 }
 
-#define subExceptionDecl( name )                                                                                        \
-class name : public Bu::ExceptionBase                                                                                   \
-{                                                                                                                                                       \
-        public:                                                                                                                                 \
-                name( const char *sFormat, ... ) throw ();                                                      \
-                name( int nCode, const char *sFormat, ... ) throw();                            \
-                name( int nCode=0 ) throw ();                                                                           \
-                name( const name &e ) throw ();                                                                         \
+#define subExceptionDecl( name )                                            \
+class name : public Bu::ExceptionBase                                           \
+{                                                                           \
+    public:                                                                 \
+        name( const char *sFormat, ... ) throw ();                          \
+        name( int nCode, const char *sFormat, ... ) throw();                \
+        name( int nCode=0 ) throw ();                                       \
+        name( const name &e ) throw ();                                     \
 };
 
-#define subExceptionDeclChild( name, parent )                                                           \
-class name : public parent                                                                                                      \
-{                                                                                                                                                       \
-        public:                                                                                                                                 \
-                name( const char *sFormat, ... ) throw ();                                                      \
-                name( int nCode, const char *sFormat, ... ) throw();                            \
-                name( int nCode=0 ) throw ();                                                                           \
-                name( const name &e ) throw ();                                                                         \
+#define subExceptionDeclChild( name, parent )                               \
+class name : public parent                                                  \
+{                                                                           \
+    public:                                                                 \
+        name( const char *sFormat, ... ) throw ();                          \
+        name( int nCode, const char *sFormat, ... ) throw();                \
+        name( int nCode=0 ) throw ();                                       \
+        name( const name &e ) throw ();                                     \
 };
 
-#define subExceptionDeclBegin( name )                                                                           \
-class name : public Bu::ExceptionBase                                                                           \
-{                                                                                                                                                       \
-        public:                                                                                                                                 \
-                name( const char *sFormat, ... ) throw ();                                                      \
-                name( int nCode, const char *sFormat, ... ) throw();                            \
-                name( int nCode=0 ) throw ();                                                                           \
-                name( const name &e ) throw ();
+#define subExceptionDeclBegin( name )                                       \
+class name : public Bu::ExceptionBase                                       \
+{                                                                           \
+    public:                                                                 \
+        name( const char *sFormat, ... ) throw ();                          \
+        name( int nCode, const char *sFormat, ... ) throw();                \
+        name( int nCode=0 ) throw ();                                       \
+        name( const name &e ) throw ();
 
-#define subExceptionDeclEnd()                                                                                           \
+#define subExceptionDeclEnd()                                               \
 };
 
-#define subExceptionDef( name )                                                                                         \
-name::name( const char *lpFormat, ... ) throw() :                                                       \
-        ExceptionBase( 0 )                                                                                                              \
-{                                                                                                                                                       \
-        va_list ap;                                                                                                                             \
-        va_start( ap, lpFormat );                                                                                               \
-        setWhat( lpFormat, ap );                                                                                                \
-        va_end( ap );                                                                                                                   \
-}                                                                                                                                                       \
-name::name( int nCode, const char *lpFormat, ... ) throw() :                            \
-        ExceptionBase( nCode )                                                                                                  \
-{                                                                                                                                                       \
-        va_list ap;                                                                                                                             \
-        va_start( ap, lpFormat );                                                                                               \
-        setWhat( lpFormat, ap );                                                                                                \
-        va_end( ap );                                                                                                                   \
-}                                                                                                                                                       \
-name::name( int nCode ) throw() :                                                                                       \
-        ExceptionBase( nCode )                                                                                                  \
-{                                                                                                                                                       \
-}                                                                                                                                                       \
-name::name( const name &e ) throw() :                                                                           \
-        ExceptionBase( e )                                                                                                              \
-{                                                                                                                                                       \
+#define subExceptionDef( name )                                             \
+name::name( const char *lpFormat, ... ) throw() :                           \
+    ExceptionBase( 0 )                                                      \
+{                                                                           \
+    va_list ap;                                                             \
+    va_start( ap, lpFormat );                                               \
+    setWhat( lpFormat, ap );                                                \
+    va_end( ap );                                                           \
+}                                                                           \
+name::name( int nCode, const char *lpFormat, ... ) throw() :                \
+    ExceptionBase( nCode )                                                  \
+{                                                                           \
+    va_list ap;                                                             \
+    va_start( ap, lpFormat );                                               \
+    setWhat( lpFormat, ap );                                                \
+    va_end( ap );                                                           \
+}                                                                           \
+name::name( int nCode ) throw() :                                           \
+    ExceptionBase( nCode )                                                  \
+{                                                                           \
+}                                                                           \
+name::name( const name &e ) throw() :                                       \
+    ExceptionBase( e )                                                      \
+{                                                                           \
 }
 
-#define subExceptionDefChild( name, parent )                                                            \
-name::name( const char *lpFormat, ... ) throw() :                                                       \
-        parent( 0 )                                                                                                                             \
-{                                                                                                                                                       \
-        va_list ap;                                                                                                                             \
-        va_start( ap, lpFormat );                                                                                               \
-        setWhat( lpFormat, ap );                                                                                                \
-        va_end( ap );                                                                                                                   \
-}                                                                                                                                                       \
-name::name( int nCode, const char *lpFormat, ... ) throw() :                            \
-        parent( nCode )                                                                                                                 \
-{                                                                                                                                                       \
-        va_list ap;                                                                                                                             \
-        va_start( ap, lpFormat );                                                                                               \
-        setWhat( lpFormat, ap );                                                                                                \
-        va_end( ap );                                                                                                                   \
-}                                                                                                                                                       \
-name::name( int nCode ) throw() :                                                                                       \
-        parent( nCode )                                                                                                                 \
-{                                                                                                                                                       \
-}                                                                                                                                                       \
-name::name( const name &e ) throw() :                                                                           \
-        ExceptionBase( e )                                                                                                              \
-{                                                                                                                                                       \
+#define subExceptionDefChild( name, parent )                                \
+name::name( const char *lpFormat, ... ) throw() :                           \
+    parent( 0 )                                                             \
+{                                                                           \
+    va_list ap;                                                             \
+    va_start( ap, lpFormat );                                               \
+    setWhat( lpFormat, ap );                                                \
+    va_end( ap );                                                           \
+}                                                                           \
+name::name( int nCode, const char *lpFormat, ... ) throw() :                \
+    parent( nCode )                                                         \
+{                                                                           \
+    va_list ap;                                                             \
+    va_start( ap, lpFormat );                                               \
+    setWhat( lpFormat, ap );                                                \
+    va_end( ap );                                                           \
+}                                                                           \
+name::name( int nCode ) throw() :                                           \
+    parent( nCode )                                                         \
+{                                                                           \
+}                                                                           \
+name::name( const name &e ) throw() :                                       \
+    ExceptionBase( e )                                                      \
+{                                                                           \
 }
 
 namespace Bu
 {
-        // Exceptions that are so general they could be used anywhere go here.
-        class UnsupportedException : public Bu::ExceptionBase
-        {
-        public:
-                UnsupportedException() throw ();
-        };
+    // Exceptions that are so general they could be used anywhere go here.
+    class UnsupportedException : public Bu::ExceptionBase
+    {
+    public:
+        UnsupportedException() throw ();
+    };
 }
 
 #endif
diff --git a/src/stable/extratypes.h b/src/stable/extratypes.h
index 2961920..3549529 100644
--- a/src/stable/extratypes.h
+++ b/src/stable/extratypes.h
@@ -19,11 +19,11 @@
 namespace Bu
 {
 #ifdef USE_64BIT_IO
-        typedef int64_t         size;
-        typedef uint64_t        usize;
+    typedef int64_t     size;
+    typedef uint64_t    usize;
 #else
-        typedef int32_t         size;
-        typedef uint32_t        usize;
+    typedef int32_t     size;
+    typedef uint32_t    usize;
 #endif
 };
 
diff --git a/src/stable/file.cpp b/src/stable/file.cpp
index 14e4f3c..7ae2484 100644
--- a/src/stable/file.cpp
+++ b/src/stable/file.cpp
@@ -19,298 +19,298 @@
 namespace Bu { subExceptionDef( FileException ) }
 
 Bu::File::File( const Bu::String &sName, int iFlags ) :
-        fd( -1 ),
-        bEos( true )
+    fd( -1 ),
+    bEos( true )
 {
 #ifdef USE_64BIT_IO
-        fd = ::open64( sName.getStr(), getPosixFlags( iFlags ), 0666 );
+    fd = ::open64( sName.getStr(), getPosixFlags( iFlags ), 0666 );
 #else
-        fd = ::open( sName.getStr(), getPosixFlags( iFlags ), 0666 );
+    fd = ::open( sName.getStr(), getPosixFlags( iFlags ), 0666 );
 #endif
-        if( fd < 0 )
-        {
-                throw Bu::FileException( errno, "%s: %s",
-                        strerror(errno), sName.getStr() );
-        }
-        bEos = false;
+    if( fd < 0 )
+    {
+        throw Bu::FileException( errno, "%s: %s",
+            strerror(errno), sName.getStr() );
+    }
+    bEos = false;
 }
 
 Bu::File::File( int fd ) :
-        fd( fd )
+    fd( fd )
 {
-        bEos = false;
+    bEos = false;
 }
 
 Bu::File::~File()
 {
-        close();
+    close();
 }
 
 void Bu::File::close()
 {
-        if( fd >= 0 )
-        {
-                if( ::close( fd ) )
-                {
-                        throw Bu::FileException( errno, "%s",
-                                strerror(errno) );
-                }
-                fd = -1;
-                bEos = true;
-        }
+    if( fd >= 0 )
+    {
+        if( ::close( fd ) )
+        {
+            throw Bu::FileException( errno, "%s",
+                strerror(errno) );
+        }
+        fd = -1;
+        bEos = true;
+    }
 }
 
 Bu::size Bu::File::read( void *pBuf, Bu::size nBytes )
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
-
-        Bu::size iRead = ::read( fd, pBuf, nBytes );
-        if( iRead == 0 )
-                bEos = true;
-        else if( iRead == -1 && errno == EAGAIN )
-                return 0;
-        else if( iRead < 0 )
-                throw FileException( errno, "%s", strerror( errno ) );
-        return iRead;
+    if( fd < 0 )
+        throw FileException("File not open.");
+
+    Bu::size iRead = ::read( fd, pBuf, nBytes );
+    if( iRead == 0 )
+        bEos = true;
+    else if( iRead == -1 && errno == EAGAIN )
+        return 0;
+    else if( iRead < 0 )
+        throw FileException( errno, "%s", strerror( errno ) );
+    return iRead;
 }
 
 Bu::size Bu::File::write( const void *pBuf, Bu::size nBytes )
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
+    if( fd < 0 )
+        throw FileException("File not open.");
 
-        Bu::size iWrote = ::write( fd, pBuf, nBytes );
-        if( iWrote < 0 )
-                throw FileException( errno, "%s", strerror( errno ) );
-        return iWrote;
+    Bu::size iWrote = ::write( fd, pBuf, nBytes );
+    if( iWrote < 0 )
+        throw FileException( errno, "%s", strerror( errno ) );
+    return iWrote;
 }
 
 Bu::size Bu::File::tell()
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
+    if( fd < 0 )
+        throw FileException("File not open.");
 
 #ifdef USE_64BIT_IO
-        return lseek64( fd, 0, SEEK_CUR );
+    return lseek64( fd, 0, SEEK_CUR );
 #else
-        return lseek( fd, 0, SEEK_CUR );
+    return lseek( fd, 0, SEEK_CUR );
 #endif
 }
 
 void Bu::File::seek( Bu::size offset )
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
+    if( fd < 0 )
+        throw FileException("File not open.");
 
 #ifdef USE_64BIT_IO
-        lseek64( fd, offset, SEEK_CUR );
+    lseek64( fd, offset, SEEK_CUR );
 #else
-        lseek( fd, offset, SEEK_CUR );
+    lseek( fd, offset, SEEK_CUR );
 #endif
-        bEos = false;
+    bEos = false;
 }
 
 void Bu::File::setPos( Bu::size pos )
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
+    if( fd < 0 )
+        throw FileException("File not open.");
 
 #ifdef USE_64BIT_IO
-        lseek64( fd, pos, SEEK_SET );
+    lseek64( fd, pos, SEEK_SET );
 #else
-        lseek( fd, pos, SEEK_SET );
+    lseek( fd, pos, SEEK_SET );
 #endif
-        bEos = false;
+    bEos = false;
 }
 
 void Bu::File::setPosEnd( Bu::size pos )
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
-        
-        lseek64( fd, pos, SEEK_END );
-        bEos = false;
+    if( fd < 0 )
+        throw FileException("File not open.");
+    
+    lseek64( fd, pos, SEEK_END );
+    bEos = false;
 }
 
 bool Bu::File::isEos()
 {
-        return bEos;
+    return bEos;
 }
 
 bool Bu::File::canRead()
 {
 #ifdef WIN32
-        return true;
+    return true;
 #else
-        int iMode = fcntl( fd, F_GETFL, 0 )&O_ACCMODE;
-        if( iMode == O_RDONLY || iMode == O_RDWR )
-                return true;
-        return false;
+    int iMode = fcntl( fd, F_GETFL, 0 )&O_ACCMODE;
+    if( iMode == O_RDONLY || iMode == O_RDWR )
+        return true;
+    return false;
 #endif
 }
 
 bool Bu::File::canWrite()
 {
 #ifdef WIN32
-        return true;
+    return true;
 #else
-        int iMode = fcntl( fd, F_GETFL, 0 )&O_ACCMODE;
-        if( iMode == O_WRONLY || iMode == O_RDWR )
-                return true;
-        return false;
+    int iMode = fcntl( fd, F_GETFL, 0 )&O_ACCMODE;
+    if( iMode == O_WRONLY || iMode == O_RDWR )
+        return true;
+    return false;
 #endif
 }
 
 bool Bu::File::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::File::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::File::isSeekable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::File::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::File::setBlocking( bool bBlocking )
 {
 #ifdef WIN32
-        fprintf(stderr, "STUB: Bu::File::setBlocking\n");
+    fprintf(stderr, "STUB: Bu::File::setBlocking\n");
 #else
-        if( bBlocking )
-                fcntl( 
-                        fd,
-                        F_SETFL, fcntl( fd, F_GETFL, 0 )&(~O_NONBLOCK)
-                        );
-        else
-                fcntl( 
-                        fd,
-                        F_SETFL, fcntl( fd, F_GETFL, 0 )|O_NONBLOCK
-                        );
+    if( bBlocking )
+        fcntl( 
+            fd,
+            F_SETFL, fcntl( fd, F_GETFL, 0 )&(~O_NONBLOCK)
+            );
+    else
+        fcntl( 
+            fd,
+            F_SETFL, fcntl( fd, F_GETFL, 0 )|O_NONBLOCK
+            );
 #endif
 }
 
 Bu::File Bu::File::tempFile( Bu::String &sName )
 {
-        int iXes;
-        for( iXes = sName.getSize()-1; iXes >= 0; iXes-- )
-        {
-                if( sName[iXes] != 'X' )
-                        break;
-        }
-        iXes++;
-        if( iXes == sName.getSize() )
-                throw Bu::ExceptionBase("Invalid temporary filename template.");
-        for( int iter = 0; iter < 1000; iter++ )
-        {
-                for( int j = iXes; j < sName.getSize(); j++ )
-                {
-                        uint32_t iX = Bu::Random::rand();
-                        sName[j] = ('A'+(iX%26)) | ((iX&0x1000)?(0x20):(0));
-                }
-
-                try
-                {
-                        return Bu::File( sName, Bu::File::Read|Bu::File::Write
-                                        |Bu::File::Create|Bu::File::Exclusive );
-                } catch(...) { }
-        }
-        throw Bu::FileException("Failed to create unique temporary file after 1000"
-                        " iterations.");
+    int iXes;
+    for( iXes = sName.getSize()-1; iXes >= 0; iXes-- )
+    {
+        if( sName[iXes] != 'X' )
+            break;
+    }
+    iXes++;
+    if( iXes == sName.getSize() )
+        throw Bu::ExceptionBase("Invalid temporary filename template.");
+    for( int iter = 0; iter < 1000; iter++ )
+    {
+        for( int j = iXes; j < sName.getSize(); j++ )
+        {
+            uint32_t iX = Bu::Random::rand();
+            sName[j] = ('A'+(iX%26)) | ((iX&0x1000)?(0x20):(0));
+        }
+
+        try
+        {
+            return Bu::File( sName, Bu::File::Read|Bu::File::Write
+                    |Bu::File::Create|Bu::File::Exclusive );
+        } catch(...) { }
+    }
+    throw Bu::FileException("Failed to create unique temporary file after 1000"
+            " iterations.");
 }
 
 void Bu::File::setSize( Bu::size iSize )
 {
 #ifdef WIN32
-        chsize( fd, iSize );
+    chsize( fd, iSize );
 #else
-        ftruncate( fd, iSize );
+    ftruncate( fd, iSize );
 #endif
 }
 
 Bu::size Bu::File::getSize() const
 {
-        struct stat st;
-        fstat( fd, &st );
-        return st.st_size;
+    struct stat st;
+    fstat( fd, &st );
+    return st.st_size;
 }
 
 Bu::size Bu::File::getBlockSize() const
 {
 #ifdef WIN32
-        return 4096;
+    return 4096;
 #else
-        struct stat st;
-        fstat( fd, &st );
-        return st.st_blksize;
+    struct stat st;
+    fstat( fd, &st );
+    return st.st_blksize;
 #endif
 }
 
 Bu::String Bu::File::getLocation() const
 {
-        return "to be implemented";
+    return "to be implemented";
 }
 
 #ifndef WIN32
 void Bu::File::chmod( mode_t t )
 {
-        fchmod( fd, t );
+    fchmod( fd, t );
 }
 #endif
 
 void Bu::File::flush()
 {
-        // There is no flushing with direct I/O...
-        //fflush( fh );
+    // There is no flushing with direct I/O...
+    //fflush( fh );
 }
 
 bool Bu::File::isOpen()
 {
-        return (fd > -1);
+    return (fd > -1);
 }
 
 int Bu::File::getPosixFlags( int iFlags )
 {
-        int iRet = 0;
-        switch( (iFlags&ReadWrite) )
-        {
-                // According to posix, O_RDWR is not necesarilly O_RDONLY|O_WRONLY, so
-                // lets be proper and use the right value in the right place.
-                case Read:              iRet = O_RDONLY; break;
-                case Write:             iRet = O_WRONLY; break;
-                case ReadWrite: iRet = O_RDWR; break;
-                default:
-                        throw FileException(
-                                "You must specify Read, Write, or both when opening a file.");
-        }
-
-        if( (iFlags&Create) )
-                iRet |= O_CREAT;
-        if( (iFlags&Append) )
-                iRet |= O_APPEND;
-        if( (iFlags&Truncate) )
-                iRet |= O_TRUNC;
+    int iRet = 0;
+    switch( (iFlags&ReadWrite) )
+    {
+        // According to posix, O_RDWR is not necesarilly O_RDONLY|O_WRONLY, so
+        // lets be proper and use the right value in the right place.
+        case Read:      iRet = O_RDONLY; break;
+        case Write:     iRet = O_WRONLY; break;
+        case ReadWrite: iRet = O_RDWR; break;
+        default:
+            throw FileException(
+                "You must specify Read, Write, or both when opening a file.");
+    }
+
+    if( (iFlags&Create) )
+        iRet |= O_CREAT;
+    if( (iFlags&Append) )
+        iRet |= O_APPEND;
+    if( (iFlags&Truncate) )
+        iRet |= O_TRUNC;
 #ifndef WIN32
-        if( (iFlags&NonBlock) )
-                iRet |= O_NONBLOCK;
+    if( (iFlags&NonBlock) )
+        iRet |= O_NONBLOCK;
 #endif
-        if( (iFlags&Exclusive) == Exclusive )
-                iRet |= O_EXCL;
+    if( (iFlags&Exclusive) == Exclusive )
+        iRet |= O_EXCL;
 
 #ifdef O_BINARY
-        iRet |= O_BINARY;
+    iRet |= O_BINARY;
 #endif
 
-        return iRet;
+    return iRet;
 }
 
diff --git a/src/stable/file.h b/src/stable/file.h
index eaf2974..2ecb27e 100644
--- a/src/stable/file.h
+++ b/src/stable/file.h
@@ -17,90 +17,90 @@
 
 namespace Bu
 {
-        subExceptionDecl( FileException );
-
-        /**
-         * A file stream.
-         *@ingroup Streams
-         */
-        class File : public Bu::Stream
-        {
-        public:
-                File( const Bu::String &sName, int iFlags );
-                File( int fd );
-                virtual ~File();
-
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
-
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-
-                virtual void flush();
-
-                virtual bool canRead();
-                virtual bool canWrite();
-
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-
-                enum {
-                        // Flags
-                        Read            = 0x01, ///< Open file for reading
-                        Write           = 0x02, ///< Open file for writing
-                        Create          = 0x04, ///< Create file if it doesn't exist
-                        Truncate        = 0x08, ///< Truncate file if it does exist
-                        Append          = 0x10, ///< Always append on every write
-                        NonBlock        = 0x20, ///< Open file in non-blocking mode
-                        Exclusive       = 0x44, ///< Create file, if it exists then fail
-
-                        // Helpful mixes
-                        ReadWrite       = 0x03, ///< Open for reading and writing
-                        WriteNew        = 0x0E  ///< Create a file (or truncate) for writing.
-                                                                /// Same as Write|Create|Truncate
-                };
-
-                virtual void setSize( Bu::size iSize );
-
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-
-                /**
-                 * Create a temp file and return its handle.  The file is opened 
-                 * Read/Write.
-                 *@param sName (Bu::String) Give in the form: "/tmp/tmpfileXXXXXXXX"
-                 *              It will alter your (sName) setting the 'X's to random
-                 *              characters.
-                 *@returns (Bu::File) A file object representing your temp file.
-                 */
-                static Bu::File tempFile( Bu::String &sName );
+    subExceptionDecl( FileException );
+
+    /**
+     * A file stream.
+     *@ingroup Streams
+     */
+    class File : public Bu::Stream
+    {
+    public:
+        File( const Bu::String &sName, int iFlags );
+        File( int fd );
+        virtual ~File();
+
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
+
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+
+        virtual void flush();
+
+        virtual bool canRead();
+        virtual bool canWrite();
+
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+
+        enum {
+            // Flags
+            Read        = 0x01, ///< Open file for reading
+            Write       = 0x02, ///< Open file for writing
+            Create      = 0x04, ///< Create file if it doesn't exist
+            Truncate    = 0x08, ///< Truncate file if it does exist
+            Append      = 0x10, ///< Always append on every write
+            NonBlock    = 0x20, ///< Open file in non-blocking mode
+            Exclusive   = 0x44, ///< Create file, if it exists then fail
+
+            // Helpful mixes
+            ReadWrite   = 0x03, ///< Open for reading and writing
+            WriteNew    = 0x0E  ///< Create a file (or truncate) for writing.
+                                /// Same as Write|Create|Truncate
+        };
+
+        virtual void setSize( Bu::size iSize );
+
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+
+        /**
+         * Create a temp file and return its handle.  The file is opened 
+         * Read/Write.
+         *@param sName (Bu::String) Give in the form: "/tmp/tmpfileXXXXXXXX"
+         *      It will alter your (sName) setting the 'X's to random
+         *      characters.
+         *@returns (Bu::File) A file object representing your temp file.
+         */
+        static Bu::File tempFile( Bu::String &sName );
 
 #ifndef WIN32
-                /**
-                 * Change the file access permissions.
-                 *@param t (mode_t) The new file access permissions.
-                 */
-                void chmod( mode_t t );
+        /**
+         * Change the file access permissions.
+         *@param t (mode_t) The new file access permissions.
+         */
+        void chmod( mode_t t );
 #endif
 
-        private:
-                int getPosixFlags( int iFlags );
+    private:
+        int getPosixFlags( int iFlags );
 
-        private:
-                int fd;
-                bool bEos;
-        };
+    private:
+        int fd;
+        bool bEos;
+    };
 }
 
 #endif
diff --git a/src/stable/filter.cpp b/src/stable/filter.cpp
index 9c1d66f..e7929e7 100644
--- a/src/stable/filter.cpp
+++ b/src/stable/filter.cpp
@@ -8,7 +8,7 @@
 #include "bu/filter.h"
 
 Bu::Filter::Filter( Bu::Stream &rNext ) :
-        rNext( rNext )
+    rNext( rNext )
 {
 }
 
@@ -18,73 +18,73 @@ Bu::Filter::~Filter()
 
 void Bu::Filter::close()
 {
-        stop();
-        rNext.close();
+    stop();
+    rNext.close();
 }
 
 Bu::size Bu::Filter::tell()
 {
-        return rNext.tell();
+    return rNext.tell();
 }
 
 void Bu::Filter::seek( Bu::size offset )
 {
-        rNext.seek( offset );
+    rNext.seek( offset );
 }
 
 void Bu::Filter::setPos( Bu::size pos )
 {
-        rNext.setPos( pos );
+    rNext.setPos( pos );
 }
 
 void Bu::Filter::setPosEnd( Bu::size pos )
 {
-        rNext.setPosEnd( pos );
+    rNext.setPosEnd( pos );
 }
 
 bool Bu::Filter::isEos()
 {
-        return rNext.isEos();
+    return rNext.isEos();
 }
 
 bool Bu::Filter::isOpen()
 {
-        return rNext.isOpen();
+    return rNext.isOpen();
 }
 
 bool Bu::Filter::canRead()
 {
-        return rNext.canRead();
+    return rNext.canRead();
 }
 
 bool Bu::Filter::canWrite()
 {
-        return rNext.canWrite();
+    return rNext.canWrite();
 }
 
 bool Bu::Filter::isReadable()
 {
-        return rNext.isReadable();
+    return rNext.isReadable();
 }
 
 bool Bu::Filter::isWritable()
 {
-        return rNext.isWritable();
+    return rNext.isWritable();
 }
 
 bool Bu::Filter::isSeekable()
 {
-        return rNext.isSeekable();
+    return rNext.isSeekable();
 }
 
 bool Bu::Filter::isBlocking()
 {
-        return rNext.isBlocking();
+    return rNext.isBlocking();
 }
 
 void Bu::Filter::setBlocking( bool bBlocking )
 {
-        rNext.setBlocking( bBlocking );
+    rNext.setBlocking( bBlocking );
 }
 
 void Bu::Filter::setSize( Bu::size )
@@ -93,21 +93,21 @@ void Bu::Filter::setSize( Bu::size )
 
 void Bu::Filter::flush()
 {
-        rNext.flush();
+    rNext.flush();
 }
 
 Bu::size Bu::Filter::getSize() const
 {
-        return rNext.getSize();
+    return rNext.getSize();
 }
 
 Bu::size Bu::Filter::getBlockSize() const
 {
-        return rNext.getBlockSize();
+    return rNext.getBlockSize();
 }
 
 Bu::String Bu::Filter::getLocation() const
 {
-        return rNext.getLocation();
+    return rNext.getLocation();
 }
 
diff --git a/src/stable/filter.h b/src/stable/filter.h
index 3e1c7d8..49a6664 100644
--- a/src/stable/filter.h
+++ b/src/stable/filter.h
@@ -14,70 +14,70 @@
 
 namespace Bu
 {
-        /**
-         * Data filter base class.  Each data filter should contain a read and write
-         * section.  Effectively, the write applies the filter, the read un-applies
-         * the filter, if possible.  For example, BZip2 is a filter that compresses
-         * on write and decompresses on read.  All bi-directional filters should
-         * follow:  x == read( write( x ) ) (byte-for-byte comparison)
-         *
-         * Also, all returned buffers should be owned by the filter, and deleted
-         * when the filter is deleted.  This means that the output of a read or
-         * write operation must be used before the next call to read or write or the
-         * data will be destroyed.  Also, the internal buffer may be changed or
-         * recreated between calls, so always get a new pointer from a call to
-         * read or write.
-         *
-         * The close function can also return data, so make sure to check for it,
-         * many filters such as compression filters will buffer data until they have
-         * enough to create a compression block, in these cases the leftover data
-         * will be returned by close.
-         *@ingroup Streams
-         */
-        class Filter : public Bu::Stream
-        {
-        public:
-                Filter( Bu::Stream &rNext );
-                virtual ~Filter();
+    /**
+     * Data filter base class.  Each data filter should contain a read and write
+     * section.  Effectively, the write applies the filter, the read un-applies
+     * the filter, if possible.  For example, BZip2 is a filter that compresses
+     * on write and decompresses on read.  All bi-directional filters should
+     * follow:  x == read( write( x ) ) (byte-for-byte comparison)
+     *
+     * Also, all returned buffers should be owned by the filter, and deleted
+     * when the filter is deleted.  This means that the output of a read or
+     * write operation must be used before the next call to read or write or the
+     * data will be destroyed.  Also, the internal buffer may be changed or
+     * recreated between calls, so always get a new pointer from a call to
+     * read or write.
+     *
+     * The close function can also return data, so make sure to check for it,
+     * many filters such as compression filters will buffer data until they have
+     * enough to create a compression block, in these cases the leftover data
+     * will be returned by close.
+     *@ingroup Streams
+     */
+    class Filter : public Bu::Stream
+    {
+    public:
+        Filter( Bu::Stream &rNext );
+        virtual ~Filter();
 
-                virtual void start()=0;
-                virtual Bu::size stop()=0;
-                virtual void close();
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
+        virtual void start()=0;
+        virtual Bu::size stop()=0;
+        virtual void close();
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
 
-                virtual void flush();
+        virtual void flush();
 
-                virtual bool canRead();
-                virtual bool canWrite();
+        virtual bool canRead();
+        virtual bool canWrite();
 
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
 
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
 
-                /**
-                 * Most filters won't re-implement this, it doesn't make a lot of sense
-                 * for filters, in general.
-                 */
-                virtual void setSize( Bu::size iSize );
+        /**
+         * Most filters won't re-implement this, it doesn't make a lot of sense
+         * for filters, in general.
+         */
+        virtual void setSize( Bu::size iSize );
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-                
-        protected:
-                Bu::Stream &rNext;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+        
+    protected:
+        Bu::Stream &rNext;
 
-        private:
+    private:
 
-        };
+    };
 }
 
 #endif
diff --git a/src/stable/fmt.h b/src/stable/fmt.h
index bcc5240..9ecaf80 100644
--- a/src/stable/fmt.h
+++ b/src/stable/fmt.h
@@ -3,92 +3,92 @@
 
 namespace Bu
 {
-        typedef struct Fmt
-        {
-                enum Alignment
-                {
-                        Left    = 0,
-                        Center  = 1,
-                        Right   = 2
-                };
-                Fmt() :
-                        uMinWidth( 0 ),
-                        cFillChar(' '),
-                        uRadix( 10 ),
-                        uAlign( Right ),
-                        bPlus( false ),
-                        bCaps( false ),
-                        bTokenize( true )
-                {
-                }
+    typedef struct Fmt
+    {
+        enum Alignment
+        {
+            Left    = 0,
+            Center  = 1,
+            Right   = 2
+        };
+        Fmt() :
+            uMinWidth( 0 ),
+            cFillChar(' '),
+            uRadix( 10 ),
+            uAlign( Right ),
+            bPlus( false ),
+            bCaps( false ),
+            bTokenize( true )
+        {
+        }
 
-                Fmt( unsigned int uMinWidth, unsigned int uRadix=10,
-                                Alignment a=Right, bool bPlus=false, bool bCaps=true,
-                                char cFill=' ') :
-                        uMinWidth( uMinWidth ),
-                        cFillChar(cFill),
-                        uRadix( uRadix ),
-                        uAlign( a ),
-                        bPlus( bPlus ),
-                        bCaps( bCaps ),
-                        bTokenize( true )
-                {
-                }
-                Fmt( unsigned int uMinWidth, Alignment a,
-                                unsigned int uRadix=10, bool bPlus=false, bool bCaps=true,
-                                char cFill=' ') :
-                        uMinWidth( uMinWidth ),
-                        cFillChar(cFill),
-                        uRadix( uRadix ),
-                        uAlign( a ),
-                        bPlus( bPlus ),
-                        bCaps( bCaps ),
-                        bTokenize( true )
-                {
-                }
+        Fmt( unsigned int uMinWidth, unsigned int uRadix=10,
+                Alignment a=Right, bool bPlus=false, bool bCaps=true,
+                char cFill=' ') :
+            uMinWidth( uMinWidth ),
+            cFillChar(cFill),
+            uRadix( uRadix ),
+            uAlign( a ),
+            bPlus( bPlus ),
+            bCaps( bCaps ),
+            bTokenize( true )
+        {
+        }
+        Fmt( unsigned int uMinWidth, Alignment a,
+                unsigned int uRadix=10, bool bPlus=false, bool bCaps=true,
+                char cFill=' ') :
+            uMinWidth( uMinWidth ),
+            cFillChar(cFill),
+            uRadix( uRadix ),
+            uAlign( a ),
+            bPlus( bPlus ),
+            bCaps( bCaps ),
+            bTokenize( true )
+        {
+        }
 
-                static Fmt hex( unsigned int uWidth=0, bool bCaps=false )
-                {
-                        return Fmt( uWidth, 16, Right, false, bCaps, '0' );
-                }
-                
-                static Fmt oct( unsigned int uWidth=0 )
-                {
-                        return Fmt( uWidth, 8, Right, false, false, '0' );
-                }
+        static Fmt hex( unsigned int uWidth=0, bool bCaps=false )
+        {
+            return Fmt( uWidth, 16, Right, false, bCaps, '0' );
+        }
+        
+        static Fmt oct( unsigned int uWidth=0 )
+        {
+            return Fmt( uWidth, 8, Right, false, false, '0' );
+        }
 
-                static Fmt bin( unsigned int uWidth=0 )
-                {
-                        return Fmt( uWidth, 1, Right, false, false, '0' );
-                }
+        static Fmt bin( unsigned int uWidth=0 )
+        {
+            return Fmt( uWidth, 1, Right, false, false, '0' );
+        }
 
-                static Fmt ptr( bool bCaps=true )
-                {
-                        return Fmt( sizeof(ptrdiff_t)*2, 16, Right, false, bCaps, '0' );
-                }
+        static Fmt ptr( bool bCaps=true )
+        {
+            return Fmt( sizeof(ptrdiff_t)*2, 16, Right, false, bCaps, '0' );
+        }
 
-                Fmt &width( unsigned int uWidth );
-                Fmt &fill( char cFill='0' );
-                Fmt &radix( unsigned int uRadix );
-                Fmt &align( Alignment eAlign );
-                Fmt &plus( bool bPlus=true );
-                Fmt &caps( bool bCaps=true );
-                Fmt &upper();
-                Fmt &lower();
-                Fmt &tokenize( bool bTokenize=true );
+        Fmt &width( unsigned int uWidth );
+        Fmt &fill( char cFill='0' );
+        Fmt &radix( unsigned int uRadix );
+        Fmt &align( Alignment eAlign );
+        Fmt &plus( bool bPlus=true );
+        Fmt &caps( bool bCaps=true );
+        Fmt &upper();
+        Fmt &lower();
+        Fmt &tokenize( bool bTokenize=true );
 
-                Fmt &left();
-                Fmt &right();
-                Fmt &center();
+        Fmt &left();
+        Fmt &right();
+        Fmt &center();
 
-                unsigned char uMinWidth;
-                char cFillChar;
-                unsigned short uRadix : 6;
-                unsigned short uAlign : 2;
-                unsigned short bPlus : 1;
-                unsigned short bCaps : 1;
-                unsigned short bTokenize : 1;
-        } Fmt;
+        unsigned char uMinWidth;
+        char cFillChar;
+        unsigned short uRadix : 6;
+        unsigned short uAlign : 2;
+        unsigned short bPlus : 1;
+        unsigned short bCaps : 1;
+        unsigned short bTokenize : 1;
+    } Fmt;
 };
 
 #endif
diff --git a/src/stable/formatter.cpp b/src/stable/formatter.cpp
index a04f7a6..9a42c99 100644
--- a/src/stable/formatter.cpp
+++ b/src/stable/formatter.cpp
@@ -12,54 +12,54 @@
 
 template<> float Bu::tlog( float x )
 {
-        return logf( x );
+    return logf( x );
 }
 
 template<> double Bu::tlog( double x )
 {
-        return log( x );
+    return log( x );
 }
 
 template<> long double Bu::tlog( long double x )
 {
-        return logl( x );
+    return logl( x );
 }
 
 template<> float Bu::tfloor( float x )
 {
-        return floorf( x );
+    return floorf( x );
 }
 
 template<> double Bu::tfloor( double x )
 {
-        return floor( x );
+    return floor( x );
 }
 
 template<> long double Bu::tfloor( long double x )
 {
-        return floorl( x );
+    return floorl( x );
 }
 
 template<> float Bu::tpow( float x, float y )
 {
-        return powf( x, y );
+    return powf( x, y );
 }
 
 template<> double Bu::tpow( double x, double y )
 {
-        return pow( x, y );
+    return pow( x, y );
 }
 
 template<> long double Bu::tpow( long double x, long double y )
 {
-        return powl( x, y );
+    return powl( x, y );
 }
 
 Bu::Formatter::Formatter( Stream &rStream ) :
-        rStream( rStream ),
-        bTempFmt( false ),
-        uIndent( 0 ),
-        cIndent( '\t' )
+    rStream( rStream ),
+    bTempFmt( false ),
+    uIndent( 0 ),
+    cIndent( '\t' )
 {
 }
 
@@ -69,491 +69,491 @@ Bu::Formatter::~Formatter()
 
 void Bu::Formatter::write( const Bu::String &sStr )
 {
-        rStream.write( sStr );
+    rStream.write( sStr );
 }
 
 void Bu::Formatter::write( const void *sStr, int iLen )
 {
-        rStream.write( sStr, iLen );
+    rStream.write( sStr, iLen );
 }
 
 void Bu::Formatter::writeAligned( const Bu::String &sStr )
 {
-        int iLen = sStr.getSize();
-        if( iLen > fLast.uMinWidth )
-        {
-                write( sStr );
-        }
-        else
-        {
-                int iRem = fLast.uMinWidth - iLen;
-                switch( fLast.uAlign )
-                {
-                        case Fmt::Right:
-                                for( int k = 0; k < iRem; k++ )
-                                        write( &fLast.cFillChar, 1 );
-                                write( sStr );
-                                break;
-                        
-                        case Fmt::Center:
-                                {
-                                        int iHlf = iRem/2;
-                                        for( int k = 0; k < iHlf; k++ )
-                                                write( &fLast.cFillChar, 1 );
-                                        write( sStr );
-                                        iHlf = iRem-iHlf;;
-                                        for( int k = 0; k < iHlf; k++ )
-                                                write( &fLast.cFillChar, 1 );
-                                }
-                                break;
-                        
-                        case Fmt::Left:
-                                write( sStr );
-                                for( int k = 0; k < iRem; k++ )
-                                        write( &fLast.cFillChar, 1 );
-                                break;
-                }
-        }
-
-        usedFormat();
+    int iLen = sStr.getSize();
+    if( iLen > fLast.uMinWidth )
+    {
+        write( sStr );
+    }
+    else
+    {
+        int iRem = fLast.uMinWidth - iLen;
+        switch( fLast.uAlign )
+        {
+            case Fmt::Right:
+                for( int k = 0; k < iRem; k++ )
+                    write( &fLast.cFillChar, 1 );
+                write( sStr );
+                break;
+            
+            case Fmt::Center:
+                {
+                    int iHlf = iRem/2;
+                    for( int k = 0; k < iHlf; k++ )
+                        write( &fLast.cFillChar, 1 );
+                    write( sStr );
+                    iHlf = iRem-iHlf;;
+                    for( int k = 0; k < iHlf; k++ )
+                        write( &fLast.cFillChar, 1 );
+                }
+                break;
+            
+            case Fmt::Left:
+                write( sStr );
+                for( int k = 0; k < iRem; k++ )
+                    write( &fLast.cFillChar, 1 );
+                break;
+        }
+    }
+
+    usedFormat();
 }
 
 void Bu::Formatter::writeAligned( const char *sStr, int iLen )
 {
-        if( iLen > fLast.uMinWidth )
-        {
-                write( sStr, iLen );
-        }
-        else
-        {
-                int iRem = fLast.uMinWidth - iLen;
-                switch( fLast.uAlign )
-                {
-                        case Fmt::Right:
-                                for( int k = 0; k < iRem; k++ )
-                                        write( &fLast.cFillChar, 1 );
-                                write( sStr, iLen );
-                                break;
-                        
-                        case Fmt::Center:
-                                {
-                                        int iHlf = iRem/2;
-                                        for( int k = 0; k < iHlf; k++ )
-                                                write( &fLast.cFillChar, 1 );
-                                        write( sStr, iLen );
-                                        iHlf = iRem-iHlf;;
-                                        for( int k = 0; k < iHlf; k++ )
-                                                write( &fLast.cFillChar, 1 );
-                                }
-                                break;
-                        
-                        case Fmt::Left:
-                                write( sStr, iLen );
-                                for( int k = 0; k < iRem; k++ )
-                                        write( &fLast.cFillChar, 1 );
-                                break;
-                }
-        }
-
-        usedFormat();
+    if( iLen > fLast.uMinWidth )
+    {
+        write( sStr, iLen );
+    }
+    else
+    {
+        int iRem = fLast.uMinWidth - iLen;
+        switch( fLast.uAlign )
+        {
+            case Fmt::Right:
+                for( int k = 0; k < iRem; k++ )
+                    write( &fLast.cFillChar, 1 );
+                write( sStr, iLen );
+                break;
+            
+            case Fmt::Center:
+                {
+                    int iHlf = iRem/2;
+                    for( int k = 0; k < iHlf; k++ )
+                        write( &fLast.cFillChar, 1 );
+                    write( sStr, iLen );
+                    iHlf = iRem-iHlf;;
+                    for( int k = 0; k < iHlf; k++ )
+                        write( &fLast.cFillChar, 1 );
+                }
+                break;
+            
+            case Fmt::Left:
+                write( sStr, iLen );
+                for( int k = 0; k < iRem; k++ )
+                    write( &fLast.cFillChar, 1 );
+                break;
+        }
+    }
+
+    usedFormat();
 }
 
 void Bu::Formatter::read( void *sStr, int iLen )
 {
-        rStream.read( sStr, iLen );
+    rStream.read( sStr, iLen );
 }
 
 Bu::String Bu::Formatter::readToken()
 {
-        Bu::String sRet;
-        if( fLast.bTokenize )
-        {
-                for(;;)
-                {
-                        char buf;
-                        int iRead = rStream.read( &buf, 1 );
-                        if( iRead == 0 )
-                                return sRet;
-                        if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
-                                continue;
-                        else
-                        {
-                                sRet += buf;
-                                break;
-                        }
-                }
-                for(;;)
-                {
-                        char buf;
-                        int iRead = rStream.read( &buf, 1 );
-                        if( iRead == 0 )
-                                return sRet;
-                        if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
-                                return sRet;
-                        else
-                                sRet += buf;
-                }
-        }
-        else
-        {
-                for(;;)
-                {
-                        char buf;
-                        int iRead = rStream.read( &buf, 1 );
-                        if( iRead == 0 )
-                                return sRet;
-                        else
-                                sRet += buf;
-                }
-        }
+    Bu::String sRet;
+    if( fLast.bTokenize )
+    {
+        for(;;)
+        {
+            char buf;
+            int iRead = rStream.read( &buf, 1 );
+            if( iRead == 0 )
+                return sRet;
+            if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
+                continue;
+            else
+            {
+                sRet += buf;
+                break;
+            }
+        }
+        for(;;)
+        {
+            char buf;
+            int iRead = rStream.read( &buf, 1 );
+            if( iRead == 0 )
+                return sRet;
+            if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
+                return sRet;
+            else
+                sRet += buf;
+        }
+    }
+    else
+    {
+        for(;;)
+        {
+            char buf;
+            int iRead = rStream.read( &buf, 1 );
+            if( iRead == 0 )
+                return sRet;
+            else
+                sRet += buf;
+        }
+    }
 }
 
 void Bu::Formatter::incIndent()
 {
-        if( uIndent < 0xFFU )
-                uIndent++;
+    if( uIndent < 0xFFU )
+        uIndent++;
 }
 
 void Bu::Formatter::decIndent()
 {
-        if( uIndent > 0 )
-                uIndent--;
+    if( uIndent > 0 )
+        uIndent--;
 }
 
 void Bu::Formatter::setIndent( uint8_t uLevel )
 {
-        uIndent = uLevel;
+    uIndent = uLevel;
 }
 
 void Bu::Formatter::clearIndent()
 {
-        uIndent = 0;
+    uIndent = 0;
 }
 
 void Bu::Formatter::setIndentChar( char cIndent )
 {
-        this->cIndent = cIndent;
+    this->cIndent = cIndent;
 }
 
 void Bu::Formatter::doFlush()
 {
-        rStream.flush();
+    rStream.flush();
 }
 
 Bu::Fmt &Bu::Fmt::width( unsigned int uWidth )
 {
-        this->uMinWidth = uWidth;
-        return *this;
+    this->uMinWidth = uWidth;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::fill( char cFill )
 {
-        this->cFillChar = (unsigned char)cFill;
-        return *this;
+    this->cFillChar = (unsigned char)cFill;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::radix( unsigned int uRadix )
 {
-        this->uRadix = uRadix;
-        return *this;
+    this->uRadix = uRadix;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::align( Alignment eAlign )
 {
-        this->uAlign = eAlign;
-        return *this;
+    this->uAlign = eAlign;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::left()
 {
-        this->uAlign = Fmt::Left;
-        return *this;
+    this->uAlign = Fmt::Left;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::center()
 {
-        this->uAlign = Fmt::Center;
-        return *this;
+    this->uAlign = Fmt::Center;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::right()
 {
-        this->uAlign = Fmt::Right;
-        return *this;
+    this->uAlign = Fmt::Right;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::plus( bool bPlus )
 {
-        this->bPlus = bPlus;
-        return *this;
+    this->bPlus = bPlus;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::caps( bool bCaps )
 {
-        this->bCaps = bCaps;
-        return *this;
+    this->bCaps = bCaps;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::upper()
 {
-        this->bCaps = true;
-        return *this;
+    this->bCaps = true;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::lower()
 {
-        this->bCaps = false;
-        return *this;
+    this->bCaps = false;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::tokenize( bool bTokenize )
 {
-        this->bTokenize = bTokenize;
-        return *this;
+    this->bTokenize = bTokenize;
+    return *this;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Fmt &fmt )
 {
-        f.setTempFormat( fmt );
-        return f;
+    f.setTempFormat( fmt );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, Bu::Formatter::Special s )
 {
-        switch( s )
-        {
-                case Formatter::nl:
-                        {
+    switch( s )
+    {
+        case Formatter::nl:
+            {
 #ifdef WIN32
-                                f.write("\r\n", 2 );
+                f.write("\r\n", 2 );
 #else
-                                f.write("\n", 1 );
+                f.write("\n", 1 );
 #endif
-                                char ci = f.getIndentChar();
-                                for( int j = 0; j < f.getIndent(); j++ )
-                                        f.write( &ci, 1 );
-                                f.doFlush();
-                        }
-                        break;
+                char ci = f.getIndentChar();
+                for( int j = 0; j < f.getIndent(); j++ )
+                    f.write( &ci, 1 );
+                f.doFlush();
+            }
+            break;
 
-                case Formatter::flush:
-                        f.doFlush();
-                        break;
-        }
-        return f;
+        case Formatter::flush:
+            f.doFlush();
+            break;
+    }
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const char *sStr )
 {
-        f.writeAligned( sStr, strlen( sStr ) );
-        return f;
+    f.writeAligned( sStr, strlen( sStr ) );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, char *sStr )
 {
-        f.writeAligned( sStr, strlen( sStr ) );
-        return f;
+    f.writeAligned( sStr, strlen( sStr ) );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::String &sStr )
 {
-        f.writeAligned( sStr );
-        return f;
+    f.writeAligned( sStr );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed char c )
 {
-        f.ifmt<signed char>( c );
-        //f.write( (char *)&c, 1 );
-        return f;
+    f.ifmt<signed char>( c );
+    //f.write( (char *)&c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, char c )
 {
-        f.write( (char *)&c, 1 );
-        return f;
+    f.write( (char *)&c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned char c )
 {
-        f.ufmt<unsigned char>( c );
-        //f.write( (char *)&c, 1 );
-        return f;
+    f.ufmt<unsigned char>( c );
+    //f.write( (char *)&c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed short i )
 {
-        f.ifmt<signed short>( i );
-        return f;
+    f.ifmt<signed short>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned short i )
 {
-        f.ufmt<unsigned short>( i );
-        return f;
+    f.ufmt<unsigned short>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed int i )
 {
-        f.ifmt<signed int>( i );
-        return f;
+    f.ifmt<signed int>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned int i )
 {
-        f.ufmt<unsigned int>( i );
-        return f;
+    f.ufmt<unsigned int>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed long i )
 {
-        f.ifmt<signed long>( i );
-        return f;
+    f.ifmt<signed long>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned long i )
 {
-        f.ufmt<unsigned long>( i );
-        return f;
+    f.ufmt<unsigned long>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed long long i )
 {
-        f.ifmt<signed long long>( i );
-        return f;
+    f.ifmt<signed long long>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned long long i )
 {
-        f.ufmt<unsigned long long>( i );
-        return f;
+    f.ufmt<unsigned long long>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, float flt )
 {
-        f.ffmt<float>( flt );
-        return f;
+    f.ffmt<float>( flt );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, double flt )
 {
-        f.ffmt<double>( flt );
-        return f;
+    f.ffmt<double>( flt );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, long double flt )
 {
-        f.ffmt<long double>( flt );
-        return f;
+    f.ffmt<long double>( flt );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, bool b )
 {
-        f.writeAligned( b?("true"):("false") );
-        return f;
+    f.writeAligned( b?("true"):("false") );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, Bu::String &sStr )
 {
-        sStr = f.readToken();
-        return f;
+    sStr = f.readToken();
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed char &c )
 {
-        f.read( &c, 1 );
-        return f;
+    f.read( &c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, char &c )
 {
-        f.read( &c, 1 );
-        return f;
+    f.read( &c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned char &c )
 {
-        f.read( &c, 1 );
-        return f;
+    f.read( &c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed short &i )
 {
-        f.iparse( i, f.readToken() );
-        return f;
+    f.iparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned short &i )
 {
-        f.uparse( i, f.readToken() );
-        return f;
+    f.uparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed int &i )
 {
-        f.iparse( i, f.readToken() );
-        return f;
+    f.iparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned int &i )
 {
-        f.uparse( i, f.readToken() );
-        return f;
+    f.uparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed long &i )
 {
-        f.iparse( i, f.readToken() );
-        return f;
+    f.iparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned long &i )
 {
-        f.uparse( i, f.readToken() );
-        return f;
+    f.uparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed long long &i )
 {
-        f.iparse( i, f.readToken() );
-        return f;
+    f.iparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned long long &i )
 {
-        f.uparse( i, f.readToken() );
-        return f;
+    f.uparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, float &flt )
 {
-        f.fparse( flt, f.readToken() );
-        return f;
+    f.fparse( flt, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, double &flt )
 {
-        f.fparse( flt, f.readToken() );
-        return f;
+    f.fparse( flt, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, long double &flt )
 {
-        f.fparse( flt, f.readToken() );
-        return f;
+    f.fparse( flt, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, bool &b )
 {
-        Bu::String sStr = f.readToken();
-        if( !sStr.isSet() )
-                return f;
-        char c = *sStr.begin();
-        if( c == 'y' || c == 'Y' || c == 't' || c == 'T' )
-                b = true;
-        else if( c == 'n' || c == 'N' || c == 'f' || c == 'F' )
-                b = false;
+    Bu::String sStr = f.readToken();
+    if( !sStr.isSet() )
+        return f;
+    char c = *sStr.begin();
+    if( c == 'y' || c == 'Y' || c == 't' || c == 'T' )
+        b = true;
+    else if( c == 'n' || c == 'N' || c == 'f' || c == 'F' )
+        b = false;
 
-        return f;
+    return f;
 }
 
diff --git a/src/stable/formatter.h b/src/stable/formatter.h
index d92a53b..94794b5 100644
--- a/src/stable/formatter.h
+++ b/src/stable/formatter.h
@@ -15,292 +15,292 @@
 
 namespace Bu
 {
-        class Stream;
-
-        template<typename t> t tlog( t x );
-        template<> float tlog( float x );
-        template<> double tlog( double x );
-        template<> long double tlog( long double x );
-
-        template<typename t> t tfloor( t x );
-        template<> float tfloor( float x );
-        template<> double tfloor( double x );
-        template<> long double tfloor( long double x );
-
-        template<typename t> t tpow( t x, t y );
-        template<> float tpow( float x, float y );
-        template<> double tpow( double x, double y );
-        template<> long double tpow( long double x, long double y );
-
-        class Formatter
-        {
-        public:
-                Formatter( Stream &rStream );
-                virtual ~Formatter();
-
-                void write( const Bu::String &sStr );
-                void write( const void *sStr, int iLen );
-                void writeAligned( const Bu::String &sStr );
-                void writeAligned( const char *sStr, int iLen );
-
-                void read( void *sStr, int iLen );
-                Bu::String readToken();
-
-                void incIndent();
-                void decIndent();
-                void setIndent( uint8_t uLevel );
-                void clearIndent();
-                uint8_t getIndent() const { return uIndent; }
-                void setIndentChar( char cIndent );
-                char getIndentChar() const { return cIndent; }
-
-                void setFormat( const Fmt &f )
-                {
-                        fLast = f;
-                        bTempFmt = false;
-                }
-
-                void setTempFormat( const Fmt &f )
-                {
-                        fLast = f;
-                        bTempFmt = true;
-                }
-
-                void usedFormat()
-                {
-                        if( bTempFmt )
-                                fLast = Fmt();
-                }
-
-                template<typename type>
-                void ifmt( type i )
-                {
-                        // This code is taken from Nango, hopefully we can make it better.
-                        bool bNeg = i<0;
-                        char cBase = fLast.bCaps?'A':'a';
-                        char buf[sizeof(type)*8+1];
-                        if( bNeg ) i = -i;
-                        if( fLast.uRadix < 2 || fLast.uRadix > 36 )
-                        {
-                                usedFormat();
-                                return;
-                        }
-
-                        for( int j = sizeof(type)*8; j >= 0; j-- )
-                        {
-                                int c = i%fLast.uRadix;
-                                i /= fLast.uRadix;
-                                buf[j] = (char)((c<10)?('0'+c):(cBase+c-10));
-                                if( i == 0 )
-                                {
-                                        if( bNeg ) buf[--j] = '-';
-                                        else if( fLast.bPlus ) buf[--j] = '+';
-                                        writeAligned( buf+j, sizeof(type)*8-j+1 );
-
-                                        return;
-                                }
-                        }
-                        usedFormat();
-                }
-
-                template<typename type>
-                void ufmt( type i )
-                {
-                        // This code is taken from Nango, hopefully we can make it better.
-                        char buf[sizeof(type)*8+1];
-                        char cBase = fLast.bCaps?'A':'a';
-                        if( fLast.uRadix < 2 || fLast.uRadix > 36 )
-                        {
-                                usedFormat();
-                                return;
-                        }
-
-                        for( int j = sizeof(type)*8; j >= 0; j-- )
-                        {
-                                int c = i%fLast.uRadix;
-                                i /= fLast.uRadix;
-                                buf[j] = (char)((c<10)?('0'+c):(cBase+c-10));
-                                if( i == 0 )
-                                {
-                                        if( fLast.bPlus ) buf[--j] = '+';
-                                        writeAligned( buf+j, sizeof(type)*8-j+1 );
-
-                                        return;
-                                }
-                        }
-                        usedFormat();
-                }
-
-                template<typename type>
-                void ffmt( type f )
-                {
-                        Bu::String fTmp;
-                        char cBase = fLast.bCaps?'A':'a';
-                        if( fLast.uRadix < 2 || fLast.uRadix > 36 )
-                        {
-                                usedFormat();
-                                return;
-                        }
-
-                        if( signbit(f) )
-                        {
-                                f = -f;
-                                fTmp += "-";
-                        }
-                        int iScale = tfloor(tlog( f ) / tlog( (type)fLast.uRadix ));
-                        f /= tpow( (type)fLast.uRadix, (type)iScale );
-
-                        if( iScale < 0 )
-                        {
-                                fTmp += "0.";
-                                for( int j = 1; j < -iScale; j++ )
-                                        fTmp += '0';
-                        }
-                        int c = f;
-                        fTmp += (char)((c<10)?('0'+c):(cBase+c-10));
-                        f -= (int)f;
-                        int j;
-                        for( j = 0; j < 8 && f; j++ )
-                        {
-                                if( iScale - j == 0 )
-                                        fTmp += '.';
-                                f = f*fLast.uRadix;
-                                int c = f;
-                                fTmp += (char)((c<10)?('0'+c):(cBase+c-10));
-                                f -= (int)f;
-                        }
-                        if( iScale >= j )
-                        {
-                                for( int k = j; k < iScale; k++ )
-                                        fTmp += '0';
-                                fTmp += ".0";
-                        }
-
-                        writeAligned( fTmp );
-                        usedFormat();
-                }
-                
-                template<typename type>
-                void iparse( type &i, const Bu::String &sBuf )
-                {
-                        if( !sBuf.isSet() )
-                                return;
-                        if( sBuf[0] != '+' && sBuf[0] != '-' &&
-                                (sBuf[0] < '0' && sBuf[0] > '9') )
-                                return;
-                        int j = 1;
-                        int iMax = sBuf.getSize();
-                        for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
-                        i = 0;
-                        type iPos = 1;
-                        for(j--; j >= 0; j-- )
-                        {
-                                if( sBuf[j] == '+' || sBuf[j] == '-' )
-                                        continue;
-                                i += (sBuf[j]-'0')*iPos;
-                                iPos *= fLast.uRadix;
-                        }
-                        if( sBuf[0] == '-' )
-                                i = -i;
-
-                        usedFormat();
-                }
-                
-                template<typename type>
-                void uparse( type &i, const Bu::String &sBuf )
-                {
-                        if( !sBuf.isSet() )
-                                return;
-                        if( sBuf[0] != '+' &&
-                                (sBuf[0] < '0' && sBuf[0] > '9') )
-                                return;
-                        int j = 1;
-                        int iMax = sBuf.getSize();
-                        for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
-                        i = 0;
-                        type iPos = 1;
-                        for(j--; j >= 0; j-- )
-                        {
-                                if( sBuf[j] == '+' )
-                                        continue;
-                                i += (sBuf[j]-'0')*iPos;
-                                iPos *= fLast.uRadix;
-                        }
-
-                        usedFormat();
-                }
-                
-                template<typename type>
-                void fparse( type &f, const Bu::String &sBuf )
-                {
-                        double fIn;
-                        sscanf( sBuf.getStr(), "%lf", &fIn );
-                        f = fIn;
-                        usedFormat();
-                }
-
-                enum Special
-                {
-                        nl,
-                        flush
-                };
-
-                void doFlush();
-
-                Stream &getStream() { return rStream; }
-                operator Stream&() { return rStream; }
-
-        private:
-                Stream &rStream;
-                Fmt fLast;
-                bool bTempFmt;
-                uint8_t uIndent;
-                char cIndent;
-        };
-
-        Formatter &operator<<( Formatter &f, const Fmt &fmt );
-        Formatter &operator<<( Formatter &f, Formatter::Special s );
-        Formatter &operator<<( Formatter &f, const char *sStr );
-        Formatter &operator<<( Formatter &f, char *sStr );
-        Formatter &operator<<( Formatter &f, const Bu::String &sStr );
-        Formatter &operator<<( Formatter &f, signed char c );
-        Formatter &operator<<( Formatter &f, char c );
-        Formatter &operator<<( Formatter &f, unsigned char c );
-        Formatter &operator<<( Formatter &f, signed short i );
-        Formatter &operator<<( Formatter &f, unsigned short i );
-        Formatter &operator<<( Formatter &f, signed int i );
-        Formatter &operator<<( Formatter &f, unsigned int i );
-        Formatter &operator<<( Formatter &f, signed long i );
-        Formatter &operator<<( Formatter &f, unsigned long i );
-        Formatter &operator<<( Formatter &f, signed long long i );
-        Formatter &operator<<( Formatter &f, unsigned long long i );
-        Formatter &operator<<( Formatter &f, float flt );
-        Formatter &operator<<( Formatter &f, double flt );
-        Formatter &operator<<( Formatter &f, long double flt );
-        Formatter &operator<<( Formatter &f, bool b );
-
-        Formatter &operator>>( Formatter &f, Bu::String &sStr );
-        Formatter &operator>>( Formatter &f, signed char &c );
-        Formatter &operator>>( Formatter &f, char &c );
-        Formatter &operator>>( Formatter &f, unsigned char &c );
-        Formatter &operator>>( Formatter &f, signed short &i );
-        Formatter &operator>>( Formatter &f, unsigned short &i );
-        Formatter &operator>>( Formatter &f, signed int &i );
-        Formatter &operator>>( Formatter &f, unsigned int &i );
-        Formatter &operator>>( Formatter &f, signed long &i );
-        Formatter &operator>>( Formatter &f, unsigned long &i );
-        Formatter &operator>>( Formatter &f, signed long long &i );
-        Formatter &operator>>( Formatter &f, unsigned long long &i );
-        Formatter &operator>>( Formatter &f, float &flt );
-        Formatter &operator>>( Formatter &f, double &flt );
-        Formatter &operator>>( Formatter &f, long double &flt );
-        Formatter &operator>>( Formatter &f, bool &b );
-
-        template<typename type>
-        Formatter &operator<<( Formatter &f, const type *p )
-        {
-                return f << "0x" << Fmt::hex(sizeof(ptrdiff_t)*2) << (ptrdiff_t)(p);
-        }
+    class Stream;
+
+    template<typename t> t tlog( t x );
+    template<> float tlog( float x );
+    template<> double tlog( double x );
+    template<> long double tlog( long double x );
+
+    template<typename t> t tfloor( t x );
+    template<> float tfloor( float x );
+    template<> double tfloor( double x );
+    template<> long double tfloor( long double x );
+
+    template<typename t> t tpow( t x, t y );
+    template<> float tpow( float x, float y );
+    template<> double tpow( double x, double y );
+    template<> long double tpow( long double x, long double y );
+
+    class Formatter
+    {
+    public:
+        Formatter( Stream &rStream );
+        virtual ~Formatter();
+
+        void write( const Bu::String &sStr );
+        void write( const void *sStr, int iLen );
+        void writeAligned( const Bu::String &sStr );
+        void writeAligned( const char *sStr, int iLen );
+
+        void read( void *sStr, int iLen );
+        Bu::String readToken();
+
+        void incIndent();
+        void decIndent();
+        void setIndent( uint8_t uLevel );
+        void clearIndent();
+        uint8_t getIndent() const { return uIndent; }
+        void setIndentChar( char cIndent );
+        char getIndentChar() const { return cIndent; }
+
+        void setFormat( const Fmt &f )
+        {
+            fLast = f;
+            bTempFmt = false;
+        }
+
+        void setTempFormat( const Fmt &f )
+        {
+            fLast = f;
+            bTempFmt = true;
+        }
+
+        void usedFormat()
+        {
+            if( bTempFmt )
+                fLast = Fmt();
+        }
+
+        template<typename type>
+        void ifmt( type i )
+        {
+            // This code is taken from Nango, hopefully we can make it better.
+            bool bNeg = i<0;
+            char cBase = fLast.bCaps?'A':'a';
+            char buf[sizeof(type)*8+1];
+            if( bNeg ) i = -i;
+            if( fLast.uRadix < 2 || fLast.uRadix > 36 )
+            {
+                usedFormat();
+                return;
+            }
+
+            for( int j = sizeof(type)*8; j >= 0; j-- )
+            {
+                int c = i%fLast.uRadix;
+                i /= fLast.uRadix;
+                buf[j] = (char)((c<10)?('0'+c):(cBase+c-10));
+                if( i == 0 )
+                {
+                    if( bNeg ) buf[--j] = '-';
+                    else if( fLast.bPlus ) buf[--j] = '+';
+                    writeAligned( buf+j, sizeof(type)*8-j+1 );
+
+                    return;
+                }
+            }
+            usedFormat();
+        }
+
+        template<typename type>
+        void ufmt( type i )
+        {
+            // This code is taken from Nango, hopefully we can make it better.
+            char buf[sizeof(type)*8+1];
+            char cBase = fLast.bCaps?'A':'a';
+            if( fLast.uRadix < 2 || fLast.uRadix > 36 )
+            {
+                usedFormat();
+                return;
+            }
+
+            for( int j = sizeof(type)*8; j >= 0; j-- )
+            {
+                int c = i%fLast.uRadix;
+                i /= fLast.uRadix;
+                buf[j] = (char)((c<10)?('0'+c):(cBase+c-10));
+                if( i == 0 )
+                {
+                    if( fLast.bPlus ) buf[--j] = '+';
+                    writeAligned( buf+j, sizeof(type)*8-j+1 );
+
+                    return;
+                }
+            }
+            usedFormat();
+        }
+
+        template<typename type>
+        void ffmt( type f )
+        {
+            Bu::String fTmp;
+            char cBase = fLast.bCaps?'A':'a';
+            if( fLast.uRadix < 2 || fLast.uRadix > 36 )
+            {
+                usedFormat();
+                return;
+            }
+
+            if( signbit(f) )
+            {
+                f = -f;
+                fTmp += "-";
+            }
+            int iScale = tfloor(tlog( f ) / tlog( (type)fLast.uRadix ));
+            f /= tpow( (type)fLast.uRadix, (type)iScale );
+
+            if( iScale < 0 )
+            {
+                fTmp += "0.";
+                for( int j = 1; j < -iScale; j++ )
+                    fTmp += '0';
+            }
+            int c = f;
+            fTmp += (char)((c<10)?('0'+c):(cBase+c-10));
+            f -= (int)f;
+            int j;
+            for( j = 0; j < 8 && f; j++ )
+            {
+                if( iScale - j == 0 )
+                    fTmp += '.';
+                f = f*fLast.uRadix;
+                int c = f;
+                fTmp += (char)((c<10)?('0'+c):(cBase+c-10));
+                f -= (int)f;
+            }
+            if( iScale >= j )
+            {
+                for( int k = j; k < iScale; k++ )
+                    fTmp += '0';
+                fTmp += ".0";
+            }
+
+            writeAligned( fTmp );
+            usedFormat();
+        }
+        
+        template<typename type>
+        void iparse( type &i, const Bu::String &sBuf )
+        {
+            if( !sBuf.isSet() )
+                return;
+            if( sBuf[0] != '+' && sBuf[0] != '-' &&
+                (sBuf[0] < '0' && sBuf[0] > '9') )
+                return;
+            int j = 1;
+            int iMax = sBuf.getSize();
+            for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
+            i = 0;
+            type iPos = 1;
+            for(j--; j >= 0; j-- )
+            {
+                if( sBuf[j] == '+' || sBuf[j] == '-' )
+                    continue;
+                i += (sBuf[j]-'0')*iPos;
+                iPos *= fLast.uRadix;
+            }
+            if( sBuf[0] == '-' )
+                i = -i;
+
+            usedFormat();
+        }
+        
+        template<typename type>
+        void uparse( type &i, const Bu::String &sBuf )
+        {
+            if( !sBuf.isSet() )
+                return;
+            if( sBuf[0] != '+' &&
+                (sBuf[0] < '0' && sBuf[0] > '9') )
+                return;
+            int j = 1;
+            int iMax = sBuf.getSize();
+            for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
+            i = 0;
+            type iPos = 1;
+            for(j--; j >= 0; j-- )
+            {
+                if( sBuf[j] == '+' )
+                    continue;
+                i += (sBuf[j]-'0')*iPos;
+                iPos *= fLast.uRadix;
+            }
+
+            usedFormat();
+        }
+        
+        template<typename type>
+        void fparse( type &f, const Bu::String &sBuf )
+        {
+            double fIn;
+            sscanf( sBuf.getStr(), "%lf", &fIn );
+            f = fIn;
+            usedFormat();
+        }
+
+        enum Special
+        {
+            nl,
+            flush
+        };
+
+        void doFlush();
+
+        Stream &getStream() { return rStream; }
+        operator Stream&() { return rStream; }
+
+    private:
+        Stream &rStream;
+        Fmt fLast;
+        bool bTempFmt;
+        uint8_t uIndent;
+        char cIndent;
+    };
+
+    Formatter &operator<<( Formatter &f, const Fmt &fmt );
+    Formatter &operator<<( Formatter &f, Formatter::Special s );
+    Formatter &operator<<( Formatter &f, const char *sStr );
+    Formatter &operator<<( Formatter &f, char *sStr );
+    Formatter &operator<<( Formatter &f, const Bu::String &sStr );
+    Formatter &operator<<( Formatter &f, signed char c );
+    Formatter &operator<<( Formatter &f, char c );
+    Formatter &operator<<( Formatter &f, unsigned char c );
+    Formatter &operator<<( Formatter &f, signed short i );
+    Formatter &operator<<( Formatter &f, unsigned short i );
+    Formatter &operator<<( Formatter &f, signed int i );
+    Formatter &operator<<( Formatter &f, unsigned int i );
+    Formatter &operator<<( Formatter &f, signed long i );
+    Formatter &operator<<( Formatter &f, unsigned long i );
+    Formatter &operator<<( Formatter &f, signed long long i );
+    Formatter &operator<<( Formatter &f, unsigned long long i );
+    Formatter &operator<<( Formatter &f, float flt );
+    Formatter &operator<<( Formatter &f, double flt );
+    Formatter &operator<<( Formatter &f, long double flt );
+    Formatter &operator<<( Formatter &f, bool b );
+
+    Formatter &operator>>( Formatter &f, Bu::String &sStr );
+    Formatter &operator>>( Formatter &f, signed char &c );
+    Formatter &operator>>( Formatter &f, char &c );
+    Formatter &operator>>( Formatter &f, unsigned char &c );
+    Formatter &operator>>( Formatter &f, signed short &i );
+    Formatter &operator>>( Formatter &f, unsigned short &i );
+    Formatter &operator>>( Formatter &f, signed int &i );
+    Formatter &operator>>( Formatter &f, unsigned int &i );
+    Formatter &operator>>( Formatter &f, signed long &i );
+    Formatter &operator>>( Formatter &f, unsigned long &i );
+    Formatter &operator>>( Formatter &f, signed long long &i );
+    Formatter &operator>>( Formatter &f, unsigned long long &i );
+    Formatter &operator>>( Formatter &f, float &flt );
+    Formatter &operator>>( Formatter &f, double &flt );
+    Formatter &operator>>( Formatter &f, long double &flt );
+    Formatter &operator>>( Formatter &f, bool &b );
+
+    template<typename type>
+    Formatter &operator<<( Formatter &f, const type *p )
+    {
+        return f << "0x" << Fmt::hex(sizeof(ptrdiff_t)*2) << (ptrdiff_t)(p);
+    }
 };
 
 #endif
diff --git a/src/stable/formula.cpp b/src/stable/formula.cpp
index 6bc2c58..c5ba1ae 100644
--- a/src/stable/formula.cpp
+++ b/src/stable/formula.cpp
@@ -9,6 +9,6 @@
 
 namespace Bu
 {
-        subExceptionDef( FormulaException );
+    subExceptionDef( FormulaException );
 }
 
diff --git a/src/stable/formula.h b/src/stable/formula.h
index 36a0398..b12afd6 100644
--- a/src/stable/formula.h
+++ b/src/stable/formula.h
@@ -21,410 +21,410 @@
 
 namespace Bu
 {
-        subExceptionDecl( FormulaException );
-        /**
-         * Implements a very simple formula parser that allows use of variables and
-         * custom functions.  This is based on a simple calculator-type parser that
-         * executes as it processes, accounting for operator precedence and
-         * grouping.
-         *
-         * prec = precision, a type to use for all math (except binary ops)
-         * bin = binary type, a type to hard cast all data to for binary ops
-         */
-        template<typename prec, typename bin=uint32_t>
-        class Formula
-        {
-        public:
-                class Func
-                {
-                public:
-                        virtual prec operator()( prec )=0;
-                };
-
-                typedef Hash<Bu::String, prec> varHash;
-                typedef Hash<Bu::String, Func *> funcHash;
-
-                Formula()
-                {
-                }
-
-                virtual ~Formula()
-                {
-                        for( typename funcHash::iterator i = hFunc.begin();
-                                 i != hFunc.end(); i++ )
-                        {
-                                delete (*i);
-                        }
-                }
-
-                prec run( const Bu::String &sFormulaSrc )
-                {
-                        if( sFormulaSrc.isEmpty() )
-                                throw FormulaException("Empty formula, nothing to do.");
-                        try
-                        {
-                                const char *sFormula = sFormulaSrc.getStr();
-                                for(;;)
-                                {
-                                        uint8_t tNum = nextToken( &sFormula );
-                                        if( tNum == symSubtract )
-                                        {
-                                                sOper.push( symNegate );
-                                                continue;
-                                        }
-                                        else if( tNum == symNot )
-                                        {
-                                                sOper.push( symNot );
-                                                continue;
-                                        }
-                                        else if( tNum == symOpenParen )
-                                        {
-                                                sOper.push( tNum );
-                                                continue;
-                                        }
-                                        else if( tNum == symFunction )
-                                        {
-                                                sOper.push( symFunction );
-                                                continue;
-                                        }
-                                        else if( tNum == symEOS )
-                                        {
-                                                throw Bu::FormulaException(
-                                                        "Cannot end with an operator.");
-                                        }
-
-                        oppart: uint8_t tOpr = nextToken( &sFormula );
-                                        if( tOpr == symEOS )
-                                        {
-                                                reduce();
-                                                prec ret = sValue.top();
-                                                sValue.clear();
-                                                sFunc.clear();
-                                                sOper.clear();
-                                                return ret;
-                                        }
-                                        if( !sOper.isEmpty() && getPrec( sOper.top() ) >
-                                                getPrec( tOpr ) )
-                                        {
-                                                reduce();
-                                        }
-                                        if( tOpr != symCloseParen )
-                                        {
-                                                sOper.push( tOpr );
-                                        }
-                                        else
-                                        {
-                                                reduce( true );
-                                                goto oppart;
-                                        }
-                                }
-                        }
-                        catch( ... )
-                        {
-                                sValue.clear();
-                                sFunc.clear();
-                                sOper.clear();
-                                throw;
-                        }
-                }
-
-                varHash hVars;
-                funcHash hFunc;
-
-        private:
-                enum
-                {
-                        symEOS,
-                        symAdd,
-                        symSubtract,
-                        symMultiply,
-                        symDivide,
-                        symOpenParen,
-                        symCloseParen,
-                        symNumber,
-                        symVariable,
-                        symFunction,
-                        symExponent,
-                        symNegate,
-                        symModulus,
-
-                        symAnd,
-                        symOr,
-                        symXor,
-                        symNot
-                };
-
-                typedef uint8_t symType;
-
-                Bu::Stack<symType> sOper;
-                Bu::Stack<prec> sValue;
-                Bu::Stack<Bu::String> sFunc;
-
-        private:
-                symType getPrec( symType nOper )
-                {
-                        switch( nOper )
-                        {
-                                case symNumber:
-                                case symVariable:
-                                case symOpenParen:
-                                case symCloseParen:
-                                        return 0;
-
-                                case symAdd:
-                                case symSubtract:
-                                        return 1;
-
-                                case symMultiply:
-                                case symDivide:
-                                case symModulus:
-                                        return 2;
-
-                                case symAnd:
-                                case symOr:
-                                case symXor:
-                                        return 2;
-
-                                case symExponent:
-                                case symNot:
-                                case symNegate:
-                                case symFunction:
-                                        return 3;
-
-                                default:
-                                        return 0;
-                        }
-                }
-
-                symType nextToken( const char **sBuf )
-                {
-                        for(;;)
-                        {
-                                char cbuf = **sBuf;
-                                ++(*sBuf);
-                                switch( cbuf )
-                                {
-                                        case '+':
-                                                return symAdd;
-
-                                        case '-':
-                                                return symSubtract;
-
-                                        case '*':
-                                                return symMultiply;
-
-                                        case '/':
-                                                return symDivide;
-
-                                        case '^':
-                                                return symExponent;
-
-                                        case '%':
-                                                return symModulus;
-
-                                        case '(':
-                                                return symOpenParen;
-
-                                        case ')':
-                                                return symCloseParen;
-
-                                        case '|':
-                                                return symOr;
-
-                                        case '&':
-                                                return symAnd;
-
-                                        case '#':
-                                                return symXor;
-
-                                        case '~':
-                                                return symNot;
-
-                                        case ' ':
-                                        case '\t':
-                                        case '\n':
-                                        case '\r':
-                                                break;
-
-                                        case '\0':
-                                                return symEOS;
-
-                                        default:
-                                                if( cbuf == '.' || (cbuf >= '0' && cbuf <= '9') )
-                                                {
-                                                        char num[50]={cbuf};
-                                                        int nPos = 1;
-                                                        bool bDot = false;
-
-                                                        for(;;)
-                                                        {
-                                                                cbuf = **sBuf;
-                                                                if( cbuf == '.' )
-                                                                {
-                                                                        if( bDot == false )
-                                                                                bDot = true;
-                                                                        else
-                                                                                throw FormulaException(
-                                                                                        "Numbers cannot have more than one "
-                                                                                        ". in them."
-                                                                                        );
-                                                                }
-                                                                if( cbuf == '.' ||
-                                                                        (cbuf >= '0' && cbuf <= '9') )
-                                                                {
-                                                                        num[nPos++] = cbuf;
-                                                                }
-                                                                else
-                                                                {
-                                                                        num[nPos] = '\0';
-                                                                        sValue.push(
-                                                                                static_cast<prec>(
-                                                                                        strtod( num, NULL )
-                                                                                        )
-                                                                                );
-                                                                        return symNumber;
-                                                                }
-                                                                ++(*sBuf);
-                                                        }
-                                                }
-                                                else if( (cbuf >= 'a' && cbuf <= 'z') || 
-                                                                 (cbuf >= 'A' && cbuf <= 'Z') ||
-                                                                 (cbuf == '_') )
-                                                {
-                                                        char tok[50]={cbuf};
-                                                        int nPos = 1;
-
-                                                        for(;;)
-                                                        {
-                                                                cbuf = **sBuf;
-                                                                if( (cbuf >= 'a' && cbuf <= 'z') || 
-                                                                        (cbuf >= 'A' && cbuf <= 'Z') ||
-                                                                        (cbuf >= '0' && cbuf <= '9') ||
-                                                                        cbuf == '_' || cbuf == '.' || cbuf == ':' )
-                                                                {
-                                                                        tok[nPos++] = cbuf;
-                                                                }
-                                                                else
-                                                                {
-                                                                        tok[nPos] = '\0';
-                                                                        if( hVars.has( tok ) )
-                                                                        {
-                                                                                sValue.push( hVars[tok] );
-                                                                                return symNumber;
-                                                                        }
-                                                                        else if( hFunc.has( tok ) )
-                                                                        {
-                                                                                sFunc.push( tok );
-                                                                                return symFunction;
-                                                                        }
-                                                                        else
-                                                                        {
-                                                                                throw FormulaException(
-                                                                                        "No variable or function named "
-                                                                                        "\"%s\" exists.",
-                                                                                        tok
-                                                                                        );
-                                                                        }
-                                                                }
-                                                                ++(*sBuf);
-                                                        }
-                                                }
-                                                break;
-                                }
-                        }
-                }
-
-                void reduce( bool bCloseParen = false )
-                {
-                        while( !sOper.isEmpty() )
-                        {
-                                uint8_t nOpr = sOper.top();
-                                if( nOpr == symOpenParen )
-                                {
-                                        if( bCloseParen == true )
-                                                sOper.pop();
-                                        return;
-                                }
-                                sOper.pop();
-
-                                prec dTop = sValue.top();
-                                sValue.pop();
-
-                                switch( nOpr )
-                                {
-                                        case symAdd:
-                                                sValue.top() += dTop;
-                                                break;
-
-                                        case symSubtract:
-                                                sValue.top() -= dTop;
-                                                break;
-
-                                        case symMultiply:
-                                                sValue.top() *= dTop;
-                                                break;
-
-                                        case symDivide:
-                                                sValue.top() /= dTop;
-                                                break;
-
-                                        case symExponent:
-                                                sValue.top() = static_cast<prec>(
-                                                                pow( sValue.top(), dTop )
-                                                        );
-                                                break;
-
-                                        case symModulus:
-                                                sValue.top() = static_cast<prec>(
-                                                                fmod( sValue.top(), dTop )
-                                                        );
-                                                break;
-
-                                        case symOr:
-                                                sValue.top() = static_cast<prec>(
-                                                                static_cast<bin>(sValue.top()) |
-                                                                static_cast<bin>(dTop)
-                                                        );
-                                                break;
-                                        
-                                        case symAnd:
-                                                sValue.top() = static_cast<prec>(
-                                                                static_cast<bin>(sValue.top()) &
-                                                                static_cast<bin>(dTop)
-                                                        );
-                                                break;
-                                        
-                                        case symXor:
-                                                sValue.top() = static_cast<prec>(
-                                                                static_cast<bin>(sValue.top()) ^
-                                                                static_cast<bin>(dTop)
-                                                        );
-                                                break;
-
-                                        case symFunction:
-                                                sValue.push( (*hFunc.get( sFunc.pop() ))( dTop ) );
-                                                break;
-
-                                        case symNegate:
-                                                sValue.push( -dTop );
-                                                break;
-
-                                        case symNot:
-                                                sValue.push( static_cast<prec>(
-                                                                ~static_cast<bin>(dTop)
-                                                        ) );
-                                                break;
-                                }
-                        }
-
-                        if( bCloseParen == true )
-                        {
-                                throw FormulaException(
-                                        "Close-paren found without matching open-paren."
-                                        );
-                        }
-                }
-        };
+    subExceptionDecl( FormulaException );
+    /**
+     * Implements a very simple formula parser that allows use of variables and
+     * custom functions.  This is based on a simple calculator-type parser that
+     * executes as it processes, accounting for operator precedence and
+     * grouping.
+     *
+     * prec = precision, a type to use for all math (except binary ops)
+     * bin = binary type, a type to hard cast all data to for binary ops
+     */
+    template<typename prec, typename bin=uint32_t>
+    class Formula
+    {
+    public:
+        class Func
+        {
+        public:
+            virtual prec operator()( prec )=0;
+        };
+
+        typedef Hash<Bu::String, prec> varHash;
+        typedef Hash<Bu::String, Func *> funcHash;
+
+        Formula()
+        {
+        }
+
+        virtual ~Formula()
+        {
+            for( typename funcHash::iterator i = hFunc.begin();
+                 i != hFunc.end(); i++ )
+            {
+                delete (*i);
+            }
+        }
+
+        prec run( const Bu::String &sFormulaSrc )
+        {
+            if( sFormulaSrc.isEmpty() )
+                throw FormulaException("Empty formula, nothing to do.");
+            try
+            {
+                const char *sFormula = sFormulaSrc.getStr();
+                for(;;)
+                {
+                    uint8_t tNum = nextToken( &sFormula );
+                    if( tNum == symSubtract )
+                    {
+                        sOper.push( symNegate );
+                        continue;
+                    }
+                    else if( tNum == symNot )
+                    {
+                        sOper.push( symNot );
+                        continue;
+                    }
+                    else if( tNum == symOpenParen )
+                    {
+                        sOper.push( tNum );
+                        continue;
+                    }
+                    else if( tNum == symFunction )
+                    {
+                        sOper.push( symFunction );
+                        continue;
+                    }
+                    else if( tNum == symEOS )
+                    {
+                        throw Bu::FormulaException(
+                            "Cannot end with an operator.");
+                    }
+
+            oppart: uint8_t tOpr = nextToken( &sFormula );
+                    if( tOpr == symEOS )
+                    {
+                        reduce();
+                        prec ret = sValue.top();
+                        sValue.clear();
+                        sFunc.clear();
+                        sOper.clear();
+                        return ret;
+                    }
+                    if( !sOper.isEmpty() && getPrec( sOper.top() ) >
+                        getPrec( tOpr ) )
+                    {
+                        reduce();
+                    }
+                    if( tOpr != symCloseParen )
+                    {
+                        sOper.push( tOpr );
+                    }
+                    else
+                    {
+                        reduce( true );
+                        goto oppart;
+                    }
+                }
+            }
+            catch( ... )
+            {
+                sValue.clear();
+                sFunc.clear();
+                sOper.clear();
+                throw;
+            }
+        }
+
+        varHash hVars;
+        funcHash hFunc;
+
+    private:
+        enum
+        {
+            symEOS,
+            symAdd,
+            symSubtract,
+            symMultiply,
+            symDivide,
+            symOpenParen,
+            symCloseParen,
+            symNumber,
+            symVariable,
+            symFunction,
+            symExponent,
+            symNegate,
+            symModulus,
+
+            symAnd,
+            symOr,
+            symXor,
+            symNot
+        };
+
+        typedef uint8_t symType;
+
+        Bu::Stack<symType> sOper;
+        Bu::Stack<prec> sValue;
+        Bu::Stack<Bu::String> sFunc;
+
+    private:
+        symType getPrec( symType nOper )
+        {
+            switch( nOper )
+            {
+                case symNumber:
+                case symVariable:
+                case symOpenParen:
+                case symCloseParen:
+                    return 0;
+
+                case symAdd:
+                case symSubtract:
+                    return 1;
+
+                case symMultiply:
+                case symDivide:
+                case symModulus:
+                    return 2;
+
+                case symAnd:
+                case symOr:
+                case symXor:
+                    return 2;
+
+                case symExponent:
+                case symNot:
+                case symNegate:
+                case symFunction:
+                    return 3;
+
+                default:
+                    return 0;
+            }
+        }
+
+        symType nextToken( const char **sBuf )
+        {
+            for(;;)
+            {
+                char cbuf = **sBuf;
+                ++(*sBuf);
+                switch( cbuf )
+                {
+                    case '+':
+                        return symAdd;
+
+                    case '-':
+                        return symSubtract;
+
+                    case '*':
+                        return symMultiply;
+
+                    case '/':
+                        return symDivide;
+
+                    case '^':
+                        return symExponent;
+
+                    case '%':
+                        return symModulus;
+
+                    case '(':
+                        return symOpenParen;
+
+                    case ')':
+                        return symCloseParen;
+
+                    case '|':
+                        return symOr;
+
+                    case '&':
+                        return symAnd;
+
+                    case '#':
+                        return symXor;
+
+                    case '~':
+                        return symNot;
+
+                    case ' ':
+                    case '\t':
+                    case '\n':
+                    case '\r':
+                        break;
+
+                    case '\0':
+                        return symEOS;
+
+                    default:
+                        if( cbuf == '.' || (cbuf >= '0' && cbuf <= '9') )
+                        {
+                            char num[50]={cbuf};
+                            int nPos = 1;
+                            bool bDot = false;
+
+                            for(;;)
+                            {
+                                cbuf = **sBuf;
+                                if( cbuf == '.' )
+                                {
+                                    if( bDot == false )
+                                        bDot = true;
+                                    else
+                                        throw FormulaException(
+                                            "Numbers cannot have more than one "
+                                            ". in them."
+                                            );
+                                }
+                                if( cbuf == '.' ||
+                                    (cbuf >= '0' && cbuf <= '9') )
+                                {
+                                    num[nPos++] = cbuf;
+                                }
+                                else
+                                {
+                                    num[nPos] = '\0';
+                                    sValue.push(
+                                        static_cast<prec>(
+                                            strtod( num, NULL )
+                                            )
+                                        );
+                                    return symNumber;
+                                }
+                                ++(*sBuf);
+                            }
+                        }
+                        else if( (cbuf >= 'a' && cbuf <= 'z') || 
+                                 (cbuf >= 'A' && cbuf <= 'Z') ||
+                                 (cbuf == '_') )
+                        {
+                            char tok[50]={cbuf};
+                            int nPos = 1;
+
+                            for(;;)
+                            {
+                                cbuf = **sBuf;
+                                if( (cbuf >= 'a' && cbuf <= 'z') || 
+                                    (cbuf >= 'A' && cbuf <= 'Z') ||
+                                    (cbuf >= '0' && cbuf <= '9') ||
+                                    cbuf == '_' || cbuf == '.' || cbuf == ':' )
+                                {
+                                    tok[nPos++] = cbuf;
+                                }
+                                else
+                                {
+                                    tok[nPos] = '\0';
+                                    if( hVars.has( tok ) )
+                                    {
+                                        sValue.push( hVars[tok] );
+                                        return symNumber;
+                                    }
+                                    else if( hFunc.has( tok ) )
+                                    {
+                                        sFunc.push( tok );
+                                        return symFunction;
+                                    }
+                                    else
+                                    {
+                                        throw FormulaException(
+                                            "No variable or function named "
+                                            "\"%s\" exists.",
+                                            tok
+                                            );
+                                    }
+                                }
+                                ++(*sBuf);
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+
+        void reduce( bool bCloseParen = false )
+        {
+            while( !sOper.isEmpty() )
+            {
+                uint8_t nOpr = sOper.top();
+                if( nOpr == symOpenParen )
+                {
+                    if( bCloseParen == true )
+                        sOper.pop();
+                    return;
+                }
+                sOper.pop();
+
+                prec dTop = sValue.top();
+                sValue.pop();
+
+                switch( nOpr )
+                {
+                    case symAdd:
+                        sValue.top() += dTop;
+                        break;
+
+                    case symSubtract:
+                        sValue.top() -= dTop;
+                        break;
+
+                    case symMultiply:
+                        sValue.top() *= dTop;
+                        break;
+
+                    case symDivide:
+                        sValue.top() /= dTop;
+                        break;
+
+                    case symExponent:
+                        sValue.top() = static_cast<prec>(
+                                pow( sValue.top(), dTop )
+                            );
+                        break;
+
+                    case symModulus:
+                        sValue.top() = static_cast<prec>(
+                                fmod( sValue.top(), dTop )
+                            );
+                        break;
+
+                    case symOr:
+                        sValue.top() = static_cast<prec>(
+                                static_cast<bin>(sValue.top()) |
+                                static_cast<bin>(dTop)
+                            );
+                        break;
+                    
+                    case symAnd:
+                        sValue.top() = static_cast<prec>(
+                                static_cast<bin>(sValue.top()) &
+                                static_cast<bin>(dTop)
+                            );
+                        break;
+                    
+                    case symXor:
+                        sValue.top() = static_cast<prec>(
+                                static_cast<bin>(sValue.top()) ^
+                                static_cast<bin>(dTop)
+                            );
+                        break;
+
+                    case symFunction:
+                        sValue.push( (*hFunc.get( sFunc.pop() ))( dTop ) );
+                        break;
+
+                    case symNegate:
+                        sValue.push( -dTop );
+                        break;
+
+                    case symNot:
+                        sValue.push( static_cast<prec>(
+                                ~static_cast<bin>(dTop)
+                            ) );
+                        break;
+                }
+            }
+
+            if( bCloseParen == true )
+            {
+                throw FormulaException(
+                    "Close-paren found without matching open-paren."
+                    );
+            }
+        }
+    };
 }
 
 #endif
diff --git a/src/stable/hash.cpp b/src/stable/hash.cpp
index f44104b..85a13c7 100644
--- a/src/stable/hash.cpp
+++ b/src/stable/hash.cpp
@@ -12,58 +12,58 @@ namespace Bu { subExceptionDef( HashException ) }
 template<>
 uint32_t Bu::__calcHashCode<const char *>( const char * const &k )
 {
-        if (k == NULL)
-        {
-                return 0;
-        }
-        
-        unsigned long int nPos = 0;
-        for( const char *s = k; *s; s++ )
-        {
-                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
-        }
+    if (k == NULL)
+    {
+        return 0;
+    }
+    
+    unsigned long int nPos = 0;
+    for( const char *s = k; *s; s++ )
+    {
+        nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+    }
 
-        return nPos;
+    return nPos;
 }
 
 template<> bool Bu::__cmpHashKeys<const char *>( const char * const &a, const char * const &b )
 {
-        if( a == b )
-                return true;
+    if( a == b )
+        return true;
 
-        for(int j=0; a[j] == b[j]; j++ )
-                if( a[j] == '\0' )
-                        return true;
+    for(int j=0; a[j] == b[j]; j++ )
+        if( a[j] == '\0' )
+            return true;
 
-        return false;
+    return false;
 }
 
 template<>
 uint32_t Bu::__calcHashCode<char *>( char * const &k )
 {
-        if (k == NULL)
-        {
-                return 0;
-        }
-        
-        unsigned long int nPos = 0;
-        for( const char *s = k; *s; s++ )
-        {
-                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
-        }
+    if (k == NULL)
+    {
+        return 0;
+    }
+    
+    unsigned long int nPos = 0;
+    for( const char *s = k; *s; s++ )
+    {
+        nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+    }
 
-        return nPos;
+    return nPos;
 }
 
 template<> bool Bu::__cmpHashKeys<char *>( char * const &a, char * const &b )
 {
-        if( a == b )
-                return true;
+    if( a == b )
+        return true;
 
-        for(int j=0; a[j] == b[j]; j++ )
-                if( a[j] == '\0' )
-                        return true;
+    for(int j=0; a[j] == b[j]; j++ )
+        if( a[j] == '\0' )
+            return true;
 
-        return false;
+    return false;
 }
 
diff --git a/src/stable/hash.h b/src/stable/hash.h
index 86f189e..1574a1c 100644
--- a/src/stable/hash.h
+++ b/src/stable/hash.h
@@ -17,1311 +17,1311 @@
 
 namespace Bu
 {
-        subExceptionDecl( HashException )
-
-        enum eHashException
-        {
-                excodeNotFilled
-        };
-
-        template<typename T>
-        uint32_t __calcHashCode( const T &k );
-
-        template<typename T>
-        bool __cmpHashKeys( const T &a, const T &b );
-
-        /**
-         * Default functor used to compute the size of hash tables.  This version
-         * effectively doubles the size of the table when space is low, ensuring
-         * that you always wind up with an odd number for the table size.  A
-         * better but slower option is to always find the next prime number that's
-         * above double your current table size, but that has the potential to be
-         * slower.
-         */
-        struct __calcNextTSize_fast
-        {
-                uint32_t operator()( uint32_t nCapacity, uint32_t nFilled,
-                                uint32_t nDeleted ) const
-                {
-                        // This frist case will allow hashtables that are mostly deleted
-                        // items to reset to small allocations
-                        if( nFilled-nDeleted <= nCapacity/4 )
-                        {
-                                nCapacity = 11;
-                                while( nCapacity < nFilled*5/4 )
-                                        nCapacity = nCapacity*2+1;
-                                return nCapacity;
-                        }
-                        // This will hopefully prevent hash tables from growing needlessly
-                        if( nFilled-nDeleted <= nCapacity/2 )
-                        {
-                                if( nDeleted == 0 )
-                                        return nCapacity/4*5+1;  // Grow just a little
-                                else
-                                        return nCapacity;       // We're going to delete things
-                        }
-                        // Otherwise, just increase the capacity
-                        return nCapacity*2+1;
-                }
-        };
-
-        template<typename totype>
-        int bitsTo( int iCount )
-        {
-                return ( (iCount/(sizeof(totype)*8))
-                                + (iCount%(sizeof(totype)*8)>0 ? 1 : 0));
-        }
-
-        template<typename key, typename value, typename sizecalc, typename keyalloc,
-                typename valuealloc, typename challoc>
-        class Hash;
-
-        /** @cond DEVEL */
-        template<typename key, typename value, typename sizecalc, typename keyalloc,
-                typename valuealloc, typename challoc >
-        class HashCore
-        {
-        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-        friend class SharedCore<
-                Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>,
-                HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc>
-                >;
-        private:
-                HashCore() :
-                        nCapacity( 0 ),
-                        nFilled( 0 ),
-                        nDeleted( 0 ),
-                        bFilled( NULL ),
-                        bDeleted( NULL ),
-                        aKeys( NULL ),
-                        aValues( NULL ),
-                        aHashCodes( NULL )
-                {
-                }
-
-                virtual ~HashCore()
-                {
-                        clear();
-                }
-
-                void init()
-                {
-                        if( nCapacity > 0 )
-                                return;
-
-                        nCapacity = 11;
-                        nKeysSize = bitsTo<uint32_t>( nCapacity );
-                        bFilled = ca.allocate( nKeysSize );
-                        bDeleted = ca.allocate( nKeysSize );
-                        clearBits();
-
-                        aHashCodes = ca.allocate( nCapacity );
-                        aKeys = ka.allocate( nCapacity );
-                        aValues = va.allocate( nCapacity );
-                }
-
-                void clearBits()
-                {
-                        if( nCapacity == 0 )
-                                return;
-
-                        for( uint32_t j = 0; j < nKeysSize; j++ )
-                        {
-                                bFilled[j] = bDeleted[j] = 0;
-                        }
-                }
-
-                void fill( uint32_t loc, const key &k, const value &v, uint32_t hash )
-                {
-                        init();
-
-                        bFilled[loc/32] |= (1<<(loc%32));
-                        va.construct( &aValues[loc], v );
-                        ka.construct( &aKeys[loc], k );
-                        aHashCodes[loc] = hash;
-                        nFilled++;
-                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                        //      nFilled, nDeleted, nCapacity );
-                }
-
-                void _erase( uint32_t loc )
-                {
-                        if( nCapacity == 0 )
-                                return;
-
-                        bDeleted[loc/32] |= (1<<(loc%32));
-                        va.destroy( &aValues[loc] );
-                        ka.destroy( &aKeys[loc] );
-                        nDeleted++;
-                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                        //      nFilled, nDeleted, nCapacity );
-                }
-
-                key &getKeyAtPos( uint32_t nPos )
-                {
-                        if( nPos >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return aKeys[nPos];
-                }
-                
-                const key &getKeyAtPos( uint32_t nPos ) const
-                {
-                        if( nPos >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return aKeys[nPos];
-                }
-                
-                value &getValueAtPos( uint32_t nPos )
-                {
-                        if( nPos >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return aValues[nPos];
-                }
-                
-                const value &getValueAtPos( uint32_t nPos ) const
-                {
-                        if( nPos >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return aValues[nPos];
-                }
-
-                uint32_t getFirstPos( bool &bFinished ) const
-                {
-                        for( uint32_t j = 0; j < nCapacity; j++ )
-                        {
-                                if( isFilled( j ) )
-                                        if( !isDeleted( j ) )
-                                                return j;
-                        }
-
-                        bFinished = true;
-                        return 0;
-                }
-
-                uint32_t getNextPos( uint32_t nPos, bool &bFinished ) const
-                {
-                        for( uint32_t j = nPos+1; j < nCapacity; j++ )
-                        {
-                                if( isFilled( j ) )
-                                        if( !isDeleted( j ) )
-                                                return j;
-                        }
-
-                        bFinished = true;
-                        return 0;
-                }
-
-                uint32_t probe( uint32_t hash, const key &k, bool &bFill, bool rehash=true )
-                {
-                        init();
-
-                        uint32_t nCur = hash%nCapacity;
-
-                        // First we scan to see if the key is already there, abort if we
-                        // run out of probing room, or we find a non-filled entry
-                        int8_t j;
-                        for( j = 0;
-                                isFilled( nCur ) && j < 32;
-                                nCur = (nCur + (1<<j))%nCapacity, j++
-                                )
-                        {
-                                // Is this the same hash code we were looking for?
-                                if( hash == aHashCodes[nCur] )
-                                {
-                                        // Skip over deleted entries.  Deleted entries are also filled,
-                                        // so we only have to do this check here.
-                                        if( isDeleted( nCur ) )
-                                                continue;
-
-                                        // Is it really the same key? (for safety)
-                                        if( __cmpHashKeys( aKeys[nCur], k ) == true )
-                                        {
-                                                bFill = true;
-                                                return nCur;
-                                        }
-                                }
-                        }
-
-                        // This is our insurance, if the table is full, then go ahead and
-                        // rehash, then try again.
-                        if( (isFilled( nCur ) || j == 32) && rehash == true )
-                        {
-                                reHash( szCalc( nCapacity, nFilled, nDeleted ) );
-
-                                // This is potentially dangerous, and could cause an infinite loop.
-                                // Be careful writing probe, eh?
-                                return probe( hash, k, bFill );
-                        }
-
-                        bFill = false;
-                        return nCur;
-                }
-                
-                uint32_t probe( uint32_t hash, key k, bool &bFill ) const
-                {
-                        if( nCapacity == 0 )
-                                throw Bu::ExceptionBase("Probe in empty hash table.");
-
-                        uint32_t nCur = hash%nCapacity;
-
-                        // First we scan to see if the key is already there, abort if we
-                        // run out of probing room, or we find a non-filled entry
-                        for( int8_t j = 0;
-                                isFilled( nCur ) && j < 32;
-                                nCur = (nCur + (1<<j))%nCapacity, j++
-                                )
-                        {
-                                // Is this the same hash code we were looking for?
-                                if( hash == aHashCodes[nCur] )
-                                {
-                                        // Skip over deleted entries.  Deleted entries are also filled,
-                                        // so we only have to do this check here.
-                                        if( isDeleted( nCur ) )
-                                                continue;
-
-                                        // Is it really the same key? (for safety)
-                                        if( __cmpHashKeys( aKeys[nCur], k ) == true )
-                                        {
-                                                bFill = true;
-                                                return nCur;
-                                        }
-                                }
-                        }
-
-                        bFill = false;
-                        return nCur;
-                }
-                
-                void insert( const key &k, const value &v )
-                {
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = probe( hash, k, bFill );
-
-                        if( bFill )
-                        {
-                                va.destroy( &aValues[nPos] );
-                                va.construct( &aValues[nPos], v );
-                        }
-                        else
-                        {
-                                fill( nPos, k, v, hash );
-                        }
-                }
-
-                void reHash( uint32_t nNewSize )
-                {
-                        //printf("--rehash: %d --> %d (%d, %d)\n", nCapacity, nNewSize, nFilled, nDeleted );
-                        //printf("---REHASH---");
-                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                        //      nFilled, nDeleted, nCapacity );
-                        
-                        // Save all the old data
-                        uint32_t nOldCapacity = nCapacity;
-                        uint32_t *bOldFilled = bFilled;
-                        uint32_t *aOldHashCodes = aHashCodes;
-                        uint32_t nOldKeysSize = nKeysSize;
-                        uint32_t *bOldDeleted = bDeleted;
-                        value *aOldValues = aValues;
-                        key *aOldKeys = aKeys;
-                        
-                        // Calculate new sizes
-                        nCapacity = nNewSize;
-                        nKeysSize = bitsTo<uint32_t>( nCapacity );
-                
-                        // Allocate new memory + prep
-                        bFilled = ca.allocate( nKeysSize );
-                        bDeleted = ca.allocate( nKeysSize );
-                        clearBits();
-
-                        aHashCodes = ca.allocate( nCapacity );
-                        aKeys = ka.allocate( nCapacity );
-                        aValues = va.allocate( nCapacity );
-
-                        nDeleted = nFilled = 0;
-
-                        // Re-insert all of the old data (except deleted items)
-                        for( uint32_t j = 0; j < nOldCapacity; j++ )
-                        {
-                                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
-                                        (bOldDeleted[j/32]&(1<<(j%32)))==0 )
-                                {
-                                        insert( aOldKeys[j], aOldValues[j] );
-                                }
-                        }
-
-                        // Delete all of the old data
-                        for( uint32_t j = 0; j < nOldCapacity; j++ )
-                        {
-                                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
-                                        (bOldDeleted[j/32]&(1<<(j%32)))==0 )
-                                {
-                                        va.destroy( &aOldValues[j] );
-                                        ka.destroy( &aOldKeys[j] );
-                                }
-                        }
-                        va.deallocate( aOldValues, nOldCapacity );
-                        ka.deallocate( aOldKeys, nOldCapacity );
-                        ca.deallocate( bOldFilled, nOldKeysSize );
-                        ca.deallocate( bOldDeleted, nOldKeysSize );
-                        ca.deallocate( aOldHashCodes, nOldCapacity );
-                }
-
-                bool isFilled( uint32_t loc ) const
-                {
-                        if( loc >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return (bFilled[loc/32]&(1<<(loc%32)))!=0;
-                }
-
-                bool isDeleted( uint32_t loc ) const
-                {
-                        if( loc >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
-                }
-
-                void clear()
-                {
-                        for( uint32_t j = 0; j < nCapacity; j++ )
-                        {
-                                if( isFilled( j ) )
-                                        if( !isDeleted( j ) )
-                                        {
-                                                va.destroy( &aValues[j] );
-                                                ka.destroy( &aKeys[j] );
-                                        }
-                        }
-                        va.deallocate( aValues, nCapacity );
-                        ka.deallocate( aKeys, nCapacity );
-                        ca.deallocate( bFilled, nKeysSize );
-                        ca.deallocate( bDeleted, nKeysSize );
-                        ca.deallocate( aHashCodes, nCapacity );
-                        
-                        bFilled = NULL;
-                        bDeleted = NULL;
-                        aKeys = NULL;
-                        aValues = NULL;
-                        aHashCodes = NULL;
-                        
-                        nCapacity = 0;
-                        nFilled = 0;
-                        nDeleted = 0;
-                }
-
-                uint32_t nCapacity;
-                uint32_t nFilled;
-                uint32_t nDeleted;
-                uint32_t *bFilled;
-                uint32_t *bDeleted;
-                uint32_t nKeysSize;
-                key *aKeys;
-                value *aValues;
-                uint32_t *aHashCodes;
-                valuealloc va;
-                keyalloc ka;
-                challoc ca;
-                sizecalc szCalc;
-        };
-        /** @endcond */
-
-        /**
-         * Libbu++ Template Hash Table.  This is your average hash table, that uses
-         * template functions in order to do fast, efficient, generalized hashing.
-         * It's pretty easy to use, and works well with all other libbu++ types so
-         * far.
-         *
-         * In order to use it, I recommend the following for all basic usage:
-         *@code
-         // Define a Hash typedef with strings as keys and ints as values.
-         typedef Bu::Hash<Bu::String, int> StrIntHash;
-
-         // Create one
-         StrIntHash hInts;
-
-         // Insert some integers
-         hInts["one"] = 1;
-         hInts["forty-two"] = 42;
-         hInts.insert("forty two", 42 );
-
-         // Get values out of the hash, the last two options are the most explicit,
-         // and must be used if the hash's value type does not match what you're
-         // comparing to exactly.
-         if( hInts["one"] == 1 ) doSomething();
-         if( hInts["forty-two"].value() == 42 ) doSomething();
-         if( hInts.get("forty two") == 42 ) doSomething();
-
-         // Iterate through the Hash
-         for( StrIntHash::iterator i = hInts.begin(); i != hInts.end(); i++ )
-         {
-                // i.getValue() works too
-                print("'%s' = %d\n", i.getKey().getStr(), (*i) );
-         }
-                                                                                                        
-         @endcode
-         *@param key (typename) The datatype of the hashtable keys
-         *@param value (typename) The datatype of the hashtable data
-         *@param sizecalc (typename) Functor to compute new table size on rehash
-         *@param keyalloc (typename) Memory allocator for hashtable keys
-         *@param valuealloc (typename) Memory allocator for hashtable values
-         *@param challoc (typename) Byte allocator for bitflags
-         *@ingroup Containers
-         */
-        template<typename key, typename value,
-                typename sizecalc = __calcNextTSize_fast,
-                typename keyalloc = std::allocator<key>,
-                typename valuealloc = std::allocator<value>,
-                typename challoc = std::allocator<uint32_t>
-                >
-        class Hash : public SharedCore<
-                                 Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>,
-                                 HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc>
-                                 >
-        {
-        private:
-                typedef class HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc> Core;
-                typedef class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> MyType;
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_resetCore;
-                using SharedCore<MyType, Core>::_allocateCore;
-        
-        public:
-                Hash()
-                {
-                }
-
-                Hash( const MyType &src ) :
-                        SharedCore<MyType, Core >( src )
-                {
-                }
-
-                virtual ~Hash()
-                {
-                }
-
-                /**
-                 * Get the current hash table capacity. (Changes at re-hash)
-                 *@returns (uint32_t) The current capacity.
-                 */
-                uint32_t getCapacity() const
-                {
-                        return core->nCapacity;
-                }
-
-                /**
-                 * Get the number of hash locations spoken for. (Including 
-                 * not-yet-cleaned-up deleted items.)
-                 *@returns (uint32_t) The current fill state.
-                 */
-                uint32_t getFill() const
-                {
-                        return core->nFilled;
-                }
-
-                /**
-                 * Get the number of items stored in the hash table.
-                 *@returns (uint32_t) The number of items stored in the hash table.
-                 */
-                uint32_t getSize() const
-                {
-                        return core->nFilled-core->nDeleted;
-                }
-
-                bool isEmpty() const
-                {
-                        return (core->nFilled-core->nDeleted) == 0;
-                }
-
-                /**
-                 * Get the number of items which have been deleted, but not yet
-                 * cleaned up.
-                 *@returns (uint32_t) The number of deleted items.
-                 */
-                uint32_t getDeleted() const
-                {
-                        return core->nDeleted;
-                }
-
-                struct HashProxy
-                {
-                friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-                private:
-                        HashProxy( MyType &h, const key *k, uint32_t nPos, uint32_t hash ) :
-                                hsh( h ),
-                                pKey( k ),
-                                nPos( nPos ),
-                                hash( hash ),
-                                bFilled( false )
-                        {
-                        }
-
-                        HashProxy( MyType &h, uint32_t nPos, value *pValue ) :
-                                hsh( h ),
-                                nPos( nPos ),
-                                pValue( pValue ),
-                                bFilled( true )
-                        {
-                        }
-
-                        MyType &hsh;
-                        const key *pKey;
-                        uint32_t nPos;
-                        value *pValue;
-                        uint32_t hash;
-                        bool bFilled;
-
-                public:
-                        /**
-                         * Cast operator for HashProxy.
-                         *@returns (value_type &) The value the HashProxy is pointing to.
-                         */
-                        operator value &()
-                        {
-                                if( bFilled == false )
-                                        throw HashException(
-                                                        excodeNotFilled,
-                                                        "No data associated with that key."
-                                                        );
-                                return *pValue;
-                        }
-
-                        /**
-                         * Direct function for retrieving a value out of the HashProxy.
-                         *@returns (value_type &) The value pointed to by this HashProxy.
-                         */
-                        value &getValue()
-                        {
-                                if( bFilled == false )
-                                        throw HashException(
-                                                        excodeNotFilled,
-                                                        "No data associated with that key."
-                                                        );
-                                return *pValue;
-                        }
-
-                        /**
-                         * Whether this HashProxy points to something real or not.
-                         */
-                        bool isFilled()
-                        {
-                                return bFilled;
-                        }
-
-                        /**
-                         * Erase the data pointed to by this HashProxy.
-                         */
-                        void erase()
-                        {
-                                if( bFilled )
-                                {
-                                        hsh.core->_erase( nPos );
-                                }
-                        }
-
-                        /**
-                         * Assign data to this point in the hash table.
-                         *@param nval (value_type) the data to assign.
-                         */
-                        value operator=( value nval )
-                        {
-                                if( bFilled )
-                                {
-                                        hsh.core->va.destroy( &hsh.core->aValues[nPos] );
-                                        hsh.core->va.construct( &hsh.core->aValues[nPos], nval );
-                                }
-                                else
-                                {
-                                        hsh.core->fill( nPos, *pKey, nval, hash ); 
-                                }
-
-                                return nval;
-                        }
-
-                        /**
-                         * Pointer extraction operator. Access to members of data pointed to
-                         *              by HashProxy.
-                         *@returns (value_type *)
-                         */
-                        value *operator->()
-                        {
-                                if( bFilled == false )
-                                        throw HashException(
-                                                        excodeNotFilled,
-                                                        "No data associated with that key."
-                                                        );
-                                return pValue;
-                        }
-                };
-
-                /**
-                 * Hash table index operator
-                 *@param k (key_type) Key of data to be retrieved.
-                 *@returns (HashProxy) Proxy pointing to the data.
-                 */
-                HashProxy operator[]( const key &k )
-                {
-                        _hardCopy();
-
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = core->probe( hash, k, bFill );
-
-                        if( bFill )
-                        {
-                                return HashProxy( *this, nPos, &core->aValues[nPos] );
-                        }
-                        else
-                        {
-                                return HashProxy( *this, &k, nPos, hash );
-                        }
-                }
-
-                /**
-                 * Insert a value (v) under key (k) into the hash table
-                 *@param k (key_type) Key to list the value under.
-                 *@param v (value_type) Value to store in the hash table.
-                 */
-                void insert( const key &k, const value &v )
-                {
-                        _hardCopy();
-
-                        core->insert( k, v );
-                }
-
-                /**
-                 * Remove a value from the hash table.
-                 *@param k (key_type) The data under this key will be erased.
-                 */
-                void erase( const key &k )
-                {
-                        _hardCopy();
-
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = core->probe( hash, k, bFill );
-
-                        if( bFill )
-                        {
-                                core->_erase( nPos );
-                        }
-                }
-
-                struct iterator;
-
-                /**
-                 * Remove a value from the hash pointed to from an iterator.
-                 *@param i (iterator &) The data to be erased.
-                 */
-                void erase( struct iterator &i )
-                {
-                        if( this != i.hsh )
-                                throw HashException("This iterator didn't come from this Hash.");
-                        
-                        _hardCopy();
-
-                        if( core->isFilled( i.nPos ) && !core->isDeleted( i.nPos ) )
-                        {
-                                core->_erase( i.nPos );
-                        }
-                }
-
-                /**
-                 * Remove all data from the hash table.
-                 */
-                virtual void clear()
-                {
-                        _resetCore();
-                }
-
-                /**
-                 * Get an item of data from the hash table.
-                 *@param k (key_type) Key pointing to the data to be retrieved.
-                 *@returns (value_type &) The data pointed to by (k).
-                 */
-                value &get( const key &k )
-                {
-                        _hardCopy();
-
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = core->probe( hash, k, bFill, false );
-
-                        if( bFill )
-                        {
-                                return core->aValues[nPos];
-                        }
-                        else
-                        {
-                                throw HashException(
-                                                excodeNotFilled,
-                                                "No data associated with that key."
-                                                );
-                        }
-                }
-                
-                /**
-                 * Get a const item of data from the hash table.
-                 *@param k (key_type) Key pointing to the data to be retrieved.
-                 *@returns (const value_type &) A const version of the data pointed
-                 *              to by (k).
-                 */
-                const value &get( const key &k ) const
-                {
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = core->probe( hash, k, bFill );
-
-                        if( bFill )
-                        {
-                                return core->aValues[nPos];
-                        }
-                        else
-                        {
-                                throw HashException(
-                                                excodeNotFilled,
-                                                "No data associated with that key."
-                                                );
-                        }
-                }
-
-                /**
-                 * Does the hash table contain an item under key (k).
-                 *@param k (key_type) The key to check.
-                 *@returns (bool) Whether there was an item in the hash under key (k).
-                 */
-                bool has( const key &k ) const
-                {
-                        bool bFill;
-                        core->probe( __calcHashCode( k ), k, bFill );
-
-                        return bFill;
-                }
-
-                /**
-                 * Iteration structure for iterating through the hash.
-                 */
-                typedef struct iterator
-                {
-                        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-                private:
-                        iterator( MyType *hsh ) :
-                                hsh( hsh ),
-                                nPos( 0 ),
-                                bFinished( false )
-                        {
-                                nPos = hsh->core->getFirstPos( bFinished );
-                        }
-                        
-                        iterator( MyType *hsh, bool bDone ) :
-                                hsh( hsh ),
-                                nPos( 0 ),
-                                bFinished( bDone )
-                        {
-                        }
-
-                        MyType *hsh;
-                        uint32_t nPos;
-                        bool bFinished;
-
-                public:
-                        iterator( const iterator &i ) :
-                                hsh( i.hsh ),
-                                nPos( i.nPos ),
-                                bFinished( i.bFinished )
-                        {
-                        }
-
-                        iterator() :
-                                hsh( NULL ),
-                                nPos( NULL ),
-                                bFinished( true )
-                        {
-                        }
-
-                        bool isValid() const
-                        {
-                                return !bFinished;
-                        }
-
-                        operator bool() const
-                        {
-                                return !bFinished;
-                        }
-
-                        /**
-                         * Iterator incrementation operator. Move the iterator forward.
-                         */
-                        iterator operator++( int )
-                        {
-                                if( bFinished == false )
-                                        nPos = hsh->core->getNextPos( nPos, bFinished );
-
-                                return *this;
-                        }
-                        
-                        /**
-                         * Iterator incrementation operator. Move the iterator forward.
-                         */
-                        iterator operator++()
-                        {
-                                if( bFinished == false )
-                                        nPos = hsh->core->getNextPos( nPos, bFinished );
-
-                                return *this;
-                        }
-
-                        /**
-                         * Iterator equality comparison operator. Iterators the same?
-                         */
-                        bool operator==( const iterator &oth ) const
-                        {
-                                if( bFinished != oth.bFinished )
-                                        return false;
-                                if( bFinished == true )
-                                {
-                                        return true;
-                                }
-                                else
-                                {
-                                        if( oth.nPos == nPos )
-                                                return true;
-                                        return false;
-                                }
-                        }
-                        
-                        /**
-                         * Iterator not equality comparison operator. Not the same?
-                         */
-                        bool operator!=( const iterator &oth ) const
-                        {
-                                return !(*this == oth );
-                        }
-
-                        /**
-                         * Iterator assignment operator.
-                         */
-                        iterator operator=( const iterator &oth )
-                        {
-                                hsh = oth.hsh;
-                                nPos = oth.nPos;
-                                bFinished = oth.bFinished;
-                                return *this;
-                        }
-
-                        /**
-                         * Iterator dereference operator... err.. get the value
-                         *@returns (value_type &) The value behind this iterator.
-                         */
-                        value &operator *()
-                        {
-                                hsh->_hardCopy();
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-
-                        const value &operator *() const
-                        {
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-                        
-                        /**
-                         * Get the key behind this iterator.
-                         *@returns (key_type &) The key behind this iterator.
-                         */
-                        const key &getKey() const
-                        {
-                                return hsh->core->getKeyAtPos( nPos );
-                        }
-
-                        /**
-                         * Get the value behind this iterator.
-                         *@returns (value_type &) The value behind this iterator.
-                         */
-                        value &getValue()
-                        {
-                                hsh->_hardCopy();
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-
-                        /**
-                         * Get the value behind this iterator.
-                         *@returns (value_type &) The value behind this iterator.
-                         */
-                        const value &getValue() const
-                        {
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-                } iterator;
-                
-                /**
-                 * Iteration structure for iterating through the hash (const).
-                 */
-                typedef struct const_iterator
-                {
-                        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-                private:
-                        const_iterator( const MyType *hsh ) :
-                                hsh( hsh ),
-                                nPos( 0 ),
-                                bFinished( false )
-                        {
-                                nPos = hsh->core->getFirstPos( bFinished );
-                        }
-                        
-                        const_iterator( const MyType *hsh, bool bDone ) :
-                                hsh( hsh ),
-                                nPos( 0 ),
-                                bFinished( bDone )
-                        {
-                        }
-
-                        const MyType *hsh;
-                        uint32_t nPos;
-                        bool bFinished;
-
-                public:
-                        const_iterator() :
-                                hsh( NULL ),
-                                nPos( 0 ),
-                                bFinished( true )
-                        {
-                        }
-
-                        const_iterator( const const_iterator &src ) :
-                                hsh( src.hsh ),
-                                nPos( src.nPos ),
-                                bFinished( src.bFinished )
-                        {
-                        }
-
-                        const_iterator( const iterator &src ) :
-                                hsh( src.hsh ),
-                                nPos( src.nPos ),
-                                bFinished( src.bFinished )
-                        {
-                        }
-
-                        bool isValid() const
-                        {
-                                return !bFinished;
-                        }
-
-                        operator bool() const
-                        {
-                                return !bFinished;
-                        }
-
-                        /**
-                         * Iterator incrementation operator. Move the iterator forward.
-                         */
-                        const_iterator operator++( int )
-                        {
-                                if( bFinished == false )
-                                        nPos = hsh->core->getNextPos( nPos, bFinished );
-
-                                return *this;
-                        }
-                        
-                        /**
-                         * Iterator incrementation operator. Move the iterator forward.
-                         */
-                        const_iterator operator++()
-                        {
-                                if( bFinished == false )
-                                        nPos = hsh->core->getNextPos( nPos, bFinished );
-
-                                return *this;
-                        }
-
-                        /**
-                         * Iterator equality comparison operator. Iterators the same?
-                         */
-                        bool operator==( const const_iterator &oth ) const
-                        {
-                                if( bFinished != oth.bFinished )
-                                        return false;
-                                if( bFinished == true )
-                                {
-                                        return true;
-                                }
-                                else
-                                {
-                                        if( oth.nPos == nPos )
-                                                return true;
-                                        return false;
-                                }
-                        }
-                        
-                        /**
-                         * Iterator not equality comparison operator. Not the same?
-                         */
-                        bool operator!=( const const_iterator &oth ) const
-                        {
-                                return !(*this == oth );
-                        }
-
-                        /**
-                         * Iterator assignment operator.
-                         */
-                        const_iterator operator=( const const_iterator &oth )
-                        {
-                                hsh = oth.hsh;
-                                nPos = oth.nPos;
-                                bFinished = oth.bFinished;
-                                return *this;
-                        }
-
-                        /**
-                         * Iterator dereference operator... err.. get the value
-                         *@returns (value_type &) The value behind this iterator.
-                         */
-                        const value &operator *() const
-                        {
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-                        
-                        /**
-                         * Get the key behind this iterator.
-                         *@returns (key_type &) The key behind this iterator.
-                         */
-                        const key &getKey() const
-                        {
-                                return hsh->core->getKeyAtPos( nPos );
-                        }
-
-                        /**
-                         * Get the value behind this iterator.
-                         *@returns (value_type &) The value behind this iterator.
-                         */
-                        const value &getValue() const
-                        {
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-                } const_iterator;
-
-                /**
-                 * Get an iterator pointing to the first item in the hash table.
-                 *@returns (iterator) An iterator pointing to the first item in the
-                 *              hash table.
-                 */
-                iterator begin()
-                {
-                        return iterator( this );
-                }
-                
-                const_iterator begin() const
-                {
-                        return const_iterator( this );
-                }
-                
-                /**
-                 * Get an iterator pointing to a point just past the last item in the
-                 *              hash table.
-                 *@returns (iterator) An iterator pointing to a point just past the
-                 *              last item in the hash table.
-                 */
-                iterator end()
-                {
-                        return iterator( this, true );
-                }
-                
-                const_iterator end() const
-                {
-                        return const_iterator( this, true );
-                }
-
-                /**
-                 * Get a list of all the keys in the hash table.
-                 *@returns (std::list<key_type>) The list of keys in the hash table.
-                 */
-                Bu::List<key> getKeys() const
-                {
-                        Bu::List<key> lKeys;
-
-                        for( uint32_t j = 0; j < core->nCapacity; j++ )
-                        {
-                                if( core->isFilled( j ) )
-                                {
-                                        if( !core->isDeleted( j ) )
-                                        {
-                                                lKeys.append( core->aKeys[j] );
-                                        }
-                                }
-                        }
-
-                        return lKeys;
-                }
-                
-                Bu::List<value> getValues() const
-                {
-                        Bu::List<value> lValues;
-
-                        for( uint32_t j = 0; j < core->nCapacity; j++ )
-                        {
-                                if( core->isFilled( j ) )
-                                {
-                                        if( !core->isDeleted( j ) )
-                                        {
-                                                lValues.append( core->aValues[j] );
-                                        }
-                                }
-                        }
-
-                        return lValues;
-                }
-
-                bool operator==( const MyType &rhs ) const
-                {
-                        if( this == &rhs )
-                                return true;
-                        if( core == rhs.core )
-                                return true;
-                        if( core == NULL || rhs.core == NULL )
-                                return false;
-                        if( getSize() != rhs.getSize() )
-                                return false;
-
-                        for( uint32_t j = 0; j < core->nCapacity; j++ )
-                        {
-                                if( core->isFilled( j ) )
-                                {
-                                        if( !core->isDeleted( j ) )
-                                        {
-                                                // Check to see if this key is in the other hash
-                                                if( rhs.has( core->aKeys[j] ) )
-                                                {
-                                                        if( !(core->aValues[j] == rhs.get( core->aKeys[j]) ) )
-                                                        {
-                                                                return false;
-                                                        }
-                                                }
-                                                else
-                                                {
-                                                        return false;
-                                                }
-                                        }
-                                }
-                        }
-
-                        return true;
-                }
-
-                bool operator!=( const MyType &rhs ) const
-                {
-                        return !(*this == rhs);
-                }
-
-                MyType &operator+=( const MyType &rhs )
-                {
-                        if( this == &rhs )
-                                return *this;
-                        if( core == rhs.core )
-                                return *this;
-                        if( core == NULL || rhs.core == NULL )
-                                return *this;
-
-                        for( const_iterator i = rhs.begin(); i; i++ )
-                                insert( i.getKey(), i.getValue() );
-
-                        return *this;
-                }
-
-        protected:
-                virtual Core *_copyCore( Core *src )
-                {
-                        Core *pRet = _allocateCore();
-
-                        pRet->nFilled = 0;
-                        pRet->nDeleted = 0;
-                        pRet->nCapacity = src->nCapacity;
-                        pRet->nKeysSize = bitsTo<uint32_t>( pRet->nCapacity );
-                        pRet->bFilled = pRet->ca.allocate( pRet->nKeysSize );
-                        pRet->bDeleted = pRet->ca.allocate( pRet->nKeysSize );
-                        pRet->clearBits();
-
-                        pRet->aHashCodes = pRet->ca.allocate( pRet->nCapacity );
-                        pRet->aKeys = pRet->ka.allocate( pRet->nCapacity );
-                        pRet->aValues = pRet->va.allocate( pRet->nCapacity );
-
-                        for( uint32_t j = 0; j < src->nCapacity; j++ )
-                        {
-                                if( src->isFilled( j ) && !src->isDeleted( j ) )
-                                {
-                                        pRet->insert( src->aKeys[j], src->aValues[j] );
-                                }
-                        }
-
-                        return pRet;
-                }
-        };
-        
-        template<typename T> uint32_t __calcHashCode( const T &k )
-        {
-                return static_cast<uint32_t>( k );
-        }
-
-        template<typename T> bool __cmpHashKeys( const T &a, const T &b )
-        {
-                return (a == b);
-        }
-
-        template<> uint32_t __calcHashCode<const char *>( const char * const &k );
-        template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b );
-
-        template<> uint32_t __calcHashCode<char *>( char * const &k );
-        template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b );
-
-        class Formatter;
-        Formatter &operator<<( Formatter &rOut, char *sStr );
-        Formatter &operator<<( Formatter &rOut, signed char c );
-        template<typename key, typename value>
-        Formatter &operator<<( Formatter &f, const Bu::Hash<key, value> &l )
-        {
-                f << '{';
-                for( typename Bu::Hash<key,value>::const_iterator i = l.begin(); i; i++ )
-                {
-                        if( i != l.begin() )
-                                f << ", ";
-                        f << i.getKey() << ": " << i.getValue();
-                }
-                f << '}';
-
-                return f;
-        }
-
-        template<typename key, typename value, typename a, typename b,
-                typename c, typename d>
-        ArchiveBase &operator<<( ArchiveBase &ar, const Hash<key,value,a,b,c,d> &h )
-        {
-                long iSize = h.getSize();
-                ar << iSize;
-                for( typename Hash<key,value,a,b,c,d>::const_iterator i = h.begin(); i != h.end(); i++ )
-                {
-                        ar << (i.getKey());
-                        ar << (i.getValue());
-                }
-
-                return ar;
-        }
-
-        template<typename key, typename value, typename a, typename b,
-                typename c, typename d>
-        ArchiveBase &operator>>( ArchiveBase &ar, Hash<key,value,a,b,c,d> &h )
-        {
-                h.clear();
-                long nSize;
-                ar >> nSize;
-
-                for( long j = 0; j < nSize; j++ )
-                {
-                        key k; value v;
-                        ar >> k >> v;
-                        h.insert( k, v );
-                }
-
-                return ar;
-        }
+    subExceptionDecl( HashException )
+
+    enum eHashException
+    {
+        excodeNotFilled
+    };
+
+    template<typename T>
+    uint32_t __calcHashCode( const T &k );
+
+    template<typename T>
+    bool __cmpHashKeys( const T &a, const T &b );
+
+    /**
+     * Default functor used to compute the size of hash tables.  This version
+     * effectively doubles the size of the table when space is low, ensuring
+     * that you always wind up with an odd number for the table size.  A
+     * better but slower option is to always find the next prime number that's
+     * above double your current table size, but that has the potential to be
+     * slower.
+     */
+    struct __calcNextTSize_fast
+    {
+        uint32_t operator()( uint32_t nCapacity, uint32_t nFilled,
+                uint32_t nDeleted ) const
+        {
+            // This frist case will allow hashtables that are mostly deleted
+            // items to reset to small allocations
+            if( nFilled-nDeleted <= nCapacity/4 )
+            {
+                nCapacity = 11;
+                while( nCapacity < nFilled*5/4 )
+                    nCapacity = nCapacity*2+1;
+                return nCapacity;
+            }
+            // This will hopefully prevent hash tables from growing needlessly
+            if( nFilled-nDeleted <= nCapacity/2 )
+            {
+                if( nDeleted == 0 )
+                    return nCapacity/4*5+1;  // Grow just a little
+                else
+                    return nCapacity;   // We're going to delete things
+            }
+            // Otherwise, just increase the capacity
+            return nCapacity*2+1;
+        }
+    };
+
+    template<typename totype>
+    int bitsTo( int iCount )
+    {
+        return ( (iCount/(sizeof(totype)*8))
+                + (iCount%(sizeof(totype)*8)>0 ? 1 : 0));
+    }
+
+    template<typename key, typename value, typename sizecalc, typename keyalloc,
+        typename valuealloc, typename challoc>
+    class Hash;
+
+    /** @cond DEVEL */
+    template<typename key, typename value, typename sizecalc, typename keyalloc,
+        typename valuealloc, typename challoc >
+    class HashCore
+    {
+    friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+    friend class SharedCore<
+        Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>,
+        HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc>
+        >;
+    private:
+        HashCore() :
+            nCapacity( 0 ),
+            nFilled( 0 ),
+            nDeleted( 0 ),
+            bFilled( NULL ),
+            bDeleted( NULL ),
+            aKeys( NULL ),
+            aValues( NULL ),
+            aHashCodes( NULL )
+        {
+        }
+
+        virtual ~HashCore()
+        {
+            clear();
+        }
+
+        void init()
+        {
+            if( nCapacity > 0 )
+                return;
+
+            nCapacity = 11;
+            nKeysSize = bitsTo<uint32_t>( nCapacity );
+            bFilled = ca.allocate( nKeysSize );
+            bDeleted = ca.allocate( nKeysSize );
+            clearBits();
+
+            aHashCodes = ca.allocate( nCapacity );
+            aKeys = ka.allocate( nCapacity );
+            aValues = va.allocate( nCapacity );
+        }
+
+        void clearBits()
+        {
+            if( nCapacity == 0 )
+                return;
+
+            for( uint32_t j = 0; j < nKeysSize; j++ )
+            {
+                bFilled[j] = bDeleted[j] = 0;
+            }
+        }
+
+        void fill( uint32_t loc, const key &k, const value &v, uint32_t hash )
+        {
+            init();
+
+            bFilled[loc/32] |= (1<<(loc%32));
+            va.construct( &aValues[loc], v );
+            ka.construct( &aKeys[loc], k );
+            aHashCodes[loc] = hash;
+            nFilled++;
+            //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+            //  nFilled, nDeleted, nCapacity );
+        }
+
+        void _erase( uint32_t loc )
+        {
+            if( nCapacity == 0 )
+                return;
+
+            bDeleted[loc/32] |= (1<<(loc%32));
+            va.destroy( &aValues[loc] );
+            ka.destroy( &aKeys[loc] );
+            nDeleted++;
+            //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+            //  nFilled, nDeleted, nCapacity );
+        }
+
+        key &getKeyAtPos( uint32_t nPos )
+        {
+            if( nPos >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return aKeys[nPos];
+        }
+        
+        const key &getKeyAtPos( uint32_t nPos ) const
+        {
+            if( nPos >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return aKeys[nPos];
+        }
+        
+        value &getValueAtPos( uint32_t nPos )
+        {
+            if( nPos >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return aValues[nPos];
+        }
+        
+        const value &getValueAtPos( uint32_t nPos ) const
+        {
+            if( nPos >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return aValues[nPos];
+        }
+
+        uint32_t getFirstPos( bool &bFinished ) const
+        {
+            for( uint32_t j = 0; j < nCapacity; j++ )
+            {
+                if( isFilled( j ) )
+                    if( !isDeleted( j ) )
+                        return j;
+            }
+
+            bFinished = true;
+            return 0;
+        }
+
+        uint32_t getNextPos( uint32_t nPos, bool &bFinished ) const
+        {
+            for( uint32_t j = nPos+1; j < nCapacity; j++ )
+            {
+                if( isFilled( j ) )
+                    if( !isDeleted( j ) )
+                        return j;
+            }
+
+            bFinished = true;
+            return 0;
+        }
+
+        uint32_t probe( uint32_t hash, const key &k, bool &bFill, bool rehash=true )
+        {
+            init();
+
+            uint32_t nCur = hash%nCapacity;
+
+            // First we scan to see if the key is already there, abort if we
+            // run out of probing room, or we find a non-filled entry
+            int8_t j;
+            for( j = 0;
+                isFilled( nCur ) && j < 32;
+                nCur = (nCur + (1<<j))%nCapacity, j++
+                )
+            {
+                // Is this the same hash code we were looking for?
+                if( hash == aHashCodes[nCur] )
+                {
+                    // Skip over deleted entries.  Deleted entries are also filled,
+                    // so we only have to do this check here.
+                    if( isDeleted( nCur ) )
+                        continue;
+
+                    // Is it really the same key? (for safety)
+                    if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                    {
+                        bFill = true;
+                        return nCur;
+                    }
+                }
+            }
+
+            // This is our insurance, if the table is full, then go ahead and
+            // rehash, then try again.
+            if( (isFilled( nCur ) || j == 32) && rehash == true )
+            {
+                reHash( szCalc( nCapacity, nFilled, nDeleted ) );
+
+                // This is potentially dangerous, and could cause an infinite loop.
+                // Be careful writing probe, eh?
+                return probe( hash, k, bFill );
+            }
+
+            bFill = false;
+            return nCur;
+        }
+        
+        uint32_t probe( uint32_t hash, key k, bool &bFill ) const
+        {
+            if( nCapacity == 0 )
+                throw Bu::ExceptionBase("Probe in empty hash table.");
+
+            uint32_t nCur = hash%nCapacity;
+
+            // First we scan to see if the key is already there, abort if we
+            // run out of probing room, or we find a non-filled entry
+            for( int8_t j = 0;
+                isFilled( nCur ) && j < 32;
+                nCur = (nCur + (1<<j))%nCapacity, j++
+                )
+            {
+                // Is this the same hash code we were looking for?
+                if( hash == aHashCodes[nCur] )
+                {
+                    // Skip over deleted entries.  Deleted entries are also filled,
+                    // so we only have to do this check here.
+                    if( isDeleted( nCur ) )
+                        continue;
+
+                    // Is it really the same key? (for safety)
+                    if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                    {
+                        bFill = true;
+                        return nCur;
+                    }
+                }
+            }
+
+            bFill = false;
+            return nCur;
+        }
+        
+        void insert( const key &k, const value &v )
+        {
+            uint32_t hash = __calcHashCode( k );
+            bool bFill;
+            uint32_t nPos = probe( hash, k, bFill );
+
+            if( bFill )
+            {
+                va.destroy( &aValues[nPos] );
+                va.construct( &aValues[nPos], v );
+            }
+            else
+            {
+                fill( nPos, k, v, hash );
+            }
+        }
+
+        void reHash( uint32_t nNewSize )
+        {
+            //printf("--rehash: %d --> %d (%d, %d)\n", nCapacity, nNewSize, nFilled, nDeleted );
+            //printf("---REHASH---");
+            //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+            //  nFilled, nDeleted, nCapacity );
+            
+            // Save all the old data
+            uint32_t nOldCapacity = nCapacity;
+            uint32_t *bOldFilled = bFilled;
+            uint32_t *aOldHashCodes = aHashCodes;
+            uint32_t nOldKeysSize = nKeysSize;
+            uint32_t *bOldDeleted = bDeleted;
+            value *aOldValues = aValues;
+            key *aOldKeys = aKeys;
+            
+            // Calculate new sizes
+            nCapacity = nNewSize;
+            nKeysSize = bitsTo<uint32_t>( nCapacity );
+        
+            // Allocate new memory + prep
+            bFilled = ca.allocate( nKeysSize );
+            bDeleted = ca.allocate( nKeysSize );
+            clearBits();
+
+            aHashCodes = ca.allocate( nCapacity );
+            aKeys = ka.allocate( nCapacity );
+            aValues = va.allocate( nCapacity );
+
+            nDeleted = nFilled = 0;
+
+            // Re-insert all of the old data (except deleted items)
+            for( uint32_t j = 0; j < nOldCapacity; j++ )
+            {
+                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
+                    (bOldDeleted[j/32]&(1<<(j%32)))==0 )
+                {
+                    insert( aOldKeys[j], aOldValues[j] );
+                }
+            }
+
+            // Delete all of the old data
+            for( uint32_t j = 0; j < nOldCapacity; j++ )
+            {
+                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
+                    (bOldDeleted[j/32]&(1<<(j%32)))==0 )
+                {
+                    va.destroy( &aOldValues[j] );
+                    ka.destroy( &aOldKeys[j] );
+                }
+            }
+            va.deallocate( aOldValues, nOldCapacity );
+            ka.deallocate( aOldKeys, nOldCapacity );
+            ca.deallocate( bOldFilled, nOldKeysSize );
+            ca.deallocate( bOldDeleted, nOldKeysSize );
+            ca.deallocate( aOldHashCodes, nOldCapacity );
+        }
+
+        bool isFilled( uint32_t loc ) const
+        {
+            if( loc >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return (bFilled[loc/32]&(1<<(loc%32)))!=0;
+        }
+
+        bool isDeleted( uint32_t loc ) const
+        {
+            if( loc >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
+        }
+
+        void clear()
+        {
+            for( uint32_t j = 0; j < nCapacity; j++ )
+            {
+                if( isFilled( j ) )
+                    if( !isDeleted( j ) )
+                    {
+                        va.destroy( &aValues[j] );
+                        ka.destroy( &aKeys[j] );
+                    }
+            }
+            va.deallocate( aValues, nCapacity );
+            ka.deallocate( aKeys, nCapacity );
+            ca.deallocate( bFilled, nKeysSize );
+            ca.deallocate( bDeleted, nKeysSize );
+            ca.deallocate( aHashCodes, nCapacity );
+            
+            bFilled = NULL;
+            bDeleted = NULL;
+            aKeys = NULL;
+            aValues = NULL;
+            aHashCodes = NULL;
+            
+            nCapacity = 0;
+            nFilled = 0;
+            nDeleted = 0;
+        }
+
+        uint32_t nCapacity;
+        uint32_t nFilled;
+        uint32_t nDeleted;
+        uint32_t *bFilled;
+        uint32_t *bDeleted;
+        uint32_t nKeysSize;
+        key *aKeys;
+        value *aValues;
+        uint32_t *aHashCodes;
+        valuealloc va;
+        keyalloc ka;
+        challoc ca;
+        sizecalc szCalc;
+    };
+    /** @endcond */
+
+    /**
+     * Libbu++ Template Hash Table.  This is your average hash table, that uses
+     * template functions in order to do fast, efficient, generalized hashing.
+     * It's pretty easy to use, and works well with all other libbu++ types so
+     * far.
+     *
+     * In order to use it, I recommend the following for all basic usage:
+     *@code
+     // Define a Hash typedef with strings as keys and ints as values.
+     typedef Bu::Hash<Bu::String, int> StrIntHash;
+
+     // Create one
+     StrIntHash hInts;
+
+     // Insert some integers
+     hInts["one"] = 1;
+     hInts["forty-two"] = 42;
+     hInts.insert("forty two", 42 );
+
+     // Get values out of the hash, the last two options are the most explicit,
+     // and must be used if the hash's value type does not match what you're
+     // comparing to exactly.
+     if( hInts["one"] == 1 ) doSomething();
+     if( hInts["forty-two"].value() == 42 ) doSomething();
+     if( hInts.get("forty two") == 42 ) doSomething();
+
+     // Iterate through the Hash
+     for( StrIntHash::iterator i = hInts.begin(); i != hInts.end(); i++ )
+     {
+        // i.getValue() works too
+        print("'%s' = %d\n", i.getKey().getStr(), (*i) );
+     }
+                                                    
+     @endcode
+     *@param key (typename) The datatype of the hashtable keys
+     *@param value (typename) The datatype of the hashtable data
+     *@param sizecalc (typename) Functor to compute new table size on rehash
+     *@param keyalloc (typename) Memory allocator for hashtable keys
+     *@param valuealloc (typename) Memory allocator for hashtable values
+     *@param challoc (typename) Byte allocator for bitflags
+     *@ingroup Containers
+     */
+    template<typename key, typename value,
+        typename sizecalc = __calcNextTSize_fast,
+        typename keyalloc = std::allocator<key>,
+        typename valuealloc = std::allocator<value>,
+        typename challoc = std::allocator<uint32_t>
+        >
+    class Hash : public SharedCore<
+                 Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>,
+                 HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc>
+                 >
+    {
+    private:
+        typedef class HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc> Core;
+        typedef class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> MyType;
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_resetCore;
+        using SharedCore<MyType, Core>::_allocateCore;
+    
+    public:
+        Hash()
+        {
+        }
+
+        Hash( const MyType &src ) :
+            SharedCore<MyType, Core >( src )
+        {
+        }
+
+        virtual ~Hash()
+        {
+        }
+
+        /**
+         * Get the current hash table capacity. (Changes at re-hash)
+         *@returns (uint32_t) The current capacity.
+         */
+        uint32_t getCapacity() const
+        {
+            return core->nCapacity;
+        }
+
+        /**
+         * Get the number of hash locations spoken for. (Including 
+         * not-yet-cleaned-up deleted items.)
+         *@returns (uint32_t) The current fill state.
+         */
+        uint32_t getFill() const
+        {
+            return core->nFilled;
+        }
+
+        /**
+         * Get the number of items stored in the hash table.
+         *@returns (uint32_t) The number of items stored in the hash table.
+         */
+        uint32_t getSize() const
+        {
+            return core->nFilled-core->nDeleted;
+        }
+
+        bool isEmpty() const
+        {
+            return (core->nFilled-core->nDeleted) == 0;
+        }
+
+        /**
+         * Get the number of items which have been deleted, but not yet
+         * cleaned up.
+         *@returns (uint32_t) The number of deleted items.
+         */
+        uint32_t getDeleted() const
+        {
+            return core->nDeleted;
+        }
+
+        struct HashProxy
+        {
+        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+        private:
+            HashProxy( MyType &h, const key *k, uint32_t nPos, uint32_t hash ) :
+                hsh( h ),
+                pKey( k ),
+                nPos( nPos ),
+                hash( hash ),
+                bFilled( false )
+            {
+            }
+
+            HashProxy( MyType &h, uint32_t nPos, value *pValue ) :
+                hsh( h ),
+                nPos( nPos ),
+                pValue( pValue ),
+                bFilled( true )
+            {
+            }
+
+            MyType &hsh;
+            const key *pKey;
+            uint32_t nPos;
+            value *pValue;
+            uint32_t hash;
+            bool bFilled;
+
+        public:
+            /**
+             * Cast operator for HashProxy.
+             *@returns (value_type &) The value the HashProxy is pointing to.
+             */
+            operator value &()
+            {
+                if( bFilled == false )
+                    throw HashException(
+                            excodeNotFilled,
+                            "No data associated with that key."
+                            );
+                return *pValue;
+            }
+
+            /**
+             * Direct function for retrieving a value out of the HashProxy.
+             *@returns (value_type &) The value pointed to by this HashProxy.
+             */
+            value &getValue()
+            {
+                if( bFilled == false )
+                    throw HashException(
+                            excodeNotFilled,
+                            "No data associated with that key."
+                            );
+                return *pValue;
+            }
+
+            /**
+             * Whether this HashProxy points to something real or not.
+             */
+            bool isFilled()
+            {
+                return bFilled;
+            }
+
+            /**
+             * Erase the data pointed to by this HashProxy.
+             */
+            void erase()
+            {
+                if( bFilled )
+                {
+                    hsh.core->_erase( nPos );
+                }
+            }
+
+            /**
+             * Assign data to this point in the hash table.
+             *@param nval (value_type) the data to assign.
+             */
+            value operator=( value nval )
+            {
+                if( bFilled )
+                {
+                    hsh.core->va.destroy( &hsh.core->aValues[nPos] );
+                    hsh.core->va.construct( &hsh.core->aValues[nPos], nval );
+                }
+                else
+                {
+                    hsh.core->fill( nPos, *pKey, nval, hash ); 
+                }
+
+                return nval;
+            }
+
+            /**
+             * Pointer extraction operator. Access to members of data pointed to
+             *      by HashProxy.
+             *@returns (value_type *)
+             */
+            value *operator->()
+            {
+                if( bFilled == false )
+                    throw HashException(
+                            excodeNotFilled,
+                            "No data associated with that key."
+                            );
+                return pValue;
+            }
+        };
+
+        /**
+         * Hash table index operator
+         *@param k (key_type) Key of data to be retrieved.
+         *@returns (HashProxy) Proxy pointing to the data.
+         */
+        HashProxy operator[]( const key &k )
+        {
+            _hardCopy();
+
+            uint32_t hash = __calcHashCode( k );
+            bool bFill;
+            uint32_t nPos = core->probe( hash, k, bFill );
+
+            if( bFill )
+            {
+                return HashProxy( *this, nPos, &core->aValues[nPos] );
+            }
+            else
+            {
+                return HashProxy( *this, &k, nPos, hash );
+            }
+        }
+
+        /**
+         * Insert a value (v) under key (k) into the hash table
+         *@param k (key_type) Key to list the value under.
+         *@param v (value_type) Value to store in the hash table.
+         */
+        void insert( const key &k, const value &v )
+        {
+            _hardCopy();
+
+            core->insert( k, v );
+        }
+
+        /**
+         * Remove a value from the hash table.
+         *@param k (key_type) The data under this key will be erased.
+         */
+        void erase( const key &k )
+        {
+            _hardCopy();
+
+            uint32_t hash = __calcHashCode( k );
+            bool bFill;
+            uint32_t nPos = core->probe( hash, k, bFill );
+
+            if( bFill )
+            {
+                core->_erase( nPos );
+            }
+        }
+
+        struct iterator;
+
+        /**
+         * Remove a value from the hash pointed to from an iterator.
+         *@param i (iterator &) The data to be erased.
+         */
+        void erase( struct iterator &i )
+        {
+            if( this != i.hsh )
+                throw HashException("This iterator didn't come from this Hash.");
+            
+            _hardCopy();
+
+            if( core->isFilled( i.nPos ) && !core->isDeleted( i.nPos ) )
+            {
+                core->_erase( i.nPos );
+            }
+        }
+
+        /**
+         * Remove all data from the hash table.
+         */
+        virtual void clear()
+        {
+            _resetCore();
+        }
+
+        /**
+         * Get an item of data from the hash table.
+         *@param k (key_type) Key pointing to the data to be retrieved.
+         *@returns (value_type &) The data pointed to by (k).
+         */
+        value &get( const key &k )
+        {
+            _hardCopy();
+
+            uint32_t hash = __calcHashCode( k );
+            bool bFill;
+            uint32_t nPos = core->probe( hash, k, bFill, false );
+
+            if( bFill )
+            {
+                return core->aValues[nPos];
+            }
+            else
+            {
+                throw HashException(
+                        excodeNotFilled,
+                        "No data associated with that key."
+                        );
+            }
+        }
+        
+        /**
+         * Get a const item of data from the hash table.
+         *@param k (key_type) Key pointing to the data to be retrieved.
+         *@returns (const value_type &) A const version of the data pointed
+         *      to by (k).
+         */
+        const value &get( const key &k ) const
+        {
+            uint32_t hash = __calcHashCode( k );
+            bool bFill;
+            uint32_t nPos = core->probe( hash, k, bFill );
+
+            if( bFill )
+            {
+                return core->aValues[nPos];
+            }
+            else
+            {
+                throw HashException(
+                        excodeNotFilled,
+                        "No data associated with that key."
+                        );
+            }
+        }
+
+        /**
+         * Does the hash table contain an item under key (k).
+         *@param k (key_type) The key to check.
+         *@returns (bool) Whether there was an item in the hash under key (k).
+         */
+        bool has( const key &k ) const
+        {
+            bool bFill;
+            core->probe( __calcHashCode( k ), k, bFill );
+
+            return bFill;
+        }
+
+        /**
+         * Iteration structure for iterating through the hash.
+         */
+        typedef struct iterator
+        {
+            friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+        private:
+            iterator( MyType *hsh ) :
+                hsh( hsh ),
+                nPos( 0 ),
+                bFinished( false )
+            {
+                nPos = hsh->core->getFirstPos( bFinished );
+            }
+            
+            iterator( MyType *hsh, bool bDone ) :
+                hsh( hsh ),
+                nPos( 0 ),
+                bFinished( bDone )
+            {
+            }
+
+            MyType *hsh;
+            uint32_t nPos;
+            bool bFinished;
+
+        public:
+            iterator( const iterator &i ) :
+                hsh( i.hsh ),
+                nPos( i.nPos ),
+                bFinished( i.bFinished )
+            {
+            }
+
+            iterator() :
+                hsh( NULL ),
+                nPos( NULL ),
+                bFinished( true )
+            {
+            }
+
+            bool isValid() const
+            {
+                return !bFinished;
+            }
+
+            operator bool() const
+            {
+                return !bFinished;
+            }
+
+            /**
+             * Iterator incrementation operator. Move the iterator forward.
+             */
+            iterator operator++( int )
+            {
+                if( bFinished == false )
+                    nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                return *this;
+            }
+            
+            /**
+             * Iterator incrementation operator. Move the iterator forward.
+             */
+            iterator operator++()
+            {
+                if( bFinished == false )
+                    nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                return *this;
+            }
+
+            /**
+             * Iterator equality comparison operator. Iterators the same?
+             */
+            bool operator==( const iterator &oth ) const
+            {
+                if( bFinished != oth.bFinished )
+                    return false;
+                if( bFinished == true )
+                {
+                    return true;
+                }
+                else
+                {
+                    if( oth.nPos == nPos )
+                        return true;
+                    return false;
+                }
+            }
+            
+            /**
+             * Iterator not equality comparison operator. Not the same?
+             */
+            bool operator!=( const iterator &oth ) const
+            {
+                return !(*this == oth );
+            }
+
+            /**
+             * Iterator assignment operator.
+             */
+            iterator operator=( const iterator &oth )
+            {
+                hsh = oth.hsh;
+                nPos = oth.nPos;
+                bFinished = oth.bFinished;
+                return *this;
+            }
+
+            /**
+             * Iterator dereference operator... err.. get the value
+             *@returns (value_type &) The value behind this iterator.
+             */
+            value &operator *()
+            {
+                hsh->_hardCopy();
+                return hsh->core->getValueAtPos( nPos );
+            }
+
+            const value &operator *() const
+            {
+                return hsh->core->getValueAtPos( nPos );
+            }
+            
+            /**
+             * Get the key behind this iterator.
+             *@returns (key_type &) The key behind this iterator.
+             */
+            const key &getKey() const
+            {
+                return hsh->core->getKeyAtPos( nPos );
+            }
+
+            /**
+             * Get the value behind this iterator.
+             *@returns (value_type &) The value behind this iterator.
+             */
+            value &getValue()
+            {
+                hsh->_hardCopy();
+                return hsh->core->getValueAtPos( nPos );
+            }
+
+            /**
+             * Get the value behind this iterator.
+             *@returns (value_type &) The value behind this iterator.
+             */
+            const value &getValue() const
+            {
+                return hsh->core->getValueAtPos( nPos );
+            }
+        } iterator;
+        
+        /**
+         * Iteration structure for iterating through the hash (const).
+         */
+        typedef struct const_iterator
+        {
+            friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+        private:
+            const_iterator( const MyType *hsh ) :
+                hsh( hsh ),
+                nPos( 0 ),
+                bFinished( false )
+            {
+                nPos = hsh->core->getFirstPos( bFinished );
+            }
+            
+            const_iterator( const MyType *hsh, bool bDone ) :
+                hsh( hsh ),
+                nPos( 0 ),
+                bFinished( bDone )
+            {
+            }
+
+            const MyType *hsh;
+            uint32_t nPos;
+            bool bFinished;
+
+        public:
+            const_iterator() :
+                hsh( NULL ),
+                nPos( 0 ),
+                bFinished( true )
+            {
+            }
+
+            const_iterator( const const_iterator &src ) :
+                hsh( src.hsh ),
+                nPos( src.nPos ),
+                bFinished( src.bFinished )
+            {
+            }
+
+            const_iterator( const iterator &src ) :
+                hsh( src.hsh ),
+                nPos( src.nPos ),
+                bFinished( src.bFinished )
+            {
+            }
+
+            bool isValid() const
+            {
+                return !bFinished;
+            }
+
+            operator bool() const
+            {
+                return !bFinished;
+            }
+
+            /**
+             * Iterator incrementation operator. Move the iterator forward.
+             */
+            const_iterator operator++( int )
+            {
+                if( bFinished == false )
+                    nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                return *this;
+            }
+            
+            /**
+             * Iterator incrementation operator. Move the iterator forward.
+             */
+            const_iterator operator++()
+            {
+                if( bFinished == false )
+                    nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                return *this;
+            }
+
+            /**
+             * Iterator equality comparison operator. Iterators the same?
+             */
+            bool operator==( const const_iterator &oth ) const
+            {
+                if( bFinished != oth.bFinished )
+                    return false;
+                if( bFinished == true )
+                {
+                    return true;
+                }
+                else
+                {
+                    if( oth.nPos == nPos )
+                        return true;
+                    return false;
+                }
+            }
+            
+            /**
+             * Iterator not equality comparison operator. Not the same?
+             */
+            bool operator!=( const const_iterator &oth ) const
+            {
+                return !(*this == oth );
+            }
+
+            /**
+             * Iterator assignment operator.
+             */
+            const_iterator operator=( const const_iterator &oth )
+            {
+                hsh = oth.hsh;
+                nPos = oth.nPos;
+                bFinished = oth.bFinished;
+                return *this;
+            }
+
+            /**
+             * Iterator dereference operator... err.. get the value
+             *@returns (value_type &) The value behind this iterator.
+             */
+            const value &operator *() const
+            {
+                return hsh->core->getValueAtPos( nPos );
+            }
+            
+            /**
+             * Get the key behind this iterator.
+             *@returns (key_type &) The key behind this iterator.
+             */
+            const key &getKey() const
+            {
+                return hsh->core->getKeyAtPos( nPos );
+            }
+
+            /**
+             * Get the value behind this iterator.
+             *@returns (value_type &) The value behind this iterator.
+             */
+            const value &getValue() const
+            {
+                return hsh->core->getValueAtPos( nPos );
+            }
+        } const_iterator;
+
+        /**
+         * Get an iterator pointing to the first item in the hash table.
+         *@returns (iterator) An iterator pointing to the first item in the
+         *      hash table.
+         */
+        iterator begin()
+        {
+            return iterator( this );
+        }
+        
+        const_iterator begin() const
+        {
+            return const_iterator( this );
+        }
+        
+        /**
+         * Get an iterator pointing to a point just past the last item in the
+         *      hash table.
+         *@returns (iterator) An iterator pointing to a point just past the
+         *      last item in the hash table.
+         */
+        iterator end()
+        {
+            return iterator( this, true );
+        }
+        
+        const_iterator end() const
+        {
+            return const_iterator( this, true );
+        }
+
+        /**
+         * Get a list of all the keys in the hash table.
+         *@returns (std::list<key_type>) The list of keys in the hash table.
+         */
+        Bu::List<key> getKeys() const
+        {
+            Bu::List<key> lKeys;
+
+            for( uint32_t j = 0; j < core->nCapacity; j++ )
+            {
+                if( core->isFilled( j ) )
+                {
+                    if( !core->isDeleted( j ) )
+                    {
+                        lKeys.append( core->aKeys[j] );
+                    }
+                }
+            }
+
+            return lKeys;
+        }
+        
+        Bu::List<value> getValues() const
+        {
+            Bu::List<value> lValues;
+
+            for( uint32_t j = 0; j < core->nCapacity; j++ )
+            {
+                if( core->isFilled( j ) )
+                {
+                    if( !core->isDeleted( j ) )
+                    {
+                        lValues.append( core->aValues[j] );
+                    }
+                }
+            }
+
+            return lValues;
+        }
+
+        bool operator==( const MyType &rhs ) const
+        {
+            if( this == &rhs )
+                return true;
+            if( core == rhs.core )
+                return true;
+            if( core == NULL || rhs.core == NULL )
+                return false;
+            if( getSize() != rhs.getSize() )
+                return false;
+
+            for( uint32_t j = 0; j < core->nCapacity; j++ )
+            {
+                if( core->isFilled( j ) )
+                {
+                    if( !core->isDeleted( j ) )
+                    {
+                        // Check to see if this key is in the other hash
+                        if( rhs.has( core->aKeys[j] ) )
+                        {
+                            if( !(core->aValues[j] == rhs.get( core->aKeys[j]) ) )
+                            {
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        bool operator!=( const MyType &rhs ) const
+        {
+            return !(*this == rhs);
+        }
+
+        MyType &operator+=( const MyType &rhs )
+        {
+            if( this == &rhs )
+                return *this;
+            if( core == rhs.core )
+                return *this;
+            if( core == NULL || rhs.core == NULL )
+                return *this;
+
+            for( const_iterator i = rhs.begin(); i; i++ )
+                insert( i.getKey(), i.getValue() );
+
+            return *this;
+        }
+
+    protected:
+        virtual Core *_copyCore( Core *src )
+        {
+            Core *pRet = _allocateCore();
+
+            pRet->nFilled = 0;
+            pRet->nDeleted = 0;
+            pRet->nCapacity = src->nCapacity;
+            pRet->nKeysSize = bitsTo<uint32_t>( pRet->nCapacity );
+            pRet->bFilled = pRet->ca.allocate( pRet->nKeysSize );
+            pRet->bDeleted = pRet->ca.allocate( pRet->nKeysSize );
+            pRet->clearBits();
+
+            pRet->aHashCodes = pRet->ca.allocate( pRet->nCapacity );
+            pRet->aKeys = pRet->ka.allocate( pRet->nCapacity );
+            pRet->aValues = pRet->va.allocate( pRet->nCapacity );
+
+            for( uint32_t j = 0; j < src->nCapacity; j++ )
+            {
+                if( src->isFilled( j ) && !src->isDeleted( j ) )
+                {
+                    pRet->insert( src->aKeys[j], src->aValues[j] );
+                }
+            }
+
+            return pRet;
+        }
+    };
+    
+    template<typename T> uint32_t __calcHashCode( const T &k )
+    {
+        return static_cast<uint32_t>( k );
+    }
+
+    template<typename T> bool __cmpHashKeys( const T &a, const T &b )
+    {
+        return (a == b);
+    }
+
+    template<> uint32_t __calcHashCode<const char *>( const char * const &k );
+    template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b );
+
+    template<> uint32_t __calcHashCode<char *>( char * const &k );
+    template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b );
+
+    class Formatter;
+    Formatter &operator<<( Formatter &rOut, char *sStr );
+    Formatter &operator<<( Formatter &rOut, signed char c );
+    template<typename key, typename value>
+    Formatter &operator<<( Formatter &f, const Bu::Hash<key, value> &l )
+    {
+        f << '{';
+        for( typename Bu::Hash<key,value>::const_iterator i = l.begin(); i; i++ )
+        {
+            if( i != l.begin() )
+                f << ", ";
+            f << i.getKey() << ": " << i.getValue();
+        }
+        f << '}';
+
+        return f;
+    }
+
+    template<typename key, typename value, typename a, typename b,
+        typename c, typename d>
+    ArchiveBase &operator<<( ArchiveBase &ar, const Hash<key,value,a,b,c,d> &h )
+    {
+        long iSize = h.getSize();
+        ar << iSize;
+        for( typename Hash<key,value,a,b,c,d>::const_iterator i = h.begin(); i != h.end(); i++ )
+        {
+            ar << (i.getKey());
+            ar << (i.getValue());
+        }
+
+        return ar;
+    }
+
+    template<typename key, typename value, typename a, typename b,
+        typename c, typename d>
+    ArchiveBase &operator>>( ArchiveBase &ar, Hash<key,value,a,b,c,d> &h )
+    {
+        h.clear();
+        long nSize;
+        ar >> nSize;
+
+        for( long j = 0; j < nSize; j++ )
+        {
+            key k; value v;
+            ar >> k >> v;
+            h.insert( k, v );
+        }
+
+        return ar;
+    }
 }
 
 #endif
diff --git a/src/stable/heap.h b/src/stable/heap.h
index a813f92..5033618 100644
--- a/src/stable/heap.h
+++ b/src/stable/heap.h
@@ -17,596 +17,596 @@
 
 namespace Bu
 {
-        subExceptionDecl( HeapException );
-
-        template<typename item, typename cmpfunc, typename itemalloc>
-        class Heap;
-
-        /** @cond DEVEL */
-        template<typename item, typename cmpfunc, typename itemalloc>
-        class HeapCore
-        {
-        friend class Heap<item, cmpfunc, itemalloc>;
-        friend class SharedCore<
-                Heap<item, cmpfunc, itemalloc>, HeapCore<item, cmpfunc, itemalloc>
-                >;
-        private:
-                HeapCore() :
-                        iSize( 0 ),
-                        iFill( 0 ),
-                        aItem( NULL )
-                {
-                }
-
-                virtual ~HeapCore()
-                {
-                        clear();
-                }
-
-                void init()
-                {
-                        if( iSize > 0 )
-                                return;
-
-                        iSize = 7;
-                        iFill = 0;
-                        aItem = ia.allocate( iSize );
-                }
-
-                void init( int iCap )
-                {
-                        if( iSize > 0 )
-                                return;
-
-                        for( iSize = 1; iSize < iCap; iSize=iSize*2+1 ) { }
-                        iFill = 0;
-                        aItem = ia.allocate( iSize );
-                }
-
-                void clear()
-                {
-                        if( iSize == 0 )
-                                return;
-
-                        for( int j = 0; j < iFill; j++ )
-                                ia.destroy( &aItem[j] );
-                        ia.deallocate( aItem, iSize );
-                        aItem = NULL;
-                        iSize = 0;
-                        iFill = 0;
-                }
-                
-                void upSize()
-                {
-                        if( iSize == 0 )
-                        {
-                                init();
-                                return;
-                        }
-
-                        item *aNewItems = ia.allocate( iSize*2+1 );
-                        //
-                        // We cannot use a memcopy here because we don't know what kind
-                        // of datastructures are being used, we have to copy them one at
-                        // a time.
-                        //
-                        for( int j = 0; j < iFill; j++ )
-                        {
-                                ia.construct( &aNewItems[j], aItem[j] );
-                                ia.destroy( &aItem[j] );
-                        }
-                        ia.deallocate( aItem, iSize );
-                        aItem = aNewItems;
-                        iSize = iSize*2+1;
-                }
-                
-                virtual void enqueue( const item &it )
-                {
-                        item i = it; // TODO: This is a silly workaround, put the i item
-                                                 // at the end.
-                        if( iFill+1 >= iSize )
-                                upSize();
-
-                        for( int j = 0; j < iFill; )
-                        {
-                                if( cmp( i, aItem[j] ) )
-                                {
-                                        Bu::swap( i, aItem[j] );
-                                }
-
-                                if( j*2+1 >= iFill )
-                                        break;
-                                if( cmp( i, aItem[j*2+1] ) )
-                                {
-                                        j = j*2+1;
-                                }
-                                else
-                                {
-                                        j = j*2+2;
-                                }
-                        }
-                        ia.construct( &aItem[iFill], i );
-                        if( iFill > 0 )
-                        {
-                                for( int j = iFill; j >= 0; )
-                                {
-                                        int k = (j-1)/2;
-                                        if( j == k )
-                                                break;
-                                        if( cmp( aItem[k], aItem[j] ) )
-                                                break;
-
-                                        Bu::swap( aItem[k], aItem[j] );
-                                        j = k;
-                                }
-                        }
-                        iFill++;
-                }
-
-                virtual item dequeue()
-                {
-                        if( iFill == 0 )
-                                throw HeapException("Heap empty.");
-                        item iRet = aItem[0];
-                        int j;
-                        for( j = 0; j < iFill; )
-                        {
-                                int k = j*2+1;
-                                if( k+1 < iFill && cmp( aItem[k+1], aItem[k] ) )
-                                {
-                                        if( k+1 < iFill-1 && cmp( aItem[iFill-1], aItem[k+1] ) )
-                                                break;
-                                        aItem[j] = aItem[k+1];
-                                        j = k+1;
-                                }
-                                else if( k < iFill )
-                                {
-                                        if( k < iFill-1 && cmp( aItem[iFill-1], aItem[k] ) )
-                                                break;
-                                        aItem[j] = aItem[k];
-                                        j = k;
-                                }
-                                else
-                                        break;
-                        }
-                        if( j < iFill-1 )
-                                aItem[j] = aItem[iFill-1];
-                        ia.destroy( &aItem[iFill-1] );
-                        iFill--;
-
-                        return iRet;
-                }
-
-        private:
-                int iSize;
-                int iFill;
-                item *aItem;
-                cmpfunc cmp;
-                itemalloc ia;
-        };
-        /** @endcond */
-
-        /**
-         * A priority queue that allows for an unlimited number of priorities.  All
-         * objects enqueued must support less-than-comparison.  Then every time an
-         * item is dequeued it is always the least item in the heap.  The heap
-         * operates using a binary tree for storage, which allows most operations
-         * to be very fast.  Enqueueing and dequeueing are both O(log(N)) operatoins
-         * whereas peeking is constant time.
-         *
-         * This heap implementation allows iterating, however please note that any
-         * enqueue or dequeue operation will invalidate the iterator and make it
-         * unusable (if it still works, you shouldn't trust the results).  Also,
-         * the items are not stored in memory in order, they are optomized into a
-         * tree.  This means that the items will be in effectively random order
-         * while iterating through them, and the order cannot be trusted.  Also,
-         * modifying an item in the heap will not cause that item to be re-sorted.
-         * If you want to change the position of an item in the heap you will have
-         * to dequeue every item before it, dequeue that item, change it, and
-         * re-enqueue all of the items removed.
-         */
-        template<typename item, typename cmpfunc=__basicLTCmp<item>, typename itemalloc=std::allocator<item> >
-        class Heap : public Queue<item>, public SharedCore<
-                                 Heap<item, cmpfunc, itemalloc>,
-                                 HeapCore<item, cmpfunc, itemalloc>
-                                 >
-        {
-        private:
-                typedef class Heap<item,cmpfunc,itemalloc> MyType;
-                typedef class HeapCore<item,cmpfunc,itemalloc> Core;
-
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_resetCore;
-                using SharedCore<MyType, Core>::_allocateCore;
-
-        public:
-                Heap()
-                {
-                }
-                
-                Heap( cmpfunc cmpin )
-                {
-                        core->cmp = cmpin;
-                }
-
-                Heap( int iInitialCapacity )
-                {
-                        core->init( iInitialCapacity );
-                }
-                
-                Heap( cmpfunc cmpin, int iInitialCapacity )
-                {
-                        core->cmp = cmpin;
-                        core->init( iInitialCapacity );
-                }
-
-                Heap( const MyType &rSrc ) :
-                        SharedCore<MyType, Core>( rSrc )
-                {
-                }
-
-                virtual ~Heap()
-                {
-                }
-
-                virtual void enqueue( const item &it )
-                {
-                        _hardCopy();
-
-                        core->enqueue( it );
-                }
-
-                virtual item &peek()
-                {
-                        _hardCopy();
-
-                        if( core->iFill == 0 )
-                                throw HeapException("Heap empty.");
-                        return core->aItem[0];
-                }
-
-                virtual const item &peek() const
-                {
-                        if( core->iFill == 0 )
-                                throw HeapException("Heap empty.");
-                        return core->aItem[0];
-                }
-
-                virtual item dequeue()
-                {
-                        _hardCopy();
-
-                        return core->dequeue();
-                }
-
-                virtual bool isEmpty() const
-                {
-                        return (core->iFill==0);
-                }
-
-                virtual int getSize() const
-                {
-                        return core->iFill;
-                }
-
-                class iterator
-                {
-                        friend class const_iterator;
-                        friend class Heap<item, cmpfunc, itemalloc>;
-                private:
-                        Heap<item, cmpfunc, itemalloc> *pHeap;
-                        int iIndex;
-
-                        iterator( Heap<item, cmpfunc, itemalloc> *pHeap, int iIndex ) :
-                                pHeap( pHeap ), iIndex( iIndex )
-                        {
-                        }
-
-                        void checkValid()
-                        {
-                                if( pHeap == NULL )
-                                        throw Bu::ExceptionBase("Iterator not initialized.");
-                                if( iIndex < 0 || iIndex >= pHeap->core->iFill )
-                                        throw Bu::ExceptionBase("Iterator out of bounds.");
-                        }
-
-                public:
-                        iterator() :
-                                pHeap( NULL ),
-                                iIndex( -1 )
-                        {
-                        }
-
-                        iterator( const iterator &i ) :
-                                pHeap( i.pHeap ),
-                                iIndex( i.iIndex )
-                        {
-                        }
-
-                        bool operator==( const iterator &oth ) const
-                        {
-                                return (oth.pHeap == pHeap) && (oth.iIndex == iIndex);
-                        }
-
-                        bool operator!=( const iterator &oth ) const
-                        {
-                                return (oth.pHeap != pHeap) || (oth.iIndex != iIndex);
-                        }
-
-                        item &operator*()
-                        {
-                                pHeap->_hardCopy();
-
-                                return pHeap->core->aItem[iIndex];
-                        }
-
-                        item *operator->()
-                        {
-                                pHeap->_hardCopy();
-
-                                return &(pHeap->core->aItem[iIndex]);
-                        }
-
-                        iterator &operator++()
-                        {
-                                checkValid();
-                                iIndex++;
-                                if( iIndex >= pHeap->iFill )
-                                        iIndex = -1;
-
-                                return *this;
-                        }
-
-                        iterator &operator--()
-                        {
-                                checkValid();
-                                iIndex--;
-
-                                return *this;
-                        }
-                        
-                        iterator &operator++( int )
-                        {
-                                checkValid();
-                                iIndex++;
-                                if( iIndex >= pHeap->core->iFill )
-                                        iIndex = -1;
-
-                                return *this;
-                        }
-
-                        iterator &operator--( int )
-                        {
-                                checkValid();
-                                iIndex--;
-
-                                return *this;
-                        }
-
-                        iterator operator+( int iDelta )
-                        {
-                                checkValid();
-                                iterator ret( *this );
-                                ret.iIndex += iDelta;
-                                if( ret.iIndex >= pHeap->core->iFill )
-                                        ret.iIndex = -1;
-                                return ret;
-                        }
-
-                        iterator operator-( int iDelta )
-                        {
-                                checkValid();
-                                iterator ret( *this );
-                                ret.iIndex -= iDelta;
-                                if( ret.iIndex < 0 )
-                                        ret.iIndex = -1;
-                                return ret;
-                        }
-
-                        operator bool() const
-                        {
-                                return iIndex != -1;
-                        }
-
-                        bool isValid() const
-                        {
-                                return iIndex != -1;
-                        }
-
-                        iterator &operator=( const iterator &oth )
-                        {
-                                pHeap = oth.pHeap;
-                                iIndex = oth.iIndex;
-                        }
-                };
-                
-                class const_iterator
-                {
-                        friend class Heap<item, cmpfunc, itemalloc>;
-                private:
-                        Heap<item, cmpfunc, itemalloc> *pHeap;
-                        int iIndex;
-
-                        const_iterator( Heap<item, cmpfunc, itemalloc> *pHeap,
-                                        int iIndex ) :
-                                pHeap( pHeap ), iIndex( iIndex )
-                        {
-                        }
-
-                        void checkValid()
-                        {
-                                if( pHeap == NULL )
-                                        throw Bu::ExceptionBase("Iterator not initialized.");
-                                if( iIndex < 0 || iIndex >= pHeap->core->iFill )
-                                        throw Bu::ExceptionBase("Iterator out of bounds.");
-                        }
-
-                public:
-                        const_iterator() :
-                                pHeap( NULL ),
-                                iIndex( -1 )
-                        {
-                        }
-                        
-                        const_iterator( const const_iterator &i ) :
-                                pHeap( i.pHeap ),
-                                iIndex( i.iIndex )
-                        {
-                        }
-                        
-                        const_iterator( const iterator &i ) :
-                                pHeap( i.pHeap ),
-                                iIndex( i.iIndex )
-                        {
-                        }
-
-                        bool operator==( const const_iterator &oth ) const
-                        {
-                                return (oth.pHeap == pHeap) && (oth.iIndex == iIndex);
-                        }
-
-                        bool operator!=( const const_iterator &oth ) const
-                        {
-                                return (oth.pHeap != pHeap) || (oth.iIndex != iIndex);
-                        }
-
-                        const item &operator*()
-                        {
-                                pHeap->_hardCopy();
-
-                                return pHeap->core->aItem[iIndex];
-                        }
-
-                        const item *operator->()
-                        {
-                                pHeap->_hardCopy();
-
-                                return &(pHeap->core->aItem[iIndex]);
-                        }
-
-                        const_iterator &operator++()
-                        {
-                                checkValid();
-                                iIndex++;
-                                if( iIndex >= pHeap->core->iFill )
-                                        iIndex = -1;
-
-                                return *this;
-                        }
-
-                        const_iterator &operator--()
-                        {
-                                checkValid();
-                                iIndex--;
-
-                                return *this;
-                        }
-                        
-                        const_iterator &operator++( int )
-                        {
-                                checkValid();
-                                iIndex++;
-                                if( iIndex >= pHeap->core->iFill )
-                                        iIndex = -1;
-
-                                return *this;
-                        }
-
-                        const_iterator &operator--( int )
-                        {
-                                checkValid();
-                                iIndex--;
-
-                                return *this;
-                        }
-
-                        const_iterator operator+( int iDelta )
-                        {
-                                checkValid();
-                                const_iterator ret( *this );
-                                ret.iIndex += iDelta;
-                                if( ret.iIndex >= pHeap->iFill )
-                                        ret.iIndex = -1;
-                                return ret;
-                        }
-
-                        const_iterator operator-( int iDelta )
-                        {
-                                checkValid();
-                                const_iterator ret( *this );
-                                ret.iIndex -= iDelta;
-                                if( ret.iIndex < 0 )
-                                        ret.iIndex = -1;
-                                return ret;
-                        }
-
-                        operator bool() const
-                        {
-                                return iIndex != -1;
-                        }
-
-                        bool isValid() const
-                        {
-                                return iIndex != -1;
-                        }
-
-                        const_iterator &operator=( const const_iterator &oth )
-                        {
-                                pHeap = oth.pHeap;
-                                iIndex = oth.iIndex;
-                        }
-
-                        const_iterator &operator=( const iterator &oth )
-                        {
-                                pHeap = oth.pHeap;
-                                iIndex = oth.iIndex;
-                        }
-                };
-
-                iterator begin()
-                {
-                        if( core->iFill == 0 )
-                                return end();
-                        return iterator( this, 0 );
-                }
-
-                const_iterator begin() const
-                {
-                        if( core->iFill == 0 )
-                                return end();
-                        return const_iterator( this, 0 );
-                }
-
-                iterator end()
-                {
-                        return iterator( this, -1 );
-                }
-
-                const_iterator end() const
-                {
-                        return const_iterator( this, -1 );
-                }
-
-
-        protected:
-                virtual Core *_copyCore( Core *src )
-                {
-                        Core *pRet = _allocateCore();
-
-                        pRet->iSize = src->iSize;
-                        pRet->iFill = src->iFill;
-                        pRet->cmp = src->cmp;
-                        pRet->aItem = pRet->ia.allocate( pRet->iSize );
-                        for( int j = 0; j < pRet->iFill; j++ )
-                        {
-                                pRet->ia.construct( &pRet->aItem[j], src->aItem[j] );
-                        }
-
-                        return pRet;
-                }
-        };
+    subExceptionDecl( HeapException );
+
+    template<typename item, typename cmpfunc, typename itemalloc>
+    class Heap;
+
+    /** @cond DEVEL */
+    template<typename item, typename cmpfunc, typename itemalloc>
+    class HeapCore
+    {
+    friend class Heap<item, cmpfunc, itemalloc>;
+    friend class SharedCore<
+        Heap<item, cmpfunc, itemalloc>, HeapCore<item, cmpfunc, itemalloc>
+        >;
+    private:
+        HeapCore() :
+            iSize( 0 ),
+            iFill( 0 ),
+            aItem( NULL )
+        {
+        }
+
+        virtual ~HeapCore()
+        {
+            clear();
+        }
+
+        void init()
+        {
+            if( iSize > 0 )
+                return;
+
+            iSize = 7;
+            iFill = 0;
+            aItem = ia.allocate( iSize );
+        }
+
+        void init( int iCap )
+        {
+            if( iSize > 0 )
+                return;
+
+            for( iSize = 1; iSize < iCap; iSize=iSize*2+1 ) { }
+            iFill = 0;
+            aItem = ia.allocate( iSize );
+        }
+
+        void clear()
+        {
+            if( iSize == 0 )
+                return;
+
+            for( int j = 0; j < iFill; j++ )
+                ia.destroy( &aItem[j] );
+            ia.deallocate( aItem, iSize );
+            aItem = NULL;
+            iSize = 0;
+            iFill = 0;
+        }
+        
+        void upSize()
+        {
+            if( iSize == 0 )
+            {
+                init();
+                return;
+            }
+
+            item *aNewItems = ia.allocate( iSize*2+1 );
+            //
+            // We cannot use a memcopy here because we don't know what kind
+            // of datastructures are being used, we have to copy them one at
+            // a time.
+            //
+            for( int j = 0; j < iFill; j++ )
+            {
+                ia.construct( &aNewItems[j], aItem[j] );
+                ia.destroy( &aItem[j] );
+            }
+            ia.deallocate( aItem, iSize );
+            aItem = aNewItems;
+            iSize = iSize*2+1;
+        }
+        
+        virtual void enqueue( const item &it )
+        {
+            item i = it; // TODO: This is a silly workaround, put the i item
+                         // at the end.
+            if( iFill+1 >= iSize )
+                upSize();
+
+            for( int j = 0; j < iFill; )
+            {
+                if( cmp( i, aItem[j] ) )
+                {
+                    Bu::swap( i, aItem[j] );
+                }
+
+                if( j*2+1 >= iFill )
+                    break;
+                if( cmp( i, aItem[j*2+1] ) )
+                {
+                    j = j*2+1;
+                }
+                else
+                {
+                    j = j*2+2;
+                }
+            }
+            ia.construct( &aItem[iFill], i );
+            if( iFill > 0 )
+            {
+                for( int j = iFill; j >= 0; )
+                {
+                    int k = (j-1)/2;
+                    if( j == k )
+                        break;
+                    if( cmp( aItem[k], aItem[j] ) )
+                        break;
+
+                    Bu::swap( aItem[k], aItem[j] );
+                    j = k;
+                }
+            }
+            iFill++;
+        }
+
+        virtual item dequeue()
+        {
+            if( iFill == 0 )
+                throw HeapException("Heap empty.");
+            item iRet = aItem[0];
+            int j;
+            for( j = 0; j < iFill; )
+            {
+                int k = j*2+1;
+                if( k+1 < iFill && cmp( aItem[k+1], aItem[k] ) )
+                {
+                    if( k+1 < iFill-1 && cmp( aItem[iFill-1], aItem[k+1] ) )
+                        break;
+                    aItem[j] = aItem[k+1];
+                    j = k+1;
+                }
+                else if( k < iFill )
+                {
+                    if( k < iFill-1 && cmp( aItem[iFill-1], aItem[k] ) )
+                        break;
+                    aItem[j] = aItem[k];
+                    j = k;
+                }
+                else
+                    break;
+            }
+            if( j < iFill-1 )
+                aItem[j] = aItem[iFill-1];
+            ia.destroy( &aItem[iFill-1] );
+            iFill--;
+
+            return iRet;
+        }
+
+    private:
+        int iSize;
+        int iFill;
+        item *aItem;
+        cmpfunc cmp;
+        itemalloc ia;
+    };
+    /** @endcond */
+
+    /**
+     * A priority queue that allows for an unlimited number of priorities.  All
+     * objects enqueued must support less-than-comparison.  Then every time an
+     * item is dequeued it is always the least item in the heap.  The heap
+     * operates using a binary tree for storage, which allows most operations
+     * to be very fast.  Enqueueing and dequeueing are both O(log(N)) operatoins
+     * whereas peeking is constant time.
+     *
+     * This heap implementation allows iterating, however please note that any
+     * enqueue or dequeue operation will invalidate the iterator and make it
+     * unusable (if it still works, you shouldn't trust the results).  Also,
+     * the items are not stored in memory in order, they are optomized into a
+     * tree.  This means that the items will be in effectively random order
+     * while iterating through them, and the order cannot be trusted.  Also,
+     * modifying an item in the heap will not cause that item to be re-sorted.
+     * If you want to change the position of an item in the heap you will have
+     * to dequeue every item before it, dequeue that item, change it, and
+     * re-enqueue all of the items removed.
+     */
+    template<typename item, typename cmpfunc=__basicLTCmp<item>, typename itemalloc=std::allocator<item> >
+    class Heap : public Queue<item>, public SharedCore<
+                 Heap<item, cmpfunc, itemalloc>,
+                 HeapCore<item, cmpfunc, itemalloc>
+                 >
+    {
+    private:
+        typedef class Heap<item,cmpfunc,itemalloc> MyType;
+        typedef class HeapCore<item,cmpfunc,itemalloc> Core;
+
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_resetCore;
+        using SharedCore<MyType, Core>::_allocateCore;
+
+    public:
+        Heap()
+        {
+        }
+        
+        Heap( cmpfunc cmpin )
+        {
+            core->cmp = cmpin;
+        }
+
+        Heap( int iInitialCapacity )
+        {
+            core->init( iInitialCapacity );
+        }
+        
+        Heap( cmpfunc cmpin, int iInitialCapacity )
+        {
+            core->cmp = cmpin;
+            core->init( iInitialCapacity );
+        }
+
+        Heap( const MyType &rSrc ) :
+            SharedCore<MyType, Core>( rSrc )
+        {
+        }
+
+        virtual ~Heap()
+        {
+        }
+
+        virtual void enqueue( const item &it )
+        {
+            _hardCopy();
+
+            core->enqueue( it );
+        }
+
+        virtual item &peek()
+        {
+            _hardCopy();
+
+            if( core->iFill == 0 )
+                throw HeapException("Heap empty.");
+            return core->aItem[0];
+        }
+
+        virtual const item &peek() const
+        {
+            if( core->iFill == 0 )
+                throw HeapException("Heap empty.");
+            return core->aItem[0];
+        }
+
+        virtual item dequeue()
+        {
+            _hardCopy();
+
+            return core->dequeue();
+        }
+
+        virtual bool isEmpty() const
+        {
+            return (core->iFill==0);
+        }
+
+        virtual int getSize() const
+        {
+            return core->iFill;
+        }
+
+        class iterator
+        {
+            friend class const_iterator;
+            friend class Heap<item, cmpfunc, itemalloc>;
+        private:
+            Heap<item, cmpfunc, itemalloc> *pHeap;
+            int iIndex;
+
+            iterator( Heap<item, cmpfunc, itemalloc> *pHeap, int iIndex ) :
+                pHeap( pHeap ), iIndex( iIndex )
+            {
+            }
+
+            void checkValid()
+            {
+                if( pHeap == NULL )
+                    throw Bu::ExceptionBase("Iterator not initialized.");
+                if( iIndex < 0 || iIndex >= pHeap->core->iFill )
+                    throw Bu::ExceptionBase("Iterator out of bounds.");
+            }
+
+        public:
+            iterator() :
+                pHeap( NULL ),
+                iIndex( -1 )
+            {
+            }
+
+            iterator( const iterator &i ) :
+                pHeap( i.pHeap ),
+                iIndex( i.iIndex )
+            {
+            }
+
+            bool operator==( const iterator &oth ) const
+            {
+                return (oth.pHeap == pHeap) && (oth.iIndex == iIndex);
+            }
+
+            bool operator!=( const iterator &oth ) const
+            {
+                return (oth.pHeap != pHeap) || (oth.iIndex != iIndex);
+            }
+
+            item &operator*()
+            {
+                pHeap->_hardCopy();
+
+                return pHeap->core->aItem[iIndex];
+            }
+
+            item *operator->()
+            {
+                pHeap->_hardCopy();
+
+                return &(pHeap->core->aItem[iIndex]);
+            }
+
+            iterator &operator++()
+            {
+                checkValid();
+                iIndex++;
+                if( iIndex >= pHeap->iFill )
+                    iIndex = -1;
+
+                return *this;
+            }
+
+            iterator &operator--()
+            {
+                checkValid();
+                iIndex--;
+
+                return *this;
+            }
+            
+            iterator &operator++( int )
+            {
+                checkValid();
+                iIndex++;
+                if( iIndex >= pHeap->core->iFill )
+                    iIndex = -1;
+
+                return *this;
+            }
+
+            iterator &operator--( int )
+            {
+                checkValid();
+                iIndex--;
+
+                return *this;
+            }
+
+            iterator operator+( int iDelta )
+            {
+                checkValid();
+                iterator ret( *this );
+                ret.iIndex += iDelta;
+                if( ret.iIndex >= pHeap->core->iFill )
+                    ret.iIndex = -1;
+                return ret;
+            }
+
+            iterator operator-( int iDelta )
+            {
+                checkValid();
+                iterator ret( *this );
+                ret.iIndex -= iDelta;
+                if( ret.iIndex < 0 )
+                    ret.iIndex = -1;
+                return ret;
+            }
+
+            operator bool() const
+            {
+                return iIndex != -1;
+            }
+
+            bool isValid() const
+            {
+                return iIndex != -1;
+            }
+
+            iterator &operator=( const iterator &oth )
+            {
+                pHeap = oth.pHeap;
+                iIndex = oth.iIndex;
+            }
+        };
+        
+        class const_iterator
+        {
+            friend class Heap<item, cmpfunc, itemalloc>;
+        private:
+            Heap<item, cmpfunc, itemalloc> *pHeap;
+            int iIndex;
+
+            const_iterator( Heap<item, cmpfunc, itemalloc> *pHeap,
+                    int iIndex ) :
+                pHeap( pHeap ), iIndex( iIndex )
+            {
+            }
+
+            void checkValid()
+            {
+                if( pHeap == NULL )
+                    throw Bu::ExceptionBase("Iterator not initialized.");
+                if( iIndex < 0 || iIndex >= pHeap->core->iFill )
+                    throw Bu::ExceptionBase("Iterator out of bounds.");
+            }
+
+        public:
+            const_iterator() :
+                pHeap( NULL ),
+                iIndex( -1 )
+            {
+            }
+            
+            const_iterator( const const_iterator &i ) :
+                pHeap( i.pHeap ),
+                iIndex( i.iIndex )
+            {
+            }
+            
+            const_iterator( const iterator &i ) :
+                pHeap( i.pHeap ),
+                iIndex( i.iIndex )
+            {
+            }
+
+            bool operator==( const const_iterator &oth ) const
+            {
+                return (oth.pHeap == pHeap) && (oth.iIndex == iIndex);
+            }
+
+            bool operator!=( const const_iterator &oth ) const
+            {
+                return (oth.pHeap != pHeap) || (oth.iIndex != iIndex);
+            }
+
+            const item &operator*()
+            {
+                pHeap->_hardCopy();
+
+                return pHeap->core->aItem[iIndex];
+            }
+
+            const item *operator->()
+            {
+                pHeap->_hardCopy();
+
+                return &(pHeap->core->aItem[iIndex]);
+            }
+
+            const_iterator &operator++()
+            {
+                checkValid();
+                iIndex++;
+                if( iIndex >= pHeap->core->iFill )
+                    iIndex = -1;
+
+                return *this;
+            }
+
+            const_iterator &operator--()
+            {
+                checkValid();
+                iIndex--;
+
+                return *this;
+            }
+            
+            const_iterator &operator++( int )
+            {
+                checkValid();
+                iIndex++;
+                if( iIndex >= pHeap->core->iFill )
+                    iIndex = -1;
+
+                return *this;
+            }
+
+            const_iterator &operator--( int )
+            {
+                checkValid();
+                iIndex--;
+
+                return *this;
+            }
+
+            const_iterator operator+( int iDelta )
+            {
+                checkValid();
+                const_iterator ret( *this );
+                ret.iIndex += iDelta;
+                if( ret.iIndex >= pHeap->iFill )
+                    ret.iIndex = -1;
+                return ret;
+            }
+
+            const_iterator operator-( int iDelta )
+            {
+                checkValid();
+                const_iterator ret( *this );
+                ret.iIndex -= iDelta;
+                if( ret.iIndex < 0 )
+                    ret.iIndex = -1;
+                return ret;
+            }
+
+            operator bool() const
+            {
+                return iIndex != -1;
+            }
+
+            bool isValid() const
+            {
+                return iIndex != -1;
+            }
+
+            const_iterator &operator=( const const_iterator &oth )
+            {
+                pHeap = oth.pHeap;
+                iIndex = oth.iIndex;
+            }
+
+            const_iterator &operator=( const iterator &oth )
+            {
+                pHeap = oth.pHeap;
+                iIndex = oth.iIndex;
+            }
+        };
+
+        iterator begin()
+        {
+            if( core->iFill == 0 )
+                return end();
+            return iterator( this, 0 );
+        }
+
+        const_iterator begin() const
+        {
+            if( core->iFill == 0 )
+                return end();
+            return const_iterator( this, 0 );
+        }
+
+        iterator end()
+        {
+            return iterator( this, -1 );
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator( this, -1 );
+        }
+
+
+    protected:
+        virtual Core *_copyCore( Core *src )
+        {
+            Core *pRet = _allocateCore();
+
+            pRet->iSize = src->iSize;
+            pRet->iFill = src->iFill;
+            pRet->cmp = src->cmp;
+            pRet->aItem = pRet->ia.allocate( pRet->iSize );
+            for( int j = 0; j < pRet->iFill; j++ )
+            {
+                pRet->ia.construct( &pRet->aItem[j], src->aItem[j] );
+            }
+
+            return pRet;
+        }
+    };
 };
 
 #endif
diff --git a/src/stable/hex.cpp b/src/stable/hex.cpp
index 3e6a22e..45679b5 100644
--- a/src/stable/hex.cpp
+++ b/src/stable/hex.cpp
@@ -8,11 +8,11 @@
 #include "bu/hex.h"
 
 Bu::Hex::Hex( Bu::Stream &rNext, bool bUpperCase, int iChunk ) :
-        Bu::Filter( rNext ),
-        iChunk( iChunk ),
-        iPos( 0 ),
-        iIn( 0 ),
-        sChrs(bUpperCase?"0123456789ABCDEF":"0123456789abcdef")
+    Bu::Filter( rNext ),
+    iChunk( iChunk ),
+    iPos( 0 ),
+    iIn( 0 ),
+    sChrs(bUpperCase?"0123456789ABCDEF":"0123456789abcdef")
 {
 }
 
@@ -22,48 +22,48 @@ Bu::Hex::~Hex()
 
 void Bu::Hex::start()
 {
-        iPos = iIn = 0;
+    iPos = iIn = 0;
 }
 
 Bu::size Bu::Hex::stop()
 {
-        return iPos;
+    return iPos;
 }
 
 Bu::size Bu::Hex::read( void *pBuf, Bu::size iBytes )
 {
-        Bu::size j;
-        uint8_t *puBuf = (uint8_t *)pBuf;
-        for( j = 0; j < iBytes; j++ )
-        {
-                for(; iIn < 2; iIn++ )
-                {
-                        if( rNext.read( &cIn[iIn], 1 ) == 0 )
-                                return j;
-                        if( cIn[iIn] == ' ' || cIn[iIn] == '\t' ||
-                                cIn[iIn] == '\n' || cIn[iIn] == '\r' )
-                                iIn--;
-                }
+    Bu::size j;
+    uint8_t *puBuf = (uint8_t *)pBuf;
+    for( j = 0; j < iBytes; j++ )
+    {
+        for(; iIn < 2; iIn++ )
+        {
+            if( rNext.read( &cIn[iIn], 1 ) == 0 )
+                return j;
+            if( cIn[iIn] == ' ' || cIn[iIn] == '\t' ||
+                cIn[iIn] == '\n' || cIn[iIn] == '\r' )
+                iIn--;
+        }
 #define chr2nibble( c ) ((c>='0'&&c<='9')?(c-'0'):((c|0x60)-'a'+10))
-                puBuf[j] = ((chr2nibble(cIn[0])<<4)|chr2nibble(cIn[1]));
-                iIn = 0;
-        }
-        return j;
+        puBuf[j] = ((chr2nibble(cIn[0])<<4)|chr2nibble(cIn[1]));
+        iIn = 0;
+    }
+    return j;
 }
 
 Bu::size Bu::Hex::write( const void *pBuf, Bu::size iBytes )
 {
-        char cOut[2];
-        uint8_t *puBuf = (uint8_t *)pBuf;
-        for( Bu::size j = 0; j < iBytes; j++ )
-        {
-                cOut[0] = sChrs[(puBuf[j]&0xf0)>>4];
-                cOut[1] = sChrs[(puBuf[j]&0x0f)];
-                if( iChunk > 0 && iPos%iChunk == 0 && iPos>0 )
-                        rNext.write(" ", 1 );
-                rNext.write( cOut, 2 );
-                iPos++;
-        }
-        return iBytes;
+    char cOut[2];
+    uint8_t *puBuf = (uint8_t *)pBuf;
+    for( Bu::size j = 0; j < iBytes; j++ )
+    {
+        cOut[0] = sChrs[(puBuf[j]&0xf0)>>4];
+        cOut[1] = sChrs[(puBuf[j]&0x0f)];
+        if( iChunk > 0 && iPos%iChunk == 0 && iPos>0 )
+            rNext.write(" ", 1 );
+        rNext.write( cOut, 2 );
+        iPos++;
+    }
+    return iBytes;
 }
 
diff --git a/src/stable/hex.h b/src/stable/hex.h
index a89e93d..c010173 100644
--- a/src/stable/hex.h
+++ b/src/stable/hex.h
@@ -12,46 +12,46 @@
 
 namespace Bu
 {
-        /**
-         * This very simple filter encodes to/decodes from hex encoded string data.
-         * The primary use of this filter is in debugging, use it with
-         * Bu::encodeStr to easily create hex dumps of string data, even other raw
-         * structures.
-         *
-         *@code
-         Bu::println("Hexdump: " + Bu::encodeStr<Bu::Hex>("Test data ;)") );
-         @endcode
-         * Or...
-         *@code
-         complex_struct data;
-         ...
-         Bu::println("Hexdump: " +
-                Bu::encodeStr<Bu::Hex>(
-                        Bu::String( &data, sizeof(data) )
-                        )
-                );
-         @endcode
-         **/
-        class Hex : public Bu::Filter
-        {
-        public:
-                Hex( Bu::Stream &rNext, bool bUpperCase=false, int iChunk=-1 );
-                virtual ~Hex();
+    /**
+     * This very simple filter encodes to/decodes from hex encoded string data.
+     * The primary use of this filter is in debugging, use it with
+     * Bu::encodeStr to easily create hex dumps of string data, even other raw
+     * structures.
+     *
+     *@code
+     Bu::println("Hexdump: " + Bu::encodeStr<Bu::Hex>("Test data ;)") );
+     @endcode
+     * Or...
+     *@code
+     complex_struct data;
+     ...
+     Bu::println("Hexdump: " +
+        Bu::encodeStr<Bu::Hex>(
+            Bu::String( &data, sizeof(data) )
+            )
+        );
+     @endcode
+     **/
+    class Hex : public Bu::Filter
+    {
+    public:
+        Hex( Bu::Stream &rNext, bool bUpperCase=false, int iChunk=-1 );
+        virtual ~Hex();
 
-                virtual void start();
-                virtual Bu::size stop();
+        virtual void start();
+        virtual Bu::size stop();
 
-                virtual Bu::size read( void *pBuf, Bu::size iBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size iBytes );
-                using Bu::Stream::write;
+        virtual Bu::size read( void *pBuf, Bu::size iBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size iBytes );
+        using Bu::Stream::write;
 
-        private:
-                int iChunk;
-                Bu::size iPos;
-                char cIn[2];
-                int iIn;
-                const char *sChrs;
-        };
+    private:
+        int iChunk;
+        Bu::size iPos;
+        char cIn[2];
+        int iIn;
+        const char *sChrs;
+    };
 };
 
 #endif
diff --git a/src/stable/list.h b/src/stable/list.h
index 4f9d4aa..b7fb1d1 100644
--- a/src/stable/list.h
+++ b/src/stable/list.h
@@ -16,1022 +16,1022 @@
 
 namespace Bu
 {
-        /** @cond DEVEL */
-        template<typename value>
-        struct ListLink
-        {
-                value *pValue;
-                ListLink *pNext;
-                ListLink *pPrev;
-        };
-
-        template<typename value, typename valuealloc, typename linkalloc>
-        class List;
-
-        template<typename value, typename valuealloc, typename linkalloc>
-        struct ListCore
-        {
-        friend class List<value, valuealloc, linkalloc>;
-        friend class SharedCore<
-                List<value, valuealloc, linkalloc>,
-                ListCore<value, valuealloc, linkalloc>
-                >;
-        private:
-                typedef struct ListLink<value> Link;
-                ListCore() :
-                        pFirst( NULL ),
-                        pLast( NULL ),
-                        nSize( 0 )
-                { }
-
-                virtual ~ListCore()
-                {
-                        clear();
-                }
-
-                Link *pFirst;
-                Link *pLast;
-                long nSize;
-                linkalloc la;
-                valuealloc va;
-                
-                /**
-                 * Append a value to the list.
-                 *@param v (const value_type &) The value to append.
-                 */
-                Link *append( const value &v )
-                {
-                        Link *pNew = la.allocate( 1 );
-                        pNew->pValue = va.allocate( 1 );
-                        va.construct( pNew->pValue, v );
-                        nSize++;
-                        if( pFirst == NULL )
-                        {
-                                // Empty list
-                                pFirst = pLast = pNew;
-                                pNew->pNext = pNew->pPrev = NULL;
-                        }
-                        else
-                        {
-                                pNew->pNext = NULL;
-                                pNew->pPrev = pLast;
-                                pLast->pNext = pNew;
-                                pLast = pNew;
-                        }
-                        return pNew;
-                }
-                
-                /**
-                 * Prepend a value to the list.
-                 *@param v (const value_type &) The value to prepend.
-                 */
-                Link *prepend( const value &v )
-                {
-                        Link *pNew = la.allocate( 1 );
-                        pNew->pValue = va.allocate( 1 );
-                        va.construct( pNew->pValue, v );
-                        nSize++;
-                        if( pFirst == NULL )
-                        {
-                                // Empty list
-                                pFirst = pLast = pNew;
-                                pNew->pNext = pNew->pPrev = NULL;
-                        }
-                        else
-                        {
-                                pNew->pNext = pFirst;
-                                pNew->pPrev = NULL;
-                                pFirst->pPrev = pNew;
-                                pFirst = pNew;
-                        }
-                        return pNew;
-                }
-                
-                void clear()
-                {
-                        Link *pCur = pFirst;
-                        for(;;)
-                        {
-                                if( pCur == NULL ) break;
-                                va.destroy( pCur->pValue );
-                                va.deallocate( pCur->pValue, 1 );
-                                Link *pTmp = pCur->pNext;
-                                la.destroy( pCur );
-                                la.deallocate( pCur, 1 );
-                                pCur = pTmp;
-                        }
-                        pFirst = pLast = NULL;
-                        nSize = 0;
-                }
-                
-                Link *insert( Link *pLink, const value &v )
-                {
-                        Link *pAfter = pLink;
-                        if( pAfter == NULL )
-                        {
-                                return append( v );
-                        }
-                        Link *pPrev = pAfter->pPrev;
-                        if( pPrev == NULL )
-                        {
-                                return prepend( v );
-                        }
-
-                        Link *pNew = la.allocate( 1 );
-                        pNew->pValue = va.allocate( 1 );
-                        va.construct( pNew->pValue, v );
-                        nSize++;
-                
-                        pNew->pNext = pAfter;
-                        pNew->pPrev = pPrev;
-                        pAfter->pPrev = pNew;
-                        pPrev->pNext = pNew;
-
-                        return pNew;
-                }
-
-                /**
-                 * Erase an item from the list.
-                 *@param i (iterator) The item to erase.
-                 */
-                void erase( Link *pLink )
-                {
-                        Link *pCur = pLink;
-                        if( pCur == NULL ) return;
-                        Link *pPrev = pCur->pPrev;
-                        if( pPrev == NULL )
-                        {
-                                va.destroy( pCur->pValue );
-                                va.deallocate( pCur->pValue, 1 );
-                                pFirst = pCur->pNext;
-                                la.destroy( pCur );
-                                la.deallocate( pCur, 1 );
-                                if( pFirst == NULL )
-                                        pLast = NULL;
-                                else
-                                        pFirst->pPrev = NULL;
-                                nSize--;
-                        }
-                        else
-                        {
-                                va.destroy( pCur->pValue );
-                                va.deallocate( pCur->pValue, 1 );
-                                Link *pTmp = pCur->pNext;
-                                la.destroy( pCur );
-                                la.deallocate( pCur, 1 );
-                                pPrev->pNext = pTmp;
-                                if( pTmp != NULL )
-                                        pTmp->pPrev = pPrev;
-                                else
-                                        pLast = pPrev;
-                                nSize--;
-                        }
-                }
-        };
-        /** @endcond */
-
-        /**
-         * Linked list template container.  This class is similar to the stl list
-         * class except for a few minor changes.  First, when const, all
-         * members are only accessable const.  Second, erasing a location does not
-         * invalidate the iterator used, it simply points to the next valid
-         * location, or end() if there are no more.  Other iterators pointing to
-         * the deleted record will, of course, no longer be valid.
-         *
-         *@param value (typename) The type of data to store in your list
-         *@param valuealloc (typename) Memory Allocator for your value type
-         *@param linkalloc (typename) Memory Allocator for the list links.
-         *@extends SharedCore
-         *@ingroup Containers
-         */
-        template<typename value, typename valuealloc=std::allocator<value>,
-                typename linkalloc=std::allocator<struct ListLink<value> > >
-        class List /** @cond */ : public SharedCore<
-                                 List<value, valuealloc, linkalloc>,
-                                 ListCore<value, valuealloc, linkalloc>
-                                 > /** @endcond */
-        {
-        private:
-                typedef struct ListLink<value> Link;
-                typedef class List<value, valuealloc, linkalloc> MyType;
-                typedef struct ListCore<value, valuealloc, linkalloc> Core;
-
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_allocateCore;
-
-        public:
-                struct const_iterator;
-                struct iterator;
-
-                List()
-                {
-                }
-
-                List( const MyType &src ) :
-                        SharedCore<MyType, Core >( src )
-                {
-                }
-                
-                List( const value &v )
-                {
-                        append( v );
-                }
-
-                ~List()
-                {
-                }
-
-                MyType &operator+=( const value &v )
-                {
-                        _hardCopy();
-                        append( v );
-                        return *this;
-                }
-
-                MyType &operator+=( const MyType &src )
-                {
-                        _hardCopy();
-                        append( src );
-                        return *this;
-                }
-                
-                MyType operator+( const MyType &src )
-                {
-                        MyType lNew( *this );
-                        lNew += src;
-                        return lNew;
-                }
-
-                bool operator==( const MyType &rhs ) const
-                {
-                        if( getSize() != rhs.getSize() )
-                                return false;
-
-                        for( typename MyType::const_iterator a = begin(), b = rhs.begin();
-                                 a; a++, b++ )
-                        {
-                                if( *a != *b )
-                                        return false;
-                        }
-
-                        return true;
-                }
-
-                bool operator!=( const MyType &rhs ) const
-                {
-                        return !(*this == rhs);
-                }
-
-                /**
-                 * Clear the data from the list.
-                 */
-                void clear()
-                {
-                        _hardCopy();
-                        core->clear();
-                }
-
-                MyType &enqueue( const value &v )
-                {
-                        _hardCopy();
-                        append( v );
-
-                        return *this;
-                }
-
-                value dequeue()
-                {
-                        // _hardCopy();  erase will call this for me
-                        value v = *core->pFirst->pValue;
-
-                        erase( begin() );
-
-                        return v;
-                }
-
-                MyType &push( const value &v )
-                {
-                        _hardCopy();
-                        prepend( v );
-
-                        return *this;
-                }
-
-                MyType &pop()
-                {
-                        _hardCopy();
-                        erase( begin() );
-
-                        return *this;
-                }
-
-                value peekPop()
-                {
-                        value v = first();
-                        pop();
-                        return v;
-                }
-
-                value &peek()
-                {
-                        return first();
-                }
-
-                /**
-                 * Append a value to the list.
-                 *@param v (const value_type &) The value to append.
-                 */
-                MyType &append( const value &v )
-                {
-                        _hardCopy();
-                        core->append( v );
-
-                        return *this;
-                }
-
-                MyType &append( const MyType &rSrc )
-                {
-                        _hardCopy();
-                        for( typename MyType::const_iterator i = rSrc.begin();
-                                 i != rSrc.end(); i++ )
-                        {
-                                core->append( *i );
-                        }
-
-                        return *this;
-                }
-
-                /**
-                 * Prepend a value to the list.
-                 *@param v (const value_type &) The value to prepend.
-                 */
-                MyType &prepend( const value &v )
-                {
-                        _hardCopy();
-                        core->prepend( v );
-
-                        return *this;
-                }
-
-                /**
-                 * Prepend another list to the front of this one.  This will prepend
-                 * the rSrc list in reverse order...I may fix that later.
-                 */
-                MyType &prepend( const MyType &rSrc )
-                {
-                        _hardCopy();
-                        for( typename MyType::const_iterator i = rSrc.begin();
-                                 i != rSrc.end(); i++ )
-                        {
-                                core->prepend( *i );
-                        }
-
-                        return *this;
-                }
-
-                MyType &insert( MyType::iterator &i, const value &v )
-                {
-                        _hardCopy();
-
-                        core->insert( i.pLink, v );
-
-                        return *this;
-                }
-
-                template<typename cmptype>
-                void sort( cmptype cmp )
-                {
-                        Heap<value, cmptype, valuealloc> hSort( cmp, getSize() );
-                        for( typename MyType::iterator i = begin(); i; i++ )
-                        {
-                                hSort.enqueue( *i );
-                        }
-                        clear();
-                        while( !hSort.isEmpty() )
-                        {
-                                append( hSort.dequeue() );
-                        }
-                }
-
-                void sort()
-                {
-                        sort<__basicLTCmp<value> >();
-                }
-
-                template<typename cmptype>
-                void sort()
-                {
-                        Heap<value, cmptype, valuealloc> hSort( getSize() );
-                        for( typename MyType::iterator i = begin(); i; i++ )
-                        {
-                                hSort.enqueue( *i );
-                        }
-                        clear();
-                        while( !hSort.isEmpty() )
-                        {
-                                append( hSort.dequeue() );
-                        }
-                }
-
-                /**
-                 * Insert a new item in sort order by searching for the first item that
-                 * is larger and inserting this before it, or at the end if none are
-                 * larger.  If this is the only function used to insert data in the
-                 * List all items will be sorted.  To use this, the value type must
-                 * support the > operator.
-                 */
-                template<typename cmptype>
-                iterator insertSorted( cmptype cmp, const value &v )
-                {
-                        _hardCopy();
-                        if( core->pFirst == NULL )
-                        {
-                                // Empty list
-                                return iterator( core->append( v ) );
-                        }
-                        else
-                        {
-                                Link *pCur = core->pFirst;
-                                for(;;)
-                                {
-                                        if( cmp( v, *(pCur->pValue)) )
-                                        {
-                                                return iterator( core->insert( pCur, v ) );
-                                        }
-                                        pCur = pCur->pNext;
-                                        if( pCur == NULL )
-                                        {
-                                                return iterator( core->append( v ) );
-                                        }
-                                }
-                        }
-                }
-                
-                iterator insertSorted( const value &v )
-                {
-                        return insertSorted<__basicLTCmp<value> >( v );
-                }
-
-                template<typename cmptype>
-                iterator insertSorted( const value &v )
-                {
-                        cmptype cmp;
-                        return insertSorted( cmp, v );
-                }
-
-                /**
-                 * An iterator to iterate through your list.
-                 */
-                typedef struct iterator
-                {
-                        friend struct const_iterator;
-                        friend class List<value, valuealloc, linkalloc>;
-                private:
-                        Link *pLink;
-
-                        iterator( Link *pLink ) :
-                                pLink( pLink )
-                        {
-                        }
-
-                public:
-                        iterator() :
-                                pLink( NULL )
-                        {
-                        }
-
-                        iterator( const iterator &i ) :
-                                pLink( i.pLink )
-                        {
-                        }
-
-                        /**
-                         * Equals comparison operator.
-                         *@param oth (const iterator &) The iterator to compare to.
-                         *@returns (bool) Are they equal?
-                         */
-                        bool operator==( const iterator &oth ) const
-                        {
-                                return ( pLink == oth.pLink );
-                        }
-
-                        /**
-                         * Equals comparison operator.
-                         *@param pOth (const Link *) The link to compare to.
-                         *@returns (bool) Are they equal?
-                         */
-                        bool operator==( const Link *pOth ) const
-                        {
-                                return ( pLink == pOth );
-                        }
-
-                        /**
-                         * Not equals comparison operator.
-                         *@param oth (const iterator &) The iterator to compare to.
-                         *@returns (bool) Are they not equal?
-                         */
-                        bool operator!=( const iterator &oth ) const
-                        {
-                                return ( pLink != oth.pLink );
-                        }
-
-                        /**
-                         * Not equals comparison operator.
-                         *@param pOth (const Link *) The link to compare to.
-                         *@returns (bool) Are they not equal?
-                         */
-                        bool operator!=( const Link *pOth ) const
-                        {
-                                return ( pLink != pOth );
-                        }
-
-                        /**
-                         * Dereference operator.
-                         *@returns (value_type &) The value.
-                         */
-                        value &operator*()
-                        {
-                                return *(pLink->pValue);
-                        }
-
-                        /**
-                         * Pointer access operator.
-                         *@returns (value_type *) A pointer to the value.
-                         */
-                        value *operator->()
-                        {
-                                return pLink->pValue;
-                        }
-
-                        iterator &operator++()
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past end of list.");
-                                pLink = pLink->pNext;
-                                return *this;
-                        }
-
-                        iterator &operator--()
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past begining of list.");
-                                pLink = pLink->pPrev;
-                                return *this;
-                        }
-                        
-                        iterator &operator++( int )
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past end of list.");
-                                pLink = pLink->pNext;
-                                return *this;
-                        }
-
-                        iterator &operator--( int )
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past begining of list.");
-                                pLink = pLink->pPrev;
-                                return *this;
-                        }
-
-                        iterator operator+( int iDelta )
-                        {
-                                iterator ret( *this );
-                                for( int j = 0; j < iDelta; j++ )
-                                {
-                                        if( ret.pLink == NULL )
-                                                throw Bu::ExceptionBase(
-                                                        "Attempt to iterate past begining of list.");
-                                        ret.pLink = ret.pLink->pNext;
-                                }
-                                return ret;
-                        }
-
-                        iterator operator-( int iDelta )
-                        {
-                                iterator ret( *this );
-                                for( int j = 0; j < iDelta; j++ )
-                                {
-                                        if( ret.pLink == NULL )
-                                                throw Bu::ExceptionBase(
-                                                        "Attempt to iterate past begining of list.");
-                                        ret.pLink = ret.pLink->pPrev;
-                                }
-                                return ret;
-                        }
-
-                        operator bool()
-                        {
-                                return pLink != NULL;
-                        }
-
-                        bool isValid()
-                        {
-                                return pLink != NULL;
-                        }
-
-                        /**
-                         * Assignment operator.
-                         *@param oth (const iterator &) The other iterator to set this
-                         *              one to.
-                         */
-                        iterator &operator=( const iterator &oth )
-                        {
-                                pLink = oth.pLink;
-                                return *this;
-                        }
-                } iterator;
-                
-                /**
-                 *@see iterator
-                 */
-                typedef struct const_iterator
-                {
-                        friend class List<value, valuealloc, linkalloc>;
-                private:
-                        Link *pLink;
-
-                        const_iterator( Link *pLink ) :
-                                pLink( pLink )
-                        {
-                        }
-
-                public:
-                        const_iterator() :
-                                pLink( NULL )
-                        {
-                        }
-
-                        const_iterator( const iterator &i ) :
-                                pLink( i.pLink )
-                        {
-                        }
-
-                        bool operator==( const const_iterator &oth ) const
-                        {
-                                return ( pLink == oth.pLink );
-                        }
-
-                        bool operator==( const Link *pOth ) const
-                        {
-                                return ( pLink == pOth );
-                        }
-
-                        bool operator!=( const const_iterator &oth ) const
-                        {
-                                return ( pLink != oth.pLink );
-                        }
-
-                        bool operator!=( const Link *pOth ) const
-                        {
-                                return ( pLink != pOth );
-                        }
-
-                        const value &operator*()
-                        {
-                                return *(pLink->pValue);
-                        }
-
-                        const value *operator->()
-                        {
-                                return pLink->pValue;
-                        }
-
-                        const_iterator &operator++()
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past end of list.");
-                                pLink = pLink->pNext;
-                                return *this;
-                        }
-
-                        const_iterator &operator--()
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past begining of list.");
-                                pLink = pLink->pPrev;
-                                return *this;
-                        }
-                        
-                        const_iterator &operator++( int )
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past end of list.");
-                                pLink = pLink->pNext;
-                                return *this;
-                        }
-
-                        const_iterator &operator--( int )
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past begining of list.");
-                                pLink = pLink->pPrev;
-                                return *this;
-                        }
-
-                        const_iterator operator+( int iDelta )
-                        {
-                                const_iterator ret( *this );
-                                for( int j = 0; j < iDelta; j++ )
-                                {
-                                        if( ret.pLink == NULL )
-                                                throw Bu::ExceptionBase(
-                                                        "Attempt to iterate past begining of list.");
-                                        ret.pLink = ret.pLink->pNext;
-                                }
-                                return ret;
-                        }
-
-                        const_iterator operator-( int iDelta )
-                        {
-                                const_iterator ret( *this );
-                                for( int j = 0; j < iDelta; j++ )
-                                {
-                                        if( ret.pLink == NULL )
-                                                throw Bu::ExceptionBase(
-                                                        "Attempt to iterate past begining of list.");
-                                        ret.pLink = ret.pLink->pPrev;
-                                }
-                                return ret;
-                        }
-
-                        const_iterator &operator=( const iterator &oth )
-                        {
-                                pLink = oth.pLink;
-                                return *this;
-                        }
-
-                        const_iterator &operator=( const const_iterator &oth )
-                        {
-                                pLink = oth.pLink;
-                                return *this;
-                        }
-
-                        operator bool()
-                        {
-                                return pLink != NULL;
-                        }
-
-                        bool isValid()
-                        {
-                                return pLink != NULL;
-                        }
-                } const_iterator;
-
-                /**
-                 * Get an iterator pointing to the first item in the list.
-                 *@returns (iterator)
-                 */
-                iterator begin()
-                {
-                        _hardCopy();
-                        return iterator( core->pFirst );
-                }
-
-                /**
-                 * Get a const iterator pointing to the first item in the list.
-                 *@returns (const const_iterator)
-                 */
-                const_iterator begin() const
-                {
-                        return const_iterator( core->pFirst );
-                }
-
-                /**
-                 * Get an iterator pointing to a place just past the last item in
-                 *              the list.
-                 *@returns (const Link *)
-                 */
-                const iterator end()
-                {
-                        return iterator( NULL );
-                }
-
-                /**
-                 * Get an iterator pointing to a place just past the last item in
-                 *              the list.
-                 *@returns (const Link *)
-                 */
-                const const_iterator end() const
-                {
-                        return const_iterator( NULL );
-                }
-
-                /**
-                 * Erase an item from the list.
-                 *@param i (iterator) The item to erase.
-                 */
-                MyType &erase( iterator i )
-                {
-                        _hardCopy();
-                        core->erase( i.pLink );
-
-                        return *this;
-                }
-
-                /**
-                 * Erase an item from the list.
-                 *@param i (iterator) The item to erase.
-                 */
-                MyType &erase( const_iterator i )
-                {
-                        _hardCopy();
-                        core->erase( i.pLink );
-
-                        return *this;
-                }
-
-                /**
-                 * Erase an item from the list if you already know the item.
-                 *@param v The item to find and erase.
-                 */
-                MyType &erase( const value &v )
-                {
-                        for( const_iterator i = begin(); i != end(); i++ )
-                        {
-                                if( (*i) == v )
-                                {
-                                        erase( i );
-                                        return *this;
-                                }
-                        }
-
-                        return *this;
-                }
-                
-                /**
-                 * Erases the first item in the list, identical to pop, but better for
-                 * lists that aren't built as stacks, since you know where it will be
-                 * erasing from.
-                 */
-                MyType &eraseFirst()
-                {
-                        _hardCopy();
-                        erase( begin() );
-
-                        return *this;
-                }
-                
-                /**
-                 * Erases the last item in the list.
-                 */
-                MyType &eraseLast()
-                {
-                        _hardCopy();
-                        core->erase( core->pLast ); 
-
-                        return *this;
-                }
-
-                iterator find( const value &v )
-                {
-                        for( iterator i = begin(); i; i++ )
-                        {
-                                if( (*i) == v )
-                                        return i;
-                        }
-
-                        return end();
-                }
-
-                const_iterator find( const value &v ) const
-                {
-                        for( const_iterator i = begin(); i; i++ )
-                        {
-                                if( (*i) == v )
-                                        return i;
-                        }
-
-                        return end();
-                }
-
-                /**
-                 * Get the current size of the list.
-                 *@returns (int) The current size of the list.
-                 */
-                long getSize() const
-                {
-                        return core->nSize;
-                }
-
-                /**
-                 * Get the first item in the list.
-                 *@returns (value_type &) The first item in the list.
-                 */
-                value &first()
-                {
-                        if( core->pFirst->pValue == NULL )
-                                throw Bu::ExceptionBase("Attempt to read first element from empty list.");
-                        _hardCopy();
-                        return *core->pFirst->pValue;
-                }
-                
-                /**
-                 * Get the first item in the list.
-                 *@returns (const value_type &) The first item in the list.
-                 */
-                const value &first() const
-                {
-                        if( core->pFirst->pValue == NULL )
-                                throw Bu::ExceptionBase("Attempt to read first element from empty list.");
-                        return *core->pFirst->pValue;
-                }
-                
-                /**
-                 * Get the last item in the list.
-                 *@returns (value_type &) The last item in the list.
-                 */
-                value &last()
-                {
-                        _hardCopy();
-                        return *core->pLast->pValue;
-                }
-                
-                /**
-                 * Get the last item in the list.
-                 *@returns (const value_type &) The last item in the list.
-                 */
-                const value &last() const
-                {
-                        return *core->pLast->pValue;
-                }
-
-                bool isEmpty() const
-                {
-                        return (core->nSize == 0);
-                }
-        
-        protected:
-                virtual Core *_copyCore( Core *src )
-                {
-                        Core *pRet = _allocateCore();
-                        for( Link *pCur = src->pFirst; pCur; pCur = pCur->pNext )
-                        {
-                                pRet->append( *pCur->pValue );
-                        }
-                        return pRet;
-                }
-
-        private:
-        };
-
-        class Formatter;
-        Formatter &operator<<( Formatter &rOut, char *sStr );
-        Formatter &operator<<( Formatter &rOut, signed char c );
-        template<typename a, typename b, typename c>
-        Formatter &operator<<( Formatter &f, const Bu::List<a,b,c> &l )
-        {
-                f << '[';
-                for( typename Bu::List<a,b,c>::const_iterator i = l.begin(); i; i++ )
-                {
-                        if( i != l.begin() )
-                                f << ", ";
-                        f << *i;
-                }
-                f << ']';
-
-                return f;
-        }
-
-        template<typename value, typename a, typename b>
-        ArchiveBase &operator<<( ArchiveBase &ar, const List<value,a,b> &h )
-        {
-                ar << h.getSize();
-                for( typename List<value>::const_iterator i = h.begin(); i != h.end(); i++ )
-                {
-                        ar << (*i);
-                }
-
-                return ar;
-        }
-
-        template<typename value, typename a, typename b>
-        ArchiveBase &operator>>( ArchiveBase &ar, List<value,a,b> &h )
-        {
-                h.clear();
-                long nSize;
-                ar >> nSize;
-
-                for( long j = 0; j < nSize; j++ )
-                {
-                        value v;
-                        ar >> v;
-                        h.append( v );
-                }
-
-                return ar;
-        }
+    /** @cond DEVEL */
+    template<typename value>
+    struct ListLink
+    {
+        value *pValue;
+        ListLink *pNext;
+        ListLink *pPrev;
+    };
+
+    template<typename value, typename valuealloc, typename linkalloc>
+    class List;
+
+    template<typename value, typename valuealloc, typename linkalloc>
+    struct ListCore
+    {
+    friend class List<value, valuealloc, linkalloc>;
+    friend class SharedCore<
+        List<value, valuealloc, linkalloc>,
+        ListCore<value, valuealloc, linkalloc>
+        >;
+    private:
+        typedef struct ListLink<value> Link;
+        ListCore() :
+            pFirst( NULL ),
+            pLast( NULL ),
+            nSize( 0 )
+        { }
+
+        virtual ~ListCore()
+        {
+            clear();
+        }
+
+        Link *pFirst;
+        Link *pLast;
+        long nSize;
+        linkalloc la;
+        valuealloc va;
+        
+        /**
+         * Append a value to the list.
+         *@param v (const value_type &) The value to append.
+         */
+        Link *append( const value &v )
+        {
+            Link *pNew = la.allocate( 1 );
+            pNew->pValue = va.allocate( 1 );
+            va.construct( pNew->pValue, v );
+            nSize++;
+            if( pFirst == NULL )
+            {
+                // Empty list
+                pFirst = pLast = pNew;
+                pNew->pNext = pNew->pPrev = NULL;
+            }
+            else
+            {
+                pNew->pNext = NULL;
+                pNew->pPrev = pLast;
+                pLast->pNext = pNew;
+                pLast = pNew;
+            }
+            return pNew;
+        }
+        
+        /**
+         * Prepend a value to the list.
+         *@param v (const value_type &) The value to prepend.
+         */
+        Link *prepend( const value &v )
+        {
+            Link *pNew = la.allocate( 1 );
+            pNew->pValue = va.allocate( 1 );
+            va.construct( pNew->pValue, v );
+            nSize++;
+            if( pFirst == NULL )
+            {
+                // Empty list
+                pFirst = pLast = pNew;
+                pNew->pNext = pNew->pPrev = NULL;
+            }
+            else
+            {
+                pNew->pNext = pFirst;
+                pNew->pPrev = NULL;
+                pFirst->pPrev = pNew;
+                pFirst = pNew;
+            }
+            return pNew;
+        }
+        
+        void clear()
+        {
+            Link *pCur = pFirst;
+            for(;;)
+            {
+                if( pCur == NULL ) break;
+                va.destroy( pCur->pValue );
+                va.deallocate( pCur->pValue, 1 );
+                Link *pTmp = pCur->pNext;
+                la.destroy( pCur );
+                la.deallocate( pCur, 1 );
+                pCur = pTmp;
+            }
+            pFirst = pLast = NULL;
+            nSize = 0;
+        }
+        
+        Link *insert( Link *pLink, const value &v )
+        {
+            Link *pAfter = pLink;
+            if( pAfter == NULL )
+            {
+                return append( v );
+            }
+            Link *pPrev = pAfter->pPrev;
+            if( pPrev == NULL )
+            {
+                return prepend( v );
+            }
+
+            Link *pNew = la.allocate( 1 );
+            pNew->pValue = va.allocate( 1 );
+            va.construct( pNew->pValue, v );
+            nSize++;
+        
+            pNew->pNext = pAfter;
+            pNew->pPrev = pPrev;
+            pAfter->pPrev = pNew;
+            pPrev->pNext = pNew;
+
+            return pNew;
+        }
+
+        /**
+         * Erase an item from the list.
+         *@param i (iterator) The item to erase.
+         */
+        void erase( Link *pLink )
+        {
+            Link *pCur = pLink;
+            if( pCur == NULL ) return;
+            Link *pPrev = pCur->pPrev;
+            if( pPrev == NULL )
+            {
+                va.destroy( pCur->pValue );
+                va.deallocate( pCur->pValue, 1 );
+                pFirst = pCur->pNext;
+                la.destroy( pCur );
+                la.deallocate( pCur, 1 );
+                if( pFirst == NULL )
+                    pLast = NULL;
+                else
+                    pFirst->pPrev = NULL;
+                nSize--;
+            }
+            else
+            {
+                va.destroy( pCur->pValue );
+                va.deallocate( pCur->pValue, 1 );
+                Link *pTmp = pCur->pNext;
+                la.destroy( pCur );
+                la.deallocate( pCur, 1 );
+                pPrev->pNext = pTmp;
+                if( pTmp != NULL )
+                    pTmp->pPrev = pPrev;
+                else
+                    pLast = pPrev;
+                nSize--;
+            }
+        }
+    };
+    /** @endcond */
+
+    /**
+     * Linked list template container.  This class is similar to the stl list
+     * class except for a few minor changes.  First, when const, all
+     * members are only accessable const.  Second, erasing a location does not
+     * invalidate the iterator used, it simply points to the next valid
+     * location, or end() if there are no more.  Other iterators pointing to
+     * the deleted record will, of course, no longer be valid.
+     *
+     *@param value (typename) The type of data to store in your list
+     *@param valuealloc (typename) Memory Allocator for your value type
+     *@param linkalloc (typename) Memory Allocator for the list links.
+     *@extends SharedCore
+     *@ingroup Containers
+     */
+    template<typename value, typename valuealloc=std::allocator<value>,
+        typename linkalloc=std::allocator<struct ListLink<value> > >
+    class List /** @cond */ : public SharedCore<
+                 List<value, valuealloc, linkalloc>,
+                 ListCore<value, valuealloc, linkalloc>
+                 > /** @endcond */
+    {
+    private:
+        typedef struct ListLink<value> Link;
+        typedef class List<value, valuealloc, linkalloc> MyType;
+        typedef struct ListCore<value, valuealloc, linkalloc> Core;
+
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_allocateCore;
+
+    public:
+        struct const_iterator;
+        struct iterator;
+
+        List()
+        {
+        }
+
+        List( const MyType &src ) :
+            SharedCore<MyType, Core >( src )
+        {
+        }
+        
+        List( const value &v )
+        {
+            append( v );
+        }
+
+        ~List()
+        {
+        }
+
+        MyType &operator+=( const value &v )
+        {
+            _hardCopy();
+            append( v );
+            return *this;
+        }
+
+        MyType &operator+=( const MyType &src )
+        {
+            _hardCopy();
+            append( src );
+            return *this;
+        }
+        
+        MyType operator+( const MyType &src )
+        {
+            MyType lNew( *this );
+            lNew += src;
+            return lNew;
+        }
+
+        bool operator==( const MyType &rhs ) const
+        {
+            if( getSize() != rhs.getSize() )
+                return false;
+
+            for( typename MyType::const_iterator a = begin(), b = rhs.begin();
+                 a; a++, b++ )
+            {
+                if( *a != *b )
+                    return false;
+            }
+
+            return true;
+        }
+
+        bool operator!=( const MyType &rhs ) const
+        {
+            return !(*this == rhs);
+        }
+
+        /**
+         * Clear the data from the list.
+         */
+        void clear()
+        {
+            _hardCopy();
+            core->clear();
+        }
+
+        MyType &enqueue( const value &v )
+        {
+            _hardCopy();
+            append( v );
+
+            return *this;
+        }
+
+        value dequeue()
+        {
+            // _hardCopy();  erase will call this for me
+            value v = *core->pFirst->pValue;
+
+            erase( begin() );
+
+            return v;
+        }
+
+        MyType &push( const value &v )
+        {
+            _hardCopy();
+            prepend( v );
+
+            return *this;
+        }
+
+        MyType &pop()
+        {
+            _hardCopy();
+            erase( begin() );
+
+            return *this;
+        }
+
+        value peekPop()
+        {
+            value v = first();
+            pop();
+            return v;
+        }
+
+        value &peek()
+        {
+            return first();
+        }
+
+        /**
+         * Append a value to the list.
+         *@param v (const value_type &) The value to append.
+         */
+        MyType &append( const value &v )
+        {
+            _hardCopy();
+            core->append( v );
+
+            return *this;
+        }
+
+        MyType &append( const MyType &rSrc )
+        {
+            _hardCopy();
+            for( typename MyType::const_iterator i = rSrc.begin();
+                 i != rSrc.end(); i++ )
+            {
+                core->append( *i );
+            }
+
+            return *this;
+        }
+
+        /**
+         * Prepend a value to the list.
+         *@param v (const value_type &) The value to prepend.
+         */
+        MyType &prepend( const value &v )
+        {
+            _hardCopy();
+            core->prepend( v );
+
+            return *this;
+        }
+
+        /**
+         * Prepend another list to the front of this one.  This will prepend
+         * the rSrc list in reverse order...I may fix that later.
+         */
+        MyType &prepend( const MyType &rSrc )
+        {
+            _hardCopy();
+            for( typename MyType::const_iterator i = rSrc.begin();
+                 i != rSrc.end(); i++ )
+            {
+                core->prepend( *i );
+            }
+
+            return *this;
+        }
+
+        MyType &insert( MyType::iterator &i, const value &v )
+        {
+            _hardCopy();
+
+            core->insert( i.pLink, v );
+
+            return *this;
+        }
+
+        template<typename cmptype>
+        void sort( cmptype cmp )
+        {
+            Heap<value, cmptype, valuealloc> hSort( cmp, getSize() );
+            for( typename MyType::iterator i = begin(); i; i++ )
+            {
+                hSort.enqueue( *i );
+            }
+            clear();
+            while( !hSort.isEmpty() )
+            {
+                append( hSort.dequeue() );
+            }
+        }
+
+        void sort()
+        {
+            sort<__basicLTCmp<value> >();
+        }
+
+        template<typename cmptype>
+        void sort()
+        {
+            Heap<value, cmptype, valuealloc> hSort( getSize() );
+            for( typename MyType::iterator i = begin(); i; i++ )
+            {
+                hSort.enqueue( *i );
+            }
+            clear();
+            while( !hSort.isEmpty() )
+            {
+                append( hSort.dequeue() );
+            }
+        }
+
+        /**
+         * Insert a new item in sort order by searching for the first item that
+         * is larger and inserting this before it, or at the end if none are
+         * larger.  If this is the only function used to insert data in the
+         * List all items will be sorted.  To use this, the value type must
+         * support the > operator.
+         */
+        template<typename cmptype>
+        iterator insertSorted( cmptype cmp, const value &v )
+        {
+            _hardCopy();
+            if( core->pFirst == NULL )
+            {
+                // Empty list
+                return iterator( core->append( v ) );
+            }
+            else
+            {
+                Link *pCur = core->pFirst;
+                for(;;)
+                {
+                    if( cmp( v, *(pCur->pValue)) )
+                    {
+                        return iterator( core->insert( pCur, v ) );
+                    }
+                    pCur = pCur->pNext;
+                    if( pCur == NULL )
+                    {
+                        return iterator( core->append( v ) );
+                    }
+                }
+            }
+        }
+        
+        iterator insertSorted( const value &v )
+        {
+            return insertSorted<__basicLTCmp<value> >( v );
+        }
+
+        template<typename cmptype>
+        iterator insertSorted( const value &v )
+        {
+            cmptype cmp;
+            return insertSorted( cmp, v );
+        }
+
+        /**
+         * An iterator to iterate through your list.
+         */
+        typedef struct iterator
+        {
+            friend struct const_iterator;
+            friend class List<value, valuealloc, linkalloc>;
+        private:
+            Link *pLink;
+
+            iterator( Link *pLink ) :
+                pLink( pLink )
+            {
+            }
+
+        public:
+            iterator() :
+                pLink( NULL )
+            {
+            }
+
+            iterator( const iterator &i ) :
+                pLink( i.pLink )
+            {
+            }
+
+            /**
+             * Equals comparison operator.
+             *@param oth (const iterator &) The iterator to compare to.
+             *@returns (bool) Are they equal?
+             */
+            bool operator==( const iterator &oth ) const
+            {
+                return ( pLink == oth.pLink );
+            }
+
+            /**
+             * Equals comparison operator.
+             *@param pOth (const Link *) The link to compare to.
+             *@returns (bool) Are they equal?
+             */
+            bool operator==( const Link *pOth ) const
+            {
+                return ( pLink == pOth );
+            }
+
+            /**
+             * Not equals comparison operator.
+             *@param oth (const iterator &) The iterator to compare to.
+             *@returns (bool) Are they not equal?
+             */
+            bool operator!=( const iterator &oth ) const
+            {
+                return ( pLink != oth.pLink );
+            }
+
+            /**
+             * Not equals comparison operator.
+             *@param pOth (const Link *) The link to compare to.
+             *@returns (bool) Are they not equal?
+             */
+            bool operator!=( const Link *pOth ) const
+            {
+                return ( pLink != pOth );
+            }
+
+            /**
+             * Dereference operator.
+             *@returns (value_type &) The value.
+             */
+            value &operator*()
+            {
+                return *(pLink->pValue);
+            }
+
+            /**
+             * Pointer access operator.
+             *@returns (value_type *) A pointer to the value.
+             */
+            value *operator->()
+            {
+                return pLink->pValue;
+            }
+
+            iterator &operator++()
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past end of list.");
+                pLink = pLink->pNext;
+                return *this;
+            }
+
+            iterator &operator--()
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past begining of list.");
+                pLink = pLink->pPrev;
+                return *this;
+            }
+            
+            iterator &operator++( int )
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past end of list.");
+                pLink = pLink->pNext;
+                return *this;
+            }
+
+            iterator &operator--( int )
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past begining of list.");
+                pLink = pLink->pPrev;
+                return *this;
+            }
+
+            iterator operator+( int iDelta )
+            {
+                iterator ret( *this );
+                for( int j = 0; j < iDelta; j++ )
+                {
+                    if( ret.pLink == NULL )
+                        throw Bu::ExceptionBase(
+                            "Attempt to iterate past begining of list.");
+                    ret.pLink = ret.pLink->pNext;
+                }
+                return ret;
+            }
+
+            iterator operator-( int iDelta )
+            {
+                iterator ret( *this );
+                for( int j = 0; j < iDelta; j++ )
+                {
+                    if( ret.pLink == NULL )
+                        throw Bu::ExceptionBase(
+                            "Attempt to iterate past begining of list.");
+                    ret.pLink = ret.pLink->pPrev;
+                }
+                return ret;
+            }
+
+            operator bool()
+            {
+                return pLink != NULL;
+            }
+
+            bool isValid()
+            {
+                return pLink != NULL;
+            }
+
+            /**
+             * Assignment operator.
+             *@param oth (const iterator &) The other iterator to set this
+             *      one to.
+             */
+            iterator &operator=( const iterator &oth )
+            {
+                pLink = oth.pLink;
+                return *this;
+            }
+        } iterator;
+        
+        /**
+         *@see iterator
+         */
+        typedef struct const_iterator
+        {
+            friend class List<value, valuealloc, linkalloc>;
+        private:
+            Link *pLink;
+
+            const_iterator( Link *pLink ) :
+                pLink( pLink )
+            {
+            }
+
+        public:
+            const_iterator() :
+                pLink( NULL )
+            {
+            }
+
+            const_iterator( const iterator &i ) :
+                pLink( i.pLink )
+            {
+            }
+
+            bool operator==( const const_iterator &oth ) const
+            {
+                return ( pLink == oth.pLink );
+            }
+
+            bool operator==( const Link *pOth ) const
+            {
+                return ( pLink == pOth );
+            }
+
+            bool operator!=( const const_iterator &oth ) const
+            {
+                return ( pLink != oth.pLink );
+            }
+
+            bool operator!=( const Link *pOth ) const
+            {
+                return ( pLink != pOth );
+            }
+
+            const value &operator*()
+            {
+                return *(pLink->pValue);
+            }
+
+            const value *operator->()
+            {
+                return pLink->pValue;
+            }
+
+            const_iterator &operator++()
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past end of list.");
+                pLink = pLink->pNext;
+                return *this;
+            }
+
+            const_iterator &operator--()
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past begining of list.");
+                pLink = pLink->pPrev;
+                return *this;
+            }
+            
+            const_iterator &operator++( int )
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past end of list.");
+                pLink = pLink->pNext;
+                return *this;
+            }
+
+            const_iterator &operator--( int )
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past begining of list.");
+                pLink = pLink->pPrev;
+                return *this;
+            }
+
+            const_iterator operator+( int iDelta )
+            {
+                const_iterator ret( *this );
+                for( int j = 0; j < iDelta; j++ )
+                {
+                    if( ret.pLink == NULL )
+                        throw Bu::ExceptionBase(
+                            "Attempt to iterate past begining of list.");
+                    ret.pLink = ret.pLink->pNext;
+                }
+                return ret;
+            }
+
+            const_iterator operator-( int iDelta )
+            {
+                const_iterator ret( *this );
+                for( int j = 0; j < iDelta; j++ )
+                {
+                    if( ret.pLink == NULL )
+                        throw Bu::ExceptionBase(
+                            "Attempt to iterate past begining of list.");
+                    ret.pLink = ret.pLink->pPrev;
+                }
+                return ret;
+            }
+
+            const_iterator &operator=( const iterator &oth )
+            {
+                pLink = oth.pLink;
+                return *this;
+            }
+
+            const_iterator &operator=( const const_iterator &oth )
+            {
+                pLink = oth.pLink;
+                return *this;
+            }
+
+            operator bool()
+            {
+                return pLink != NULL;
+            }
+
+            bool isValid()
+            {
+                return pLink != NULL;
+            }
+        } const_iterator;
+
+        /**
+         * Get an iterator pointing to the first item in the list.
+         *@returns (iterator)
+         */
+        iterator begin()
+        {
+            _hardCopy();
+            return iterator( core->pFirst );
+        }
+
+        /**
+         * Get a const iterator pointing to the first item in the list.
+         *@returns (const const_iterator)
+         */
+        const_iterator begin() const
+        {
+            return const_iterator( core->pFirst );
+        }
+
+        /**
+         * Get an iterator pointing to a place just past the last item in
+         *      the list.
+         *@returns (const Link *)
+         */
+        const iterator end()
+        {
+            return iterator( NULL );
+        }
+
+        /**
+         * Get an iterator pointing to a place just past the last item in
+         *      the list.
+         *@returns (const Link *)
+         */
+        const const_iterator end() const
+        {
+            return const_iterator( NULL );
+        }
+
+        /**
+         * Erase an item from the list.
+         *@param i (iterator) The item to erase.
+         */
+        MyType &erase( iterator i )
+        {
+            _hardCopy();
+            core->erase( i.pLink );
+
+            return *this;
+        }
+
+        /**
+         * Erase an item from the list.
+         *@param i (iterator) The item to erase.
+         */
+        MyType &erase( const_iterator i )
+        {
+            _hardCopy();
+            core->erase( i.pLink );
+
+            return *this;
+        }
+
+        /**
+         * Erase an item from the list if you already know the item.
+         *@param v The item to find and erase.
+         */
+        MyType &erase( const value &v )
+        {
+            for( const_iterator i = begin(); i != end(); i++ )
+            {
+                if( (*i) == v )
+                {
+                    erase( i );
+                    return *this;
+                }
+            }
+
+            return *this;
+        }
+        
+        /**
+         * Erases the first item in the list, identical to pop, but better for
+         * lists that aren't built as stacks, since you know where it will be
+         * erasing from.
+         */
+        MyType &eraseFirst()
+        {
+            _hardCopy();
+            erase( begin() );
+
+            return *this;
+        }
+        
+        /**
+         * Erases the last item in the list.
+         */
+        MyType &eraseLast()
+        {
+            _hardCopy();
+            core->erase( core->pLast ); 
+
+            return *this;
+        }
+
+        iterator find( const value &v )
+        {
+            for( iterator i = begin(); i; i++ )
+            {
+                if( (*i) == v )
+                    return i;
+            }
+
+            return end();
+        }
+
+        const_iterator find( const value &v ) const
+        {
+            for( const_iterator i = begin(); i; i++ )
+            {
+                if( (*i) == v )
+                    return i;
+            }
+
+            return end();
+        }
+
+        /**
+         * Get the current size of the list.
+         *@returns (int) The current size of the list.
+         */
+        long getSize() const
+        {
+            return core->nSize;
+        }
+
+        /**
+         * Get the first item in the list.
+         *@returns (value_type &) The first item in the list.
+         */
+        value &first()
+        {
+            if( core->pFirst->pValue == NULL )
+                throw Bu::ExceptionBase("Attempt to read first element from empty list.");
+            _hardCopy();
+            return *core->pFirst->pValue;
+        }
+        
+        /**
+         * Get the first item in the list.
+         *@returns (const value_type &) The first item in the list.
+         */
+        const value &first() const
+        {
+            if( core->pFirst->pValue == NULL )
+                throw Bu::ExceptionBase("Attempt to read first element from empty list.");
+            return *core->pFirst->pValue;
+        }
+        
+        /**
+         * Get the last item in the list.
+         *@returns (value_type &) The last item in the list.
+         */
+        value &last()
+        {
+            _hardCopy();
+            return *core->pLast->pValue;
+        }
+        
+        /**
+         * Get the last item in the list.
+         *@returns (const value_type &) The last item in the list.
+         */
+        const value &last() const
+        {
+            return *core->pLast->pValue;
+        }
+
+        bool isEmpty() const
+        {
+            return (core->nSize == 0);
+        }
+    
+    protected:
+        virtual Core *_copyCore( Core *src )
+        {
+            Core *pRet = _allocateCore();
+            for( Link *pCur = src->pFirst; pCur; pCur = pCur->pNext )
+            {
+                pRet->append( *pCur->pValue );
+            }
+            return pRet;
+        }
+
+    private:
+    };
+
+    class Formatter;
+    Formatter &operator<<( Formatter &rOut, char *sStr );
+    Formatter &operator<<( Formatter &rOut, signed char c );
+    template<typename a, typename b, typename c>
+    Formatter &operator<<( Formatter &f, const Bu::List<a,b,c> &l )
+    {
+        f << '[';
+        for( typename Bu::List<a,b,c>::const_iterator i = l.begin(); i; i++ )
+        {
+            if( i != l.begin() )
+                f << ", ";
+            f << *i;
+        }
+        f << ']';
+
+        return f;
+    }
+
+    template<typename value, typename a, typename b>
+    ArchiveBase &operator<<( ArchiveBase &ar, const List<value,a,b> &h )
+    {
+        ar << h.getSize();
+        for( typename List<value>::const_iterator i = h.begin(); i != h.end(); i++ )
+        {
+            ar << (*i);
+        }
+
+        return ar;
+    }
+
+    template<typename value, typename a, typename b>
+    ArchiveBase &operator>>( ArchiveBase &ar, List<value,a,b> &h )
+    {
+        h.clear();
+        long nSize;
+        ar >> nSize;
+
+        for( long j = 0; j < nSize; j++ )
+        {
+            value v;
+            ar >> v;
+            h.append( v );
+        }
+
+        return ar;
+    }
 
 }
 
diff --git a/src/stable/logger.cpp b/src/stable/logger.cpp
index fa0987e..7d49193 100644
--- a/src/stable/logger.cpp
+++ b/src/stable/logger.cpp
@@ -14,7 +14,7 @@
 
 Bu::Logger::Logger()
 {
-        setFormat("%t");
+    setFormat("%t");
 }
 
 Bu::Logger::~Logger()
@@ -24,186 +24,186 @@ Bu::Logger::~Logger()
 void Bu::Logger::log( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...)
 {
 #ifndef WIN32
-        if( (nLevel&nLevelMask) == 0 )
-                return;
+    if( (nLevel&nLevelMask) == 0 )
+        return;
 
-        va_list ap;
-        va_start( ap, sFormat );
-        char *text;
-        if( vasprintf( &text, sFormat, ap ) < 0 )
-        {
-                printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! WTF?\n");
-                return;
-        }
-        va_end(ap);
-        
-        time_t t = time(NULL);
-        
-        char *line = NULL;
-        struct tm *pTime;
-        pTime = localtime( &t );
-        if ( asprintf(
-                &line,
-                sLogFormat.getStr(),
-                pTime->tm_year+1900,
-                pTime->tm_mon+1,
-                pTime->tm_mday,
-                pTime->tm_hour,
-                pTime->tm_min,
-                pTime->tm_sec,
-                nLevel,
-                sFile,
-                nLine,
-                text,
-                sFunction
-                ) < 0 )
-        {
-                //printf("LOGGER: ERROR ALLOCATING STRING:  %s\n", strerror( errno ) );
-                return;
-        }
-        write( fileno(stdout), line, strlen(line) );
-        free( text );
-        free( line );
+    va_list ap;
+    va_start( ap, sFormat );
+    char *text;
+    if( vasprintf( &text, sFormat, ap ) < 0 )
+    {
+        printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! WTF?\n");
+        return;
+    }
+    va_end(ap);
+    
+    time_t t = time(NULL);
+    
+    char *line = NULL;
+    struct tm *pTime;
+    pTime = localtime( &t );
+    if ( asprintf(
+        &line,
+        sLogFormat.getStr(),
+        pTime->tm_year+1900,
+        pTime->tm_mon+1,
+        pTime->tm_mday,
+        pTime->tm_hour,
+        pTime->tm_min,
+        pTime->tm_sec,
+        nLevel,
+        sFile,
+        nLine,
+        text,
+        sFunction
+        ) < 0 )
+    {
+        //printf("LOGGER: ERROR ALLOCATING STRING:  %s\n", strerror( errno ) );
+        return;
+    }
+    write( fileno(stdout), line, strlen(line) );
+    free( text );
+    free( line );
 #else
-        #warning Bu::Logger::log IS A STUB for WIN32!!!!        
+    #warning Bu::Logger::log IS A STUB for WIN32!!!!    
 #endif
 }
 
 void Bu::Logger::setFormat( const Bu::String &str )
 {
-        sLogFormat = "";
+    sLogFormat = "";
 
-        static char fmts[][4]={
-                {'y', 'd', '0', '1'},
-                {'m', 'd', '0', '2'},
-                {'d', 'd', '0', '3'},
-                {'h', 'd', '0', '4'},
-                {'M', 'd', '0', '5'},
-                {'s', 'd', '0', '6'},
-                {'L', 'd', '0', '7'},
-                {'f', 's', '0', '8'},
-                {'l', 'd', '0', '9'},
-                {'t', 's', '1', '0'},
-                {'F', 's', '1', '1'},
-                {'\0', '\0', '\0', '\0'},
-        };
-        
-        for( const char *s = str.getStr(); *s; s++ )
-        {
-                if( *s == '%' )
-                {
-                        sLogFormat += '%';
-                        Bu::String sBuf;
-                        for(;;)
-                        {
-                                s++;
-                                int l;
-                                for( l = 0;; l++ )
-                                {
-                                        if( fmts[l][0] == '\0' )
-                                        {
-                                                sBuf += *s;
-                                                break;
-                                        }
-                                        else if( *s == fmts[l][0] )
-                                        {
-                                                sLogFormat += fmts[l][2];
-                                                sLogFormat += fmts[l][3];
-                                                sLogFormat += '$';
-                                                sLogFormat += sBuf;
-                                                sLogFormat += fmts[l][1];
-                                                break;
-                                        }
-                                }
-                                if( fmts[l][0] != '\0' )
-                                        break;
-                        }
-                }
-                else
-                {
-                        sLogFormat += *s;
-                }
-        }
-        sLogFormat += '\n';
+    static char fmts[][4]={
+        {'y', 'd', '0', '1'},
+        {'m', 'd', '0', '2'},
+        {'d', 'd', '0', '3'},
+        {'h', 'd', '0', '4'},
+        {'M', 'd', '0', '5'},
+        {'s', 'd', '0', '6'},
+        {'L', 'd', '0', '7'},
+        {'f', 's', '0', '8'},
+        {'l', 'd', '0', '9'},
+        {'t', 's', '1', '0'},
+        {'F', 's', '1', '1'},
+        {'\0', '\0', '\0', '\0'},
+    };
+    
+    for( const char *s = str.getStr(); *s; s++ )
+    {
+        if( *s == '%' )
+        {
+            sLogFormat += '%';
+            Bu::String sBuf;
+            for(;;)
+            {
+                s++;
+                int l;
+                for( l = 0;; l++ )
+                {
+                    if( fmts[l][0] == '\0' )
+                    {
+                        sBuf += *s;
+                        break;
+                    }
+                    else if( *s == fmts[l][0] )
+                    {
+                        sLogFormat += fmts[l][2];
+                        sLogFormat += fmts[l][3];
+                        sLogFormat += '$';
+                        sLogFormat += sBuf;
+                        sLogFormat += fmts[l][1];
+                        break;
+                    }
+                }
+                if( fmts[l][0] != '\0' )
+                    break;
+            }
+        }
+        else
+        {
+            sLogFormat += *s;
+        }
+    }
+    sLogFormat += '\n';
 
-        //write( fileno(stdout), sLogFormat.getStr(), sLogFormat.getSize() );
+    //write( fileno(stdout), sLogFormat.getStr(), sLogFormat.getSize() );
 }
 
 void Bu::Logger::setMask( uint32_t n )
 {
-        nLevelMask = n;
+    nLevelMask = n;
 }
 
 uint32_t Bu::Logger::getMask()
 {
-        return nLevelMask;
+    return nLevelMask;
 }
 
 void Bu::Logger::setLevel( uint32_t n )
 {
-        int j;
-        for( j = 31; j > 0; j-- )
-        {
-                if( (n&(1<<j)) )
-                {
-                        for(; j >= 0; j-- )
-                        {
-                                n |= (1<<j);
-                        }
-                        nLevelMask = n;
-                        return;
-                }
-        }
+    int j;
+    for( j = 31; j > 0; j-- )
+    {
+        if( (n&(1<<j)) )
+        {
+            for(; j >= 0; j-- )
+            {
+                n |= (1<<j);
+            }
+            nLevelMask = n;
+            return;
+        }
+    }
 }
 
 void Bu::Logger::hexDump( uint32_t nLevel, const char *sFile,
-                const char *sFunction, int nLine, const void *pDataV, long nDataLen,
-                const char *lpName )
+        const char *sFunction, int nLine, const void *pDataV, long nDataLen,
+        const char *lpName )
 {
-        if( (nLevel&nLevelMask) == 0 )
-                return;
+    if( (nLevel&nLevelMask) == 0 )
+        return;
 
-        log( nLevel, sFile, sFunction, nLine, "Displaying %ld bytes of %s.", nDataLen, lpName );
-        const unsigned char *pData = (const unsigned char *)pDataV;
-        int j = 0;
-        Bu::String sBorder;
-        for( int l = 0; l < 8*3+2*8+2+5; l++ ) sBorder += ((l!=11&&l!=37)?("-"):("+"));
-        log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
-        Bu::String sLine;
-        for(;;)
-        {
-                {
-                        char buf[16];
-                        sprintf( buf, "%010d | ", j );
-                        sLine += buf;
-                }
-                int kmax = 8;
-                if( nDataLen-j < 8 ) kmax = nDataLen-j;
-                for(int k = 0; k < 8; k++ )
-                {
-                        if( k < kmax )
-                        {
-                                char buf[4];
-                                sprintf( buf, "%02X ", (int)((unsigned char)pData[j+k]) );
-                                sLine += buf;
-                        }
-                        else
-                        {
-                                sLine += "-- ";
-                        }
-                }
-                sLine += "| ";
-                for(int k = 0; k < kmax; k++ )
-                {
-                        char buf[3];
-                        sprintf( buf, "%c", (pData[j+k]>32 && pData[j+k]<=128)?(pData[j+k]):('.') );
-                        sLine += buf;
-                }
-                log( nLevel, sFile, sFunction, nLine, sLine.getStr() );
-                sLine = "";
-                j += kmax;
-                if( j >= nDataLen ) break;
-        }
-        log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
+    log( nLevel, sFile, sFunction, nLine, "Displaying %ld bytes of %s.", nDataLen, lpName );
+    const unsigned char *pData = (const unsigned char *)pDataV;
+    int j = 0;
+    Bu::String sBorder;
+    for( int l = 0; l < 8*3+2*8+2+5; l++ ) sBorder += ((l!=11&&l!=37)?("-"):("+"));
+    log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
+    Bu::String sLine;
+    for(;;)
+    {
+        {
+            char buf[16];
+            sprintf( buf, "%010d | ", j );
+            sLine += buf;
+        }
+        int kmax = 8;
+        if( nDataLen-j < 8 ) kmax = nDataLen-j;
+        for(int k = 0; k < 8; k++ )
+        {
+            if( k < kmax )
+            {
+                char buf[4];
+                sprintf( buf, "%02X ", (int)((unsigned char)pData[j+k]) );
+                sLine += buf;
+            }
+            else
+            {
+                sLine += "-- ";
+            }
+        }
+        sLine += "| ";
+        for(int k = 0; k < kmax; k++ )
+        {
+            char buf[3];
+            sprintf( buf, "%c", (pData[j+k]>32 && pData[j+k]<=128)?(pData[j+k]):('.') );
+            sLine += buf;
+        }
+        log( nLevel, sFile, sFunction, nLine, sLine.getStr() );
+        sLine = "";
+        j += kmax;
+        if( j >= nDataLen ) break;
+    }
+    log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
 }
 
diff --git a/src/stable/logger.h b/src/stable/logger.h
index 198ffa2..bcc5a83 100644
--- a/src/stable/logger.h
+++ b/src/stable/logger.h
@@ -13,82 +13,82 @@
 
 namespace Bu
 {
-        /**
-         * Simple logging facility.  All output goes straight to stdout, unlike the
-         * old multi-log system.  Generally we expect any program complex enough to
-         * want to use this will have other facilities for processing the logging
-         * output, but if we need it we can add other output methods.
-         *
-         * Currently implemented as a singleton to avoid clutter with globals, you
-         * generally never want to use the logging system directly, it's annoying.
-         * Instead use the handy macros lineLog, setLogMask, setLogFormat, and
-         * setLogLevel.  They do all the real work for you.
-         *
-         * In the log format, you can specify extra information that will be written
-         * to the log with every message, and extras in printf style.  Use %X flags
-         * where X is one of the following:
-         * - L - Logging level of the log message (not the current mask)
-         * - y - Full year
-         * - m - Month
-         * - d - Day of month
-         * - h - Hour (24-hour format)
-         * - M - Minutes
-         * - s - Seconds 
-         * - f - Source file
-         * - l - Line number
-         * - F - function name
-         * - t - Text of message (usually important)
-         *
-         * You can include anything extra that you would like, a newline will always
-         * be added automatically, so no need to worry about that.  You can also
-         * include any extra printf style formatting that you would like, for
-         * example: "%h:%02M:%02s" for the time 4:02:09 instead of 4:2:9.
-         *
-         * It's generally handy to create an enum of values you use as levels during
-         * program execution (such as error, warning, info, debug, etc).  These
-         * levels should be treated as bitflags, and the most desirable messages,
-         * i.e. serious errors and the like should be low order (0x01), and the much
-         * less desirable messages, like debugging info, should be higher order
-         * (0xF0).  During operation you can then set either an explicit mask,
-         * selecting just the levels that you would like to see printed, or set the
-         * mask using the setLevel helper function, which simulates verbosity
-         * levels, enabling every flag lower order than the highest order set bit
-         * passed.  I.E. if you had the following enumerated levels:
-         * 
-         *@code
-         enum {
-                logError        = 0x01,
-                logWarning      = 0x02,
-                logInfo         = 0x04,
-                logDebug        = 0x08
-         };
-         @endcode
-         * And you set the mask with setMask( logInfo ) the only messages you would
-         * see are the ones catagorized logInfo.  However, if you used 
-         * setLevel( logInfo ) then you would see logInfo, logWarning, and logError
-         * type messages, since they are lower order.
-         */
-        class Logger : public Bu::Singleton<Bu::Logger>
-        {
-                friend class Bu::Singleton<Bu::Logger>;
-        private:
-                Logger();
-                virtual ~Logger();
+    /**
+     * Simple logging facility.  All output goes straight to stdout, unlike the
+     * old multi-log system.  Generally we expect any program complex enough to
+     * want to use this will have other facilities for processing the logging
+     * output, but if we need it we can add other output methods.
+     *
+     * Currently implemented as a singleton to avoid clutter with globals, you
+     * generally never want to use the logging system directly, it's annoying.
+     * Instead use the handy macros lineLog, setLogMask, setLogFormat, and
+     * setLogLevel.  They do all the real work for you.
+     *
+     * In the log format, you can specify extra information that will be written
+     * to the log with every message, and extras in printf style.  Use %X flags
+     * where X is one of the following:
+     * - L - Logging level of the log message (not the current mask)
+     * - y - Full year
+     * - m - Month
+     * - d - Day of month
+     * - h - Hour (24-hour format)
+     * - M - Minutes
+     * - s - Seconds 
+     * - f - Source file
+     * - l - Line number
+     * - F - function name
+     * - t - Text of message (usually important)
+     *
+     * You can include anything extra that you would like, a newline will always
+     * be added automatically, so no need to worry about that.  You can also
+     * include any extra printf style formatting that you would like, for
+     * example: "%h:%02M:%02s" for the time 4:02:09 instead of 4:2:9.
+     *
+     * It's generally handy to create an enum of values you use as levels during
+     * program execution (such as error, warning, info, debug, etc).  These
+     * levels should be treated as bitflags, and the most desirable messages,
+     * i.e. serious errors and the like should be low order (0x01), and the much
+     * less desirable messages, like debugging info, should be higher order
+     * (0xF0).  During operation you can then set either an explicit mask,
+     * selecting just the levels that you would like to see printed, or set the
+     * mask using the setLevel helper function, which simulates verbosity
+     * levels, enabling every flag lower order than the highest order set bit
+     * passed.  I.E. if you had the following enumerated levels:
+     * 
+     *@code
+     enum {
+        logError    = 0x01,
+        logWarning  = 0x02,
+        logInfo     = 0x04,
+        logDebug    = 0x08
+     };
+     @endcode
+     * And you set the mask with setMask( logInfo ) the only messages you would
+     * see are the ones catagorized logInfo.  However, if you used 
+     * setLevel( logInfo ) then you would see logInfo, logWarning, and logError
+     * type messages, since they are lower order.
+     */
+    class Logger : public Bu::Singleton<Bu::Logger>
+    {
+        friend class Bu::Singleton<Bu::Logger>;
+    private:
+        Logger();
+        virtual ~Logger();
 
-        public:
-                void log( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...);
+    public:
+        void log( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...);
 
-                void setFormat( const Bu::String &str );
-                void setMask( uint32_t n );
-                void setLevel( uint32_t n );
-                uint32_t getMask();
+        void setFormat( const Bu::String &str );
+        void setMask( uint32_t n );
+        void setLevel( uint32_t n );
+        uint32_t getMask();
 
-                void hexDump( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const void *pData, long nDataLen, const char *lpName );
+        void hexDump( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const void *pData, long nDataLen, const char *lpName );
 
-        private:
-                Bu::String sLogFormat;
-                uint32_t nLevelMask;
-        };
+    private:
+        Bu::String sLogFormat;
+        uint32_t nLevelMask;
+    };
 }
 
 /**
@@ -97,29 +97,29 @@ namespace Bu
  * file, line number, and function.
  */
 #define lineLog( nLevel, sFrmt, ...) \
-        Bu::Logger::getInstance().log( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, sFrmt, ##__VA_ARGS__ ) 
+    Bu::Logger::getInstance().log( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, sFrmt, ##__VA_ARGS__ ) 
 
 #define logHexDump( nLevel, pData, iSize, sName ) \
-        Bu::Logger::getInstance().hexDump( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, pData, iSize, sName ) 
+    Bu::Logger::getInstance().hexDump( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, pData, iSize, sName ) 
 
 /**
  * Set the Bu::Logger logging mask directly.  See Bu::Logger::setMask for
  * details.
  */
 #define setLogMask( nLevel ) \
-        Bu::Logger::getInstance().setMask( nLevel ) 
+    Bu::Logger::getInstance().setMask( nLevel ) 
 
 /**
  * Set the Bu::Logger format. See Bu::Logger::setFormat for details.
  */
 #define setLogFormat( sFrmt ) \
-        Bu::Logger::getInstance().setFormat( sFrmt ) 
+    Bu::Logger::getInstance().setFormat( sFrmt ) 
 
 /**
  * Set the Bu::Logger logging mask simulating levels.  See Bu::Logger::setLevel
  * for details.
  */
 #define setLogLevel( nLevel ) \
-        Bu::Logger::getInstance().setLevel( nLevel ) 
+    Bu::Logger::getInstance().setLevel( nLevel ) 
 
 #endif
diff --git a/src/stable/lzma.cpp b/src/stable/lzma.cpp
index 9df8f57..9ec2ce0 100644
--- a/src/stable/lzma.cpp
+++ b/src/stable/lzma.cpp
@@ -15,234 +15,234 @@
 using namespace Bu;
 
 Bu::Lzma::Lzma( Bu::Stream &rNext, int nCompression, Format eFmt ) :
-        Bu::Filter( rNext ),
-        prState( NULL ),
-        nCompression( nCompression ),
-        sTotalOut( 0 ),
-        eFmt( eFmt ),
-        bEos( false )
+    Bu::Filter( rNext ),
+    prState( NULL ),
+    nCompression( nCompression ),
+    sTotalOut( 0 ),
+    eFmt( eFmt ),
+    bEos( false )
 {
-        TRACE( nCompression );
-        start();
+    TRACE( nCompression );
+    start();
 }
 
 Bu::Lzma::~Lzma()
 {
-        TRACE();
-        stop();
+    TRACE();
+    stop();
 }
 
 void Bu::Lzma::start()
 {
-        TRACE();
-        nBufSize = 64*1024;
-        pBuf = new char[nBufSize];
+    TRACE();
+    nBufSize = 64*1024;
+    pBuf = new char[nBufSize];
 }
 
 Bu::size Bu::Lzma::stop()
 {
-        TRACE();
-        if( pState )
-        {
-                if( bReading )
-                {
-                        lzma_end( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return 0;
-                }
-                else
-                {
-                        for(;;)
-                        {
-                                pState->next_in = NULL;
-                                pState->avail_in = 0;
-                                pState->avail_out = nBufSize;
-                                pState->next_out = (uint8_t *)pBuf;
-                                int res = lzma_code( pState, LZMA_FINISH );
-                                if( pState->avail_out < nBufSize )
-                                {
-                                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                                }
-                                if( res == LZMA_STREAM_END )
-                                        break;
-                        }
-                        lzma_end( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return sTotalOut;
-                }
-        }
-        return 0;
+    TRACE();
+    if( pState )
+    {
+        if( bReading )
+        {
+            lzma_end( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return 0;
+        }
+        else
+        {
+            for(;;)
+            {
+                pState->next_in = NULL;
+                pState->avail_in = 0;
+                pState->avail_out = nBufSize;
+                pState->next_out = (uint8_t *)pBuf;
+                int res = lzma_code( pState, LZMA_FINISH );
+                if( pState->avail_out < nBufSize )
+                {
+                    sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                }
+                if( res == LZMA_STREAM_END )
+                    break;
+            }
+            lzma_end( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return sTotalOut;
+        }
+    }
+    return 0;
 }
 
 void Bu::Lzma::lzmaError( int code )
 {
-        TRACE( code );
-        switch( code )
-        {
-                case LZMA_OK:
-                case LZMA_STREAM_END:
-                case LZMA_NO_CHECK:
-                case LZMA_UNSUPPORTED_CHECK:
-                        break;
+    TRACE( code );
+    switch( code )
+    {
+        case LZMA_OK:
+        case LZMA_STREAM_END:
+        case LZMA_NO_CHECK:
+        case LZMA_UNSUPPORTED_CHECK:
+            break;
 
-                case LZMA_MEM_ERROR:
-                        throw ExceptionBase("Lzma: Memory allocation error.");
+        case LZMA_MEM_ERROR:
+            throw ExceptionBase("Lzma: Memory allocation error.");
 
-                case LZMA_MEMLIMIT_ERROR:
-                        throw ExceptionBase("Lzma: Memory usage limit was reached.");
+        case LZMA_MEMLIMIT_ERROR:
+            throw ExceptionBase("Lzma: Memory usage limit was reached.");
 
-                case LZMA_FORMAT_ERROR:
-                        throw ExceptionBase("Lzma: File format not recognized.");
+        case LZMA_FORMAT_ERROR:
+            throw ExceptionBase("Lzma: File format not recognized.");
 
-                case LZMA_OPTIONS_ERROR:
-                        throw ExceptionBase("Lzma: Invalid or unsupported options.");
+        case LZMA_OPTIONS_ERROR:
+            throw ExceptionBase("Lzma: Invalid or unsupported options.");
 
-                case LZMA_DATA_ERROR:
-                        throw ExceptionBase("Lzma: Data is corrupt.");
+        case LZMA_DATA_ERROR:
+            throw ExceptionBase("Lzma: Data is corrupt.");
 
-                case LZMA_BUF_ERROR:
-                        throw ExceptionBase("Lzma: No progress is possible.");
+        case LZMA_BUF_ERROR:
+            throw ExceptionBase("Lzma: No progress is possible.");
 
-                case LZMA_PROG_ERROR:
-                        throw ExceptionBase("Lzma: Programming error.");
+        case LZMA_PROG_ERROR:
+            throw ExceptionBase("Lzma: Programming error.");
 
-                default:
-                        throw ExceptionBase("Lzma: Unknown error encountered." );
-        }
+        default:
+            throw ExceptionBase("Lzma: Unknown error encountered." );
+    }
 }
 
 Bu::size Bu::Lzma::read( void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( !pState )
-        {
-                prState = new ::lzma_stream;
-                lzma_stream zEmpty = LZMA_STREAM_INIT;
-                Bu::memcpy( prState, &zEmpty, sizeof(lzma_stream) );
-
-                bReading = true;
-                lzmaError( lzma_auto_decoder( pState, UINT64_MAX, 0 ) );
-                pState->next_in = (uint8_t *)pBuf;
-                pState->avail_in = 0;
-        }
-        if( bReading == false )
-                throw ExceptionBase("This lzma filter is in writing mode, you can't read.");
-
-        int nRead = 0;
-        int nReadTotal = pState->total_out;
-        pState->next_out = (uint8_t *)pData;
-        pState->avail_out = nBytes;
-        for(;;)
-        {
-                int ret = lzma_code( pState, LZMA_RUN );
-//              printf("inflate returned %d; avail in=%d, out=%d\n", ret,
-//                              pState->avail_in, pState->avail_out );
-        
-                nReadTotal += nRead-pState->avail_out;
-
-                if( ret == LZMA_STREAM_END )
-                {
-                        bEos = true;
-                        if( pState->avail_in > 0 )
-                        {
-                                if( rNext.isSeekable() )
-                                {
-                                        rNext.seek( -pState->avail_in );
-                                }
-                        }
-                        return nBytes-pState->avail_out;
-                }
-//              if( ret != LZMA_BUF_ERROR )
-                        lzmaError( ret );
-
-                if( pState->avail_out )
-                {
-                        if( pState->avail_in == 0 )
-                        {
-                                nRead = rNext.read( pBuf, nBufSize );
-                                if( nRead == 0 && rNext.isEos() )
-                                {
-                                        throw Bu::ExceptionBase("Premature end of underlying "
-                                                        "stream found reading deflate stream.");
-                                }
-                                pState->next_in = (uint8_t *)pBuf;
-                                pState->avail_in = nRead;
-                        }
-                }
-                else
-                {
-                        return nBytes-pState->avail_out;
-                }
-        }
-        return 0;
+    TRACE( pData, nBytes );
+    if( !pState )
+    {
+        prState = new ::lzma_stream;
+        lzma_stream zEmpty = LZMA_STREAM_INIT;
+        Bu::memcpy( prState, &zEmpty, sizeof(lzma_stream) );
+
+        bReading = true;
+        lzmaError( lzma_auto_decoder( pState, UINT64_MAX, 0 ) );
+        pState->next_in = (uint8_t *)pBuf;
+        pState->avail_in = 0;
+    }
+    if( bReading == false )
+        throw ExceptionBase("This lzma filter is in writing mode, you can't read.");
+
+    int nRead = 0;
+    int nReadTotal = pState->total_out;
+    pState->next_out = (uint8_t *)pData;
+    pState->avail_out = nBytes;
+    for(;;)
+    {
+        int ret = lzma_code( pState, LZMA_RUN );
+//      printf("inflate returned %d; avail in=%d, out=%d\n", ret,
+//              pState->avail_in, pState->avail_out );
+    
+        nReadTotal += nRead-pState->avail_out;
+
+        if( ret == LZMA_STREAM_END )
+        {
+            bEos = true;
+            if( pState->avail_in > 0 )
+            {
+                if( rNext.isSeekable() )
+                {
+                    rNext.seek( -pState->avail_in );
+                }
+            }
+            return nBytes-pState->avail_out;
+        }
+//      if( ret != LZMA_BUF_ERROR )
+            lzmaError( ret );
+
+        if( pState->avail_out )
+        {
+            if( pState->avail_in == 0 )
+            {
+                nRead = rNext.read( pBuf, nBufSize );
+                if( nRead == 0 && rNext.isEos() )
+                {
+                    throw Bu::ExceptionBase("Premature end of underlying "
+                            "stream found reading deflate stream.");
+                }
+                pState->next_in = (uint8_t *)pBuf;
+                pState->avail_in = nRead;
+            }
+        }
+        else
+        {
+            return nBytes-pState->avail_out;
+        }
+    }
+    return 0;
 }
 
 Bu::size Bu::Lzma::write( const void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( !pState )
-        {
-                prState = new ::lzma_stream;
-                lzma_stream zEmpty = LZMA_STREAM_INIT;
-                Bu::memcpy( prState, &zEmpty, sizeof(lzma_stream) );
-
-                bReading = false;
-                if( eFmt == Xz )
-                        lzmaError(
-                                lzma_easy_encoder( pState, nCompression, LZMA_CHECK_CRC64 )
-                                );
-                else if( eFmt == LzmaAlone )
-                {
-                        lzma_options_lzma opt;
-                        lzma_lzma_preset( &opt, nCompression );
-                        lzmaError( lzma_alone_encoder( pState, &opt ) );
-                }
-                else
-                        throw Bu::ExceptionBase("Invalid format for lzma.");
-        }
-        if( bReading == true )
-                throw ExceptionBase("This lzma filter is in reading mode, you can't write.");
-
-        pState->next_in = (uint8_t *)pData;
-        pState->avail_in = nBytes;
-        for(;;)
-        {
-                pState->avail_out = nBufSize;
-                pState->next_out = (uint8_t *)pBuf;
-
-                lzmaError( lzma_code( pState, LZMA_RUN ) );
-
-                if( pState->avail_out < nBufSize )
-                {
-                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                }
-                if( pState->avail_in == 0 )
-                        break;
-        }
-
-        return nBytes;
+    TRACE( pData, nBytes );
+    if( !pState )
+    {
+        prState = new ::lzma_stream;
+        lzma_stream zEmpty = LZMA_STREAM_INIT;
+        Bu::memcpy( prState, &zEmpty, sizeof(lzma_stream) );
+
+        bReading = false;
+        if( eFmt == Xz )
+            lzmaError(
+                lzma_easy_encoder( pState, nCompression, LZMA_CHECK_CRC64 )
+                );
+        else if( eFmt == LzmaAlone )
+        {
+            lzma_options_lzma opt;
+            lzma_lzma_preset( &opt, nCompression );
+            lzmaError( lzma_alone_encoder( pState, &opt ) );
+        }
+        else
+            throw Bu::ExceptionBase("Invalid format for lzma.");
+    }
+    if( bReading == true )
+        throw ExceptionBase("This lzma filter is in reading mode, you can't write.");
+
+    pState->next_in = (uint8_t *)pData;
+    pState->avail_in = nBytes;
+    for(;;)
+    {
+        pState->avail_out = nBufSize;
+        pState->next_out = (uint8_t *)pBuf;
+
+        lzmaError( lzma_code( pState, LZMA_RUN ) );
+
+        if( pState->avail_out < nBufSize )
+        {
+            sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+        }
+        if( pState->avail_in == 0 )
+            break;
+    }
+
+    return nBytes;
 }
 
 bool Bu::Lzma::isOpen()
 {
-        TRACE();
-        return (pState != NULL);
+    TRACE();
+    return (pState != NULL);
 }
 
 bool Bu::Lzma::isEos()
 {
-        TRACE();
-        return bEos;
+    TRACE();
+    return bEos;
 }
 
 Bu::size Bu::Lzma::getCompressedSize()
 {
-        return sTotalOut;
+    return sTotalOut;
 }
 
diff --git a/src/stable/lzma.h b/src/stable/lzma.h
index 7118a6b..40963cc 100644
--- a/src/stable/lzma.h
+++ b/src/stable/lzma.h
@@ -14,46 +14,46 @@
 
 namespace Bu
 {
-        /**
-         * Provides XZ compression and decompression, both LZMA1 (LzmaAlone) as
-         * well as the newer LZMA2 (xz) format.  This uses .xz by default.
-         *
-         *@ingroup Streams
-         *@ingroup Compression
-         */
-        class Lzma : public Bu::Filter
-        {
-        public:
-                enum Format
-                {
-                        Xz                      = 0x01,
-                        LzmaAlone       = 0x02,
-                };
-
-                Lzma( Bu::Stream &rNext, int nCompression=6, Format eFmt=Xz );
-                virtual ~Lzma();
-
-                virtual void start();
-                virtual Bu::size stop();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-
-                virtual bool isOpen();
-                virtual bool isEos();
-
-                Bu::size getCompressedSize();
-
-        private:
-                void lzmaError( int code );
-                void *prState;
-                bool bReading;
-                int nCompression;
-                char *pBuf;
-                uint32_t nBufSize;
-                Bu::size sTotalOut;
-                Format eFmt;
-                bool bEos;
-        };
+    /**
+     * Provides XZ compression and decompression, both LZMA1 (LzmaAlone) as
+     * well as the newer LZMA2 (xz) format.  This uses .xz by default.
+     *
+     *@ingroup Streams
+     *@ingroup Compression
+     */
+    class Lzma : public Bu::Filter
+    {
+    public:
+        enum Format
+        {
+            Xz          = 0x01,
+            LzmaAlone   = 0x02,
+        };
+
+        Lzma( Bu::Stream &rNext, int nCompression=6, Format eFmt=Xz );
+        virtual ~Lzma();
+
+        virtual void start();
+        virtual Bu::size stop();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+        virtual bool isOpen();
+        virtual bool isEos();
+
+        Bu::size getCompressedSize();
+
+    private:
+        void lzmaError( int code );
+        void *prState;
+        bool bReading;
+        int nCompression;
+        char *pBuf;
+        uint32_t nBufSize;
+        Bu::size sTotalOut;
+        Format eFmt;
+        bool bEos;
+    };
 }
 
 #endif
diff --git a/src/stable/md5.cpp b/src/stable/md5.cpp
index c1d993f..e62cbf4 100644
--- a/src/stable/md5.cpp
+++ b/src/stable/md5.cpp
@@ -19,7 +19,7 @@
 
 Bu::Md5::Md5()
 {
-        reset();
+    reset();
 }
 
 Bu::Md5::~Md5()
@@ -28,15 +28,15 @@ Bu::Md5::~Md5()
 
 void Bu::Md5::reset()
 {
-        // These are the magic seed numbers...
+    // These are the magic seed numbers...
 
-        sum[0] = 0x67452301U;
-        sum[1] = 0xEFCDAB89U;
-        sum[2] = 0x98BADCFEU;
-        sum[3] = 0x10325476U;
+    sum[0] = 0x67452301U;
+    sum[1] = 0xEFCDAB89U;
+    sum[2] = 0x98BADCFEU;
+    sum[3] = 0x10325476U;
 
-        uBits[0] = 0;
-        uBits[1] = 0;
+    uBits[0] = 0;
+    uBits[1] = 0;
 }
 
 void Bu::Md5::setSalt( const Bu::String & /*sSalt*/ )
@@ -45,102 +45,102 @@ void Bu::Md5::setSalt( const Bu::String & /*sSalt*/ )
 
 void Bu::Md5::addData( const void *sVData, int iSize )
 {
-        const char *sData = (const char *)sVData;
-        uint32_t t;
-
-        t = uBits[0];
-        if( (uBits[0] = t + ((uint32_t)iSize << 3)) < t )
-                uBits[1]++;
-        uBits[1] += iSize >> 29;
-
-        t = (t >> 3) & 0x3f;    /* How many bytes we have buffered */
-
-        /* Handle any leading odd-sized chunks */
-        if( t )
-        {
-                unsigned char *p = (unsigned char *) inbuf + t;
-
-                t = 64 - t;
-                if( (uint32_t)iSize < t ) {
-                        memcpy( p, sData, iSize );
-                        return;
-                }
-                memcpy( p, sData, t );
-                toLittleEndian( inbuf, 16 );
-                compBlock( sum, (uint32_t *)inbuf );
-                sData += t;
-                iSize -= t;
-        }
-
-        /* Process data in 64-byte chunks */
-        while( iSize >= 64 )
-        {
-                memcpy( inbuf, sData, 64 );
-                toLittleEndian( inbuf, 16 );
-                compBlock( sum, (uint32_t *)inbuf );
-                sData += 64;
-                iSize -= 64;
-        }
-
-        /* Handle any remaining bytes of data. */
-        memcpy( inbuf, sData, iSize );
+    const char *sData = (const char *)sVData;
+    uint32_t t;
+
+    t = uBits[0];
+    if( (uBits[0] = t + ((uint32_t)iSize << 3)) < t )
+        uBits[1]++;
+    uBits[1] += iSize >> 29;
+
+    t = (t >> 3) & 0x3f;    /* How many bytes we have buffered */
+
+    /* Handle any leading odd-sized chunks */
+    if( t )
+    {
+        unsigned char *p = (unsigned char *) inbuf + t;
+
+        t = 64 - t;
+        if( (uint32_t)iSize < t ) {
+            memcpy( p, sData, iSize );
+            return;
+        }
+        memcpy( p, sData, t );
+        toLittleEndian( inbuf, 16 );
+        compBlock( sum, (uint32_t *)inbuf );
+        sData += t;
+        iSize -= t;
+    }
+
+    /* Process data in 64-byte chunks */
+    while( iSize >= 64 )
+    {
+        memcpy( inbuf, sData, 64 );
+        toLittleEndian( inbuf, 16 );
+        compBlock( sum, (uint32_t *)inbuf );
+        sData += 64;
+        iSize -= 64;
+    }
+
+    /* Handle any remaining bytes of data. */
+    memcpy( inbuf, sData, iSize );
 }
 
 Bu::String Bu::Md5::getResult()
 {
-        uint32_t lsum[4];
-        compCap( lsum );
-        return Bu::String( (const char *)lsum, 4*4 );
+    uint32_t lsum[4];
+    compCap( lsum );
+    return Bu::String( (const char *)lsum, 4*4 );
 }
 
 void Bu::Md5::writeResult( Bu::Stream &sOut )
 {
-        uint32_t lsum[4];
-        compCap( lsum );
-        sOut.write( lsum, 4*4 );
+    uint32_t lsum[4];
+    compCap( lsum );
+    sOut.write( lsum, 4*4 );
 }
 
 void Bu::Md5::compCap( uint32_t *sumout )
 {
-        uint8_t tmpbuf[64];
-        memcpy( sumout, sum, 4*4 );
-        memcpy( tmpbuf, inbuf, 64 );
-
-        uint32_t count;
-        uint8_t *p;
-
-        /* Compute number of bytes mod 64 */
-        count = (uBits[0] >> 3) & 0x3F;
-
-        /* Set the first char of padding to 0x80.  This is safe since there is
-           always at least one byte free */
-        p = tmpbuf + count;
-        *p++ = 0x80;
-
-        /* Bytes of padding needed to make 64 bytes */
-        count = 64 - 1 - count;
-
-        /* Pad out to 56 mod 64 */
-        if (count < 8) {
-                /* Two lots of padding:  Pad the first block to 64 bytes */
-                memset( p, 0, count );
-                toLittleEndian( tmpbuf, 16 );
-                compBlock( sumout, (uint32_t *)tmpbuf );
-
-                /* Now fill the next block with 56 bytes */
-                memset( tmpbuf, 0, 56);
-        } else {
-                /* Pad block to 56 bytes */
-                memset( p, 0, count - 8);
-        }
-        toLittleEndian( tmpbuf, 14 );
-
-        /* Append length in bits and transform */
-        ((uint32_t *) tmpbuf)[14] = uBits[0];
-        ((uint32_t *) tmpbuf)[15] = uBits[1];
-
-        compBlock( sumout, (uint32_t *)tmpbuf );
-        toLittleEndian((unsigned char *)sumout, 4);
+    uint8_t tmpbuf[64];
+    memcpy( sumout, sum, 4*4 );
+    memcpy( tmpbuf, inbuf, 64 );
+
+    uint32_t count;
+    uint8_t *p;
+
+    /* Compute number of bytes mod 64 */
+    count = (uBits[0] >> 3) & 0x3F;
+
+    /* Set the first char of padding to 0x80.  This is safe since there is
+       always at least one byte free */
+    p = tmpbuf + count;
+    *p++ = 0x80;
+
+    /* Bytes of padding needed to make 64 bytes */
+    count = 64 - 1 - count;
+
+    /* Pad out to 56 mod 64 */
+    if (count < 8) {
+        /* Two lots of padding:  Pad the first block to 64 bytes */
+        memset( p, 0, count );
+        toLittleEndian( tmpbuf, 16 );
+        compBlock( sumout, (uint32_t *)tmpbuf );
+
+        /* Now fill the next block with 56 bytes */
+        memset( tmpbuf, 0, 56);
+    } else {
+        /* Pad block to 56 bytes */
+        memset( p, 0, count - 8);
+    }
+    toLittleEndian( tmpbuf, 14 );
+
+    /* Append length in bits and transform */
+    ((uint32_t *) tmpbuf)[14] = uBits[0];
+    ((uint32_t *) tmpbuf)[15] = uBits[1];
+
+    compBlock( sumout, (uint32_t *)tmpbuf );
+    toLittleEndian((unsigned char *)sumout, 4);
 }
 
 #define F1(x, y, z) (z ^ (x & (y ^ z)))
@@ -150,15 +150,15 @@ void Bu::Md5::compCap( uint32_t *sumout )
 
 /* This is the central step in the MD5 algorithm. */
 #define MD5STEP(f, w, x, y, z, data, s) \
-        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+    ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
 
 void Bu::Md5::compBlock( uint32_t *lsum, uint32_t *x )
 {
-        register uint32_t a, b, c, d;
-        a = lsum[0];
-        b = lsum[1];
-        c = lsum[2];
-        d = lsum[3];
+    register uint32_t a, b, c, d;
+    a = lsum[0];
+    b = lsum[1];
+    c = lsum[2];
+    d = lsum[3];
 
     MD5STEP(F1, a, b, c, d, x[0] + 0xd76aa478, 7);
     MD5STEP(F1, d, a, b, c, x[1] + 0xe8c7b756, 12);
@@ -228,19 +228,19 @@ void Bu::Md5::compBlock( uint32_t *lsum, uint32_t *x )
     MD5STEP(F4, c, d, a, b, x[2] + 0x2ad7d2bb, 15);
     MD5STEP(F4, b, c, d, a, x[9] + 0xeb86d391, 21);
 
-        lsum[0] += a;
-        lsum[1] += b;
-        lsum[2] += c;
-        lsum[3] += d;
+    lsum[0] += a;
+    lsum[1] += b;
+    lsum[2] += c;
+    lsum[3] += d;
 }
 
 void Bu::Md5::_toLittleEndian( uint8_t *buf, uint32_t count )
 {
-        uint32_t t;
-        do {
-                t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
-                        ((unsigned) buf[1] << 8 | buf[0]);
-                *(uint32_t *) buf = t;
-                buf += 4;
-        } while( --count );
+    uint32_t t;
+    do {
+        t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
+            ((unsigned) buf[1] << 8 | buf[0]);
+        *(uint32_t *) buf = t;
+        buf += 4;
+    } while( --count );
 }
diff --git a/src/stable/md5.h b/src/stable/md5.h
index cb7d396..8845082 100644
--- a/src/stable/md5.h
+++ b/src/stable/md5.h
@@ -12,43 +12,43 @@
 
 namespace Bu
 {
-        /**
-         * Class for easily calculating MD5 sums of just about any data.
-         * This code is based on some public domain code written by Colin Plumb in
-         * 1993.
-         *@author Mike Buland
-         */
-        class Md5 : public Bu::CryptoHash
-        {
-        public:
-                /** Build an MD5 sum builder. */
-                Md5();
-
-                /** Deconstruct */
-                virtual ~Md5();
-
-                virtual void reset();
-                virtual void setSalt( const Bu::String &sSalt );
-                virtual void addData( const void *sData, int iSize );
-                using Bu::CryptoHash::addData;
-                virtual String getResult();
-                virtual void writeResult( Bu::Stream &sOut );
-
-        private:
-                /**
-                 * Compute one block of input data.
-                 */
-                void compBlock( uint32_t *lsum, uint32_t *x );
-                void compCap( uint32_t *sumout );
-
-                void _addData( uint8_t *target, int &iCurFill, const void *sData,
-                                int iSize );
-                void _toLittleEndian( uint8_t *buf, uint32_t count );
-                
-                uint8_t inbuf[64];
-                uint32_t sum[4];
-                uint32_t uBits[2];
-        };
+    /**
+     * Class for easily calculating MD5 sums of just about any data.
+     * This code is based on some public domain code written by Colin Plumb in
+     * 1993.
+     *@author Mike Buland
+     */
+    class Md5 : public Bu::CryptoHash
+    {
+    public:
+        /** Build an MD5 sum builder. */
+        Md5();
+
+        /** Deconstruct */
+        virtual ~Md5();
+
+        virtual void reset();
+        virtual void setSalt( const Bu::String &sSalt );
+        virtual void addData( const void *sData, int iSize );
+        using Bu::CryptoHash::addData;
+        virtual String getResult();
+        virtual void writeResult( Bu::Stream &sOut );
+
+    private:
+        /**
+         * Compute one block of input data.
+         */
+        void compBlock( uint32_t *lsum, uint32_t *x );
+        void compCap( uint32_t *sumout );
+
+        void _addData( uint8_t *target, int &iCurFill, const void *sData,
+                int iSize );
+        void _toLittleEndian( uint8_t *buf, uint32_t count );
+        
+        uint8_t inbuf[64];
+        uint32_t sum[4];
+        uint32_t uBits[2];
+    };
 };
 
 #endif
diff --git a/src/stable/membuf.cpp b/src/stable/membuf.cpp
index dea9a0e..4d6e8e6 100644
--- a/src/stable/membuf.cpp
+++ b/src/stable/membuf.cpp
@@ -10,13 +10,13 @@
 using namespace Bu;
 
 Bu::MemBuf::MemBuf() :
-        nPos( 0 )
+    nPos( 0 )
 {
 }
 
 Bu::MemBuf::MemBuf( const Bu::String &str ) :
-        sBuf( str ),
-        nPos( 0 )
+    sBuf( str ),
+    nPos( 0 )
 {
 }
 
@@ -30,76 +30,76 @@ void Bu::MemBuf::close()
 
 size Bu::MemBuf::read( void *pBuf, size nBytes )
 {
-        if( (size)sBuf.getSize()-(size)nPos < nBytes )
-                nBytes = sBuf.getSize()-nPos;
+    if( (size)sBuf.getSize()-(size)nPos < nBytes )
+        nBytes = sBuf.getSize()-nPos;
 
-        memcpy( pBuf, sBuf.getStr()+nPos, nBytes );
-        nPos += nBytes;
+    memcpy( pBuf, sBuf.getStr()+nPos, nBytes );
+    nPos += nBytes;
 
-        return nBytes;
+    return nBytes;
 }
-        
+    
 size Bu::MemBuf::write( const void *pBuf, size nBytes )
 {
-        if( nPos == sBuf.getSize() )
-        {
-                // Easiest, just append the data.
-                sBuf.append( (const char *)pBuf, nBytes );
-                nPos += nBytes;
-                return nBytes;
-        }
-        else
-        {
-                // Trickier, we must do this in two parts, overwrite, then append
-                // Frist, overwrite.
-                size iOver = sBuf.getSize() - nPos;
-                if( iOver > nBytes )
-                        iOver = nBytes;
-                memcpy( sBuf.getStr()+nPos, pBuf, iOver );
-                // Then append
-                if( iOver < nBytes )
-                {
-                        sBuf.append( ((const char *)pBuf)+iOver, nBytes-iOver );
-                }
-                nPos += nBytes;
-                return nBytes;
-        }
+    if( nPos == sBuf.getSize() )
+    {
+        // Easiest, just append the data.
+        sBuf.append( (const char *)pBuf, nBytes );
+        nPos += nBytes;
+        return nBytes;
+    }
+    else
+    {
+        // Trickier, we must do this in two parts, overwrite, then append
+        // Frist, overwrite.
+        size iOver = sBuf.getSize() - nPos;
+        if( iOver > nBytes )
+            iOver = nBytes;
+        memcpy( sBuf.getStr()+nPos, pBuf, iOver );
+        // Then append
+        if( iOver < nBytes )
+        {
+            sBuf.append( ((const char *)pBuf)+iOver, nBytes-iOver );
+        }
+        nPos += nBytes;
+        return nBytes;
+    }
 }
 
 size Bu::MemBuf::tell()
 {
-        return nPos;
+    return nPos;
 }
 
 void Bu::MemBuf::seek( size offset )
 {
-        nPos += offset;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+    nPos += offset;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
 }
 
 void Bu::MemBuf::setPos( size pos )
 {
-        nPos = pos;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+    nPos = pos;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
 }
 
 void Bu::MemBuf::setPosEnd( size pos )
 {
-        nPos = sBuf.getSize()-pos;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+    nPos = sBuf.getSize()-pos;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
 }
 
 bool Bu::MemBuf::isEos()
 {
-        return (nPos == sBuf.getSize());
+    return (nPos == sBuf.getSize());
 }
 
 bool Bu::MemBuf::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::MemBuf::flush()
@@ -108,32 +108,32 @@ void Bu::MemBuf::flush()
 
 bool Bu::MemBuf::canRead()
 {
-        return !isEos();
+    return !isEos();
 }
 
 bool Bu::MemBuf::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MemBuf::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MemBuf::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MemBuf::isSeekable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MemBuf::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::MemBuf::setBlocking( bool )
@@ -142,36 +142,36 @@ void Bu::MemBuf::setBlocking( bool )
 
 void Bu::MemBuf::setSize( size iSize )
 {
-        if( iSize < 0 )
-                iSize = 0;
-        sBuf.setSize( iSize );
-        if( nPos > iSize )
-                nPos = iSize;
+    if( iSize < 0 )
+        iSize = 0;
+    sBuf.setSize( iSize );
+    if( nPos > iSize )
+        nPos = iSize;
 }
 
 Bu::size Bu::MemBuf::getSize() const
 {
-        return sBuf.getSize();
+    return sBuf.getSize();
 }
 
 Bu::size Bu::MemBuf::getBlockSize() const
 {
-        return sBuf.getSize();
+    return sBuf.getSize();
 }
 
 Bu::String Bu::MemBuf::getLocation() const
 {
-        return "";
+    return "";
 }
 
 Bu::String &Bu::MemBuf::getString()
 {
-        return sBuf;
+    return sBuf;
 }
 
 void Bu::MemBuf::setString( const Bu::String &sNewData )
 {
-        sBuf = sNewData;
-        nPos = 0;
+    sBuf = sNewData;
+    nPos = 0;
 }
 
diff --git a/src/stable/membuf.h b/src/stable/membuf.h
index f016974..f36e0bc 100644
--- a/src/stable/membuf.h
+++ b/src/stable/membuf.h
@@ -16,53 +16,53 @@
 
 namespace Bu
 {
-        /**
-         * A memory buffer stream.  This provides a read/write stream in memory that
-         * works exactly like a file stream...only in memory.  You can seed the
-         * memory buffer with a Bu::String of your own, or start with an empty one.
-         * Due to Bu::String using Bu::SharedCore starting with a string will not
-         * necesarilly cause the MemBuf to make a copy of your memory, but if you're
-         * sure you're not going to need to change the stream then use StaticMemBuf.
-         *@ingroup Streams
-         */
-        class MemBuf : public Stream
-        {
-        public:
-                MemBuf();
-                MemBuf( const Bu::String &str );
-                virtual ~MemBuf();
+    /**
+     * A memory buffer stream.  This provides a read/write stream in memory that
+     * works exactly like a file stream...only in memory.  You can seed the
+     * memory buffer with a Bu::String of your own, or start with an empty one.
+     * Due to Bu::String using Bu::SharedCore starting with a string will not
+     * necesarilly cause the MemBuf to make a copy of your memory, but if you're
+     * sure you're not going to need to change the stream then use StaticMemBuf.
+     *@ingroup Streams
+     */
+    class MemBuf : public Stream
+    {
+    public:
+        MemBuf();
+        MemBuf( const Bu::String &str );
+        virtual ~MemBuf();
 
-                virtual void close();
-                virtual size read( void *pBuf, size iBytes );
+        virtual void close();
+        virtual size read( void *pBuf, size iBytes );
 
-                virtual size write( const void *pBuf, size iBytes );
-                using Stream::write;
-                virtual size tell();
-                virtual void seek( size offset );
-                virtual void setPos( size pos );
-                virtual void setPosEnd( size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( size iSize );
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size write( const void *pBuf, size iBytes );
+        using Stream::write;
+        virtual size tell();
+        virtual void seek( size offset );
+        virtual void setPos( size pos );
+        virtual void setPosEnd( size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( size iSize );
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-                Bu::String &getString();
-                void setString( const Bu::String &sNewData );
+        Bu::String &getString();
+        void setString( const Bu::String &sNewData );
 
-        private:
-                Bu::String sBuf;
-                size nPos;
-        };
+    private:
+        Bu::String sBuf;
+        size nPos;
+    };
 }
 
 #endif
diff --git a/src/stable/minicron.cpp b/src/stable/minicron.cpp
index 87296ae..c83cd44 100644
--- a/src/stable/minicron.cpp
+++ b/src/stable/minicron.cpp
@@ -11,260 +11,260 @@
 #include <time.h>
 
 Bu::MiniCron::MiniCron() :
-        jidNext( 1 )
+    jidNext( 1 )
 {
 }
 
 Bu::MiniCron::~MiniCron()
 {
-        while( !hJobs.isEmpty() )
-        {
-                delete hJobs.dequeue();
-        }
+    while( !hJobs.isEmpty() )
+    {
+        delete hJobs.dequeue();
+    }
 }
 
 bool Bu::MiniCron::hasJobs()
 {
-        return !hJobs.isEmpty();
+    return !hJobs.isEmpty();
 }
 
 time_t Bu::MiniCron::getNextRun()
 {
-        if( hasJobs() )
-                return hJobs.peek()->getNextRun();
-        return -1;
+    if( hasJobs() )
+        return hJobs.peek()->getNextRun();
+    return -1;
 }
 
 time_t Bu::MiniCron::getNextRun( Bu::MiniCron::JobId jid )
 {
-        for( JobHeap::iterator i = hJobs.begin(); i; i++ )
-        {
-                if( (*i)->getId() == jid )
-                {
-                        return (*i)->getNextRunTime();
-                }
-        }
-        return -1;
+    for( JobHeap::iterator i = hJobs.begin(); i; i++ )
+    {
+        if( (*i)->getId() == jid )
+        {
+            return (*i)->getNextRunTime();
+        }
+    }
+    return -1;
 }
 
 void Bu::MiniCron::poll()
 {
-        time_t tNow = time( NULL );
-
-        while( !hJobs.isEmpty() )
-        {
-                if( hJobs.peek()->getNextRun() <= tNow )
-                {
-                        Job *pJob = hJobs.dequeue();
-                        pJob->run();
-                        if( pJob->bContinue )
-                        {
-                                hJobs.enqueue( pJob );
-                        }
-                        else
-                        {
-                                delete pJob;
-                        }
-                }
-                else
-                {
-                        break;
-                }
-        }
+    time_t tNow = time( NULL );
+
+    while( !hJobs.isEmpty() )
+    {
+        if( hJobs.peek()->getNextRun() <= tNow )
+        {
+            Job *pJob = hJobs.dequeue();
+            pJob->run();
+            if( pJob->bContinue )
+            {
+                hJobs.enqueue( pJob );
+            }
+            else
+            {
+                delete pJob;
+            }
+        }
+        else
+        {
+            break;
+        }
+    }
 }
 
 Bu::MiniCron::JobId Bu::MiniCron::addJob( const Bu::String &sName,
-                Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
+        Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
 {
-        JobId jid = jidNext++;
-        Job *pJob = new Job( sName, jid );
-        pJob->sigJob = sigJob;
-        pJob->pTimer = t.clone();
-        pJob->tNextRun = pJob->pTimer->nextTime();
-        hJobs.enqueue( pJob );
+    JobId jid = jidNext++;
+    Job *pJob = new Job( sName, jid );
+    pJob->sigJob = sigJob;
+    pJob->pTimer = t.clone();
+    pJob->tNextRun = pJob->pTimer->nextTime();
+    hJobs.enqueue( pJob );
 
-        return jid;
+    return jid;
 }
 
 Bu::MiniCron::JobId Bu::MiniCron::addJobOnce( const Bu::String &sName,
-                Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
+        Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
 {
-        JobId jid = jidNext++;
-        Job *pJob = new Job( sName, jid, false );
-        pJob->sigJob = sigJob;
-        pJob->pTimer = t.clone();
-        pJob->tNextRun = pJob->pTimer->nextTime();
-        hJobs.enqueue( pJob );
+    JobId jid = jidNext++;
+    Job *pJob = new Job( sName, jid, false );
+    pJob->sigJob = sigJob;
+    pJob->pTimer = t.clone();
+    pJob->tNextRun = pJob->pTimer->nextTime();
+    hJobs.enqueue( pJob );
 
-        return jid;
+    return jid;
 }
 
 void Bu::MiniCron::removeJob( JobId jid )
 {
-        Bu::List<Job *> lJobs;
-        while( !hJobs.isEmpty() )
-        {
-                Job *pJob = hJobs.dequeue();
-                if( pJob->getId() == jid )
-                {
-                        delete pJob;
-                }
-                else
-                        lJobs.append( pJob );
-        }
+    Bu::List<Job *> lJobs;
+    while( !hJobs.isEmpty() )
+    {
+        Job *pJob = hJobs.dequeue();
+        if( pJob->getId() == jid )
+        {
+            delete pJob;
+        }
+        else
+            lJobs.append( pJob );
+    }
 
-        for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
-        {
-                hJobs.enqueue( *i );
-        }
+    for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
+    {
+        hJobs.enqueue( *i );
+    }
 }
 
 void Bu::MiniCron::runJob( JobId jid, bool bReschedule )
 {
-        Bu::List<Job *> lJobs;
-        while( !hJobs.isEmpty() )
-        {
-                Job *pJob = hJobs.dequeue();
-                if( pJob->getId() == jid )
-                {
-                        pJob->run( bReschedule );
-                        if( !pJob->bContinue )
-                        {
-                                delete pJob;
-                                break;
-                        }
-                        lJobs.append( pJob );
-                        break;
-                }
-                lJobs.append( pJob );
-        }
-
-        for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
-        {
-                hJobs.enqueue( *i );
-        }
+    Bu::List<Job *> lJobs;
+    while( !hJobs.isEmpty() )
+    {
+        Job *pJob = hJobs.dequeue();
+        if( pJob->getId() == jid )
+        {
+            pJob->run( bReschedule );
+            if( !pJob->bContinue )
+            {
+                delete pJob;
+                break;
+            }
+            lJobs.append( pJob );
+            break;
+        }
+        lJobs.append( pJob );
+    }
+
+    for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
+    {
+        hJobs.enqueue( *i );
+    }
 }
 
 void Bu::MiniCron::runJob( const Bu::String &sName, bool bReschedule )
 {
-        Bu::List<Job *> lJobs;
-        while( !hJobs.isEmpty() )
-        {
-                Job *pJob = hJobs.dequeue();
-                if( pJob->getName() == sName )
-                {
-                        pJob->run( bReschedule );
-                        if( !pJob->bContinue )
-                        {
-                                delete pJob;
-                                break;
-                        }
-                        lJobs.append( pJob );
-                        break;
-                }
-                lJobs.append( pJob );
-        }
-
-        for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
-        {
-                hJobs.enqueue( *i );
-        }
+    Bu::List<Job *> lJobs;
+    while( !hJobs.isEmpty() )
+    {
+        Job *pJob = hJobs.dequeue();
+        if( pJob->getName() == sName )
+        {
+            pJob->run( bReschedule );
+            if( !pJob->bContinue )
+            {
+                delete pJob;
+                break;
+            }
+            lJobs.append( pJob );
+            break;
+        }
+        lJobs.append( pJob );
+    }
+
+    for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
+    {
+        hJobs.enqueue( *i );
+    }
 }
 
 Bu::MiniCron::JobInfoList Bu::MiniCron::getJobInfo()
 {
-        JobInfoList lRet;
-        for( JobHeap::iterator i = hJobs.begin(); i; i++ )
-        {
-                lRet.append(
-                        JobInfo( (*i)->getName(), (*i)->getId(), (*i)->getNextRun() )
-                        );
-        }
-        lRet.sort();
-        return lRet;
+    JobInfoList lRet;
+    for( JobHeap::iterator i = hJobs.begin(); i; i++ )
+    {
+        lRet.append(
+            JobInfo( (*i)->getName(), (*i)->getId(), (*i)->getNextRun() )
+            );
+    }
+    lRet.sort();
+    return lRet;
 }
 
 Bu::MiniCron::Job::Job( const Bu::String &sName, JobId jid, bool bRepeat ) :
-        sName( sName ),
-        pTimer( NULL ),
-        bContinue( bRepeat ),
-        jid( jid ),
-        tAdded( time( NULL ) ),
-        iRunCount( 0 )
+    sName( sName ),
+    pTimer( NULL ),
+    bContinue( bRepeat ),
+    jid( jid ),
+    tAdded( time( NULL ) ),
+    iRunCount( 0 )
 {
 }
 
 Bu::MiniCron::Job::~Job()
 {
-        delete pTimer;
-        pTimer = NULL;
+    delete pTimer;
+    pTimer = NULL;
 }
 
 void Bu::MiniCron::Job::run( bool bReschedule )
 {
-        iRunCount++;
-        if( bReschedule )
-                tNextRun = pTimer->nextTime();
-        sigJob( *this );
+    iRunCount++;
+    if( bReschedule )
+        tNextRun = pTimer->nextTime();
+    sigJob( *this );
 }
 
 time_t Bu::MiniCron::Job::getNextRun() const
 {
-        return tNextRun;
+    return tNextRun;
 }
 
 void Bu::MiniCron::Job::calcNextRun()
 {
-        if( pTimer )
-                tNextRun = pTimer->nextTime();
+    if( pTimer )
+        tNextRun = pTimer->nextTime();
 }
 
 void Bu::MiniCron::Job::setTimer( const Timer &t )
 {
-        delete pTimer;
-        pTimer = t.clone();
+    delete pTimer;
+    pTimer = t.clone();
 }
 
 void Bu::MiniCron::Job::stop()
 {
-        bContinue = false;
+    bContinue = false;
 }
 
 void Bu::MiniCron::Job::resume()
 {
-        bContinue = true;
+    bContinue = true;
 }
 
 Bu::MiniCron::JobId Bu::MiniCron::Job::getId() const
 {
-        return jid;
+    return jid;
 }
 
 time_t Bu::MiniCron::Job::getTimeCreated() const
 {
-        return tAdded;
+    return tAdded;
 }
 
 int Bu::MiniCron::Job::getRunCount() const
 {
-        return iRunCount;
+    return iRunCount;
 }
 
 time_t Bu::MiniCron::Job::getNextRunTime() const
 {
-        return tNextRun;
+    return tNextRun;
 }
 
 Bu::String Bu::MiniCron::Job::getName() const
 {
-        return sName;
+    return sName;
 }
 
 Bu::MiniCron::JobInfo::JobInfo( const Bu::String &sName, JobId jid,
-                time_t tNext ) :
-        sName( sName ),
-        jid( jid ),
-        tNext( tNext )
+        time_t tNext ) :
+    sName( sName ),
+    jid( jid ),
+    tNext( tNext )
 {
 }
 
@@ -274,7 +274,7 @@ Bu::MiniCron::JobInfo::~JobInfo()
 
 bool Bu::MiniCron::JobInfo::operator<( const JobInfo &rhs ) const
 {
-        return jid < rhs.jid;
+    return jid < rhs.jid;
 }
 
 Bu::MiniCron::Timer::Timer()
@@ -286,8 +286,8 @@ Bu::MiniCron::Timer::~Timer()
 }
 
 Bu::MiniCron::TimerInterval::TimerInterval( time_t tFirst, time_t tInterval ) :
-        tNext( tFirst ),
-        tInterval( tInterval )
+    tNext( tFirst ),
+    tInterval( tInterval )
 {
 }
 
@@ -297,14 +297,14 @@ Bu::MiniCron::TimerInterval::~TimerInterval()
 
 time_t Bu::MiniCron::TimerInterval::nextTime()
 {
-        time_t tRet = tNext;
-        tNext += tInterval;
-        return tRet;
+    time_t tRet = tNext;
+    tNext += tInterval;
+    return tRet;
 }
 
 Bu::MiniCron::TimerBasic::TimerBasic( const Bu::String &s ) :
-        tLast( -1 ),
-        sSpec( s )
+    tLast( -1 ),
+    sSpec( s )
 {
 }
 
@@ -314,164 +314,164 @@ Bu::MiniCron::TimerBasic::~TimerBasic()
 
 time_t Bu::MiniCron::TimerBasic::nextTime()
 {
-        if( tLast == -1 )
-                tLast = time( NULL );
-
-        Bu::String::const_iterator i = sSpec.begin();
-        switch( lex( i ) )
-        {
-                case tokDaily:
-                        {
-                                int iHour = lexInt( i );
-                                int iMin = lexInt( i );
-
-                                struct tm t;
-                                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
-                                if( iHour < t.tm_hour ||
-                                        (iHour == t.tm_hour && iMin <= t.tm_min) )
-                                {
-                                        t.tm_mday++;
-                                }
-                                t.tm_hour = iHour;
-                                t.tm_min = iMin;
-                                t.tm_sec = 0;
-                                tLast = mktime( &t );
-                        }
-                        break;
-
-                case tokHourly:
-                        {
-                                int iMin = lexInt( i );
-
-                                struct tm t;
-                                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
-                                if( iMin <= t.tm_min )
-                                        t.tm_hour++;
-                                t.tm_min = iMin;
-                                t.tm_sec = 0;
-                                tLast = mktime( &t );
-                        }
-                        break;
-
-                case tokWeekly:
-                        {
-                                int iDay = lexInt( i );
-                                int iHour = lexInt( i );
-                                int iMin = lexInt( i );
-                                
-                                struct tm t;
-                                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
-                                if( iDay < t.tm_wday || 
-                                        (iDay == t.tm_wday && iHour < t.tm_hour) ||
-                                        (iDay == t.tm_wday && iHour == t.tm_hour
-                                         && iMin <= t.tm_min) )
-                                {
-                                        if( iDay <= t.tm_wday )
-                                                t.tm_mday += 7 - (t.tm_wday-iDay);
-                                        else
-                                                t.tm_mday += 7 - (iDay-t.tm_wday);
-                                }
-                                else
-                                {
-                                        t.tm_mday += (iDay-t.tm_wday);
-                                }
-                                t.tm_hour = iHour;
-                                t.tm_min = iMin;
-                                t.tm_sec = 0;
-                                tLast = mktime( &t );
-                        }
-                        break;
-
-                case tokMonthly:
-                        break;
-
-                case tokYearly:
-                        break;
-
-                default:
-                        break;
-        }
-
-        return tLast;
+    if( tLast == -1 )
+        tLast = time( NULL );
+
+    Bu::String::const_iterator i = sSpec.begin();
+    switch( lex( i ) )
+    {
+        case tokDaily:
+            {
+                int iHour = lexInt( i );
+                int iMin = lexInt( i );
+
+                struct tm t;
+                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
+                if( iHour < t.tm_hour ||
+                    (iHour == t.tm_hour && iMin <= t.tm_min) )
+                {
+                    t.tm_mday++;
+                }
+                t.tm_hour = iHour;
+                t.tm_min = iMin;
+                t.tm_sec = 0;
+                tLast = mktime( &t );
+            }
+            break;
+
+        case tokHourly:
+            {
+                int iMin = lexInt( i );
+
+                struct tm t;
+                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
+                if( iMin <= t.tm_min )
+                    t.tm_hour++;
+                t.tm_min = iMin;
+                t.tm_sec = 0;
+                tLast = mktime( &t );
+            }
+            break;
+
+        case tokWeekly:
+            {
+                int iDay = lexInt( i );
+                int iHour = lexInt( i );
+                int iMin = lexInt( i );
+                
+                struct tm t;
+                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
+                if( iDay < t.tm_wday || 
+                    (iDay == t.tm_wday && iHour < t.tm_hour) ||
+                    (iDay == t.tm_wday && iHour == t.tm_hour
+                     && iMin <= t.tm_min) )
+                {
+                    if( iDay <= t.tm_wday )
+                        t.tm_mday += 7 - (t.tm_wday-iDay);
+                    else
+                        t.tm_mday += 7 - (iDay-t.tm_wday);
+                }
+                else
+                {
+                    t.tm_mday += (iDay-t.tm_wday);
+                }
+                t.tm_hour = iHour;
+                t.tm_min = iMin;
+                t.tm_sec = 0;
+                tLast = mktime( &t );
+            }
+            break;
+
+        case tokMonthly:
+            break;
+
+        case tokYearly:
+            break;
+
+        default:
+            break;
+    }
+
+    return tLast;
 }
 
 Bu::MiniCron::TimerBasic::Token Bu::MiniCron::TimerBasic::lex(
-                Bu::String::const_iterator &i )
-{
-        if( !i )
-        {
-                return tokEos;
-        }
-
-        Bu::String::const_iterator b = i;
-
-        for(; b && (*b == ' ' || *b == '\t'); b++ ) { i = b+1; }
-        for(; b && *b != ' ' && *b != '\t'; b++ ) { }
-
-        Bu::String sTok( i, b );
-        i = b;
-
-        if( sTok == "daily" )
-                return tokDaily;
-        else if( sTok == "hourly" )
-                return tokHourly;
-        else if( sTok == "weekly" )
-                return tokWeekly;
-        else if( sTok == "monthly" )
-                return tokMonthly;
-        else if( sTok == "yearly" )
-                return tokYearly;
-        else if( sTok == "sun" )
-        {
-                iVal = 0;
-                return valInt;
-        }
-        else if( sTok == "mon" )
-        {
-                iVal = 1;
-                return valInt;
-        }
-        else if( sTok == "tue" )
-        {
-                iVal = 2;
-                return valInt;
-        }
-        else if( sTok == "wed" )
-        {
-                iVal = 3;
-                return valInt;
-        }
-        else if( sTok == "thu" )
-        {
-                iVal = 4;
-                return valInt;
-        }
-        else if( sTok == "fri" )
-        {
-                iVal = 5;
-                return valInt;
-        }
-        else if( sTok == "sat" )
-        {
-                iVal = 6;
-                return valInt;
-        }
-        else if( sTok[0] >= '0' && sTok[0] <= '9' )
-        {
-                iVal = strtol( sTok.getStr(), NULL, 0 );
-                return valInt;
-        }
-
-        return tokErr;
+        Bu::String::const_iterator &i )
+{
+    if( !i )
+    {
+        return tokEos;
+    }
+
+    Bu::String::const_iterator b = i;
+
+    for(; b && (*b == ' ' || *b == '\t'); b++ ) { i = b+1; }
+    for(; b && *b != ' ' && *b != '\t'; b++ ) { }
+
+    Bu::String sTok( i, b );
+    i = b;
+
+    if( sTok == "daily" )
+        return tokDaily;
+    else if( sTok == "hourly" )
+        return tokHourly;
+    else if( sTok == "weekly" )
+        return tokWeekly;
+    else if( sTok == "monthly" )
+        return tokMonthly;
+    else if( sTok == "yearly" )
+        return tokYearly;
+    else if( sTok == "sun" )
+    {
+        iVal = 0;
+        return valInt;
+    }
+    else if( sTok == "mon" )
+    {
+        iVal = 1;
+        return valInt;
+    }
+    else if( sTok == "tue" )
+    {
+        iVal = 2;
+        return valInt;
+    }
+    else if( sTok == "wed" )
+    {
+        iVal = 3;
+        return valInt;
+    }
+    else if( sTok == "thu" )
+    {
+        iVal = 4;
+        return valInt;
+    }
+    else if( sTok == "fri" )
+    {
+        iVal = 5;
+        return valInt;
+    }
+    else if( sTok == "sat" )
+    {
+        iVal = 6;
+        return valInt;
+    }
+    else if( sTok[0] >= '0' && sTok[0] <= '9' )
+    {
+        iVal = strtol( sTok.getStr(), NULL, 0 );
+        return valInt;
+    }
+
+    return tokErr;
 }
 
 int Bu::MiniCron::TimerBasic::lexInt( Bu::String::const_iterator &i )
 {
-        Token t = lex( i );
-        if( t == tokEos )
-                return 0;
-        if( t != valInt )
-                throw Bu::ExceptionBase("Expected int, got something else.");
-        return iVal;
+    Token t = lex( i );
+    if( t == tokEos )
+        return 0;
+    if( t != valInt )
+        throw Bu::ExceptionBase("Expected int, got something else.");
+    return iVal;
 }
 
diff --git a/src/stable/minicron.h b/src/stable/minicron.h
index 53e5156..953b82a 100644
--- a/src/stable/minicron.h
+++ b/src/stable/minicron.h
@@ -16,321 +16,321 @@
 
 namespace Bu
 {
-        /**
-         * A simple cron like system designed to be embedded in any program.  This
-         * class creates a simple cron system that can run any number of jobs at
-         * customizable intervals or schedules.  It does not support some of the
-         * more complex scheduling that some cron systems can do such as load
-         * balancing directly, but this could be done on the job side.
-         *
-         * This system is synchronous, it does not use any threads on it's own, but
-         * it is threadsafe, so a cron thread could be created if desired.
-         *
-         * The operation is fairly simple, jobs can be added at any time, and use
-         * any timer they would like, even custom timers.  When it is time for a
-         * job to be run it signals the slot provided when the job was added.  Every
-         * job slot recieves a handle to the job object so that it may control it's
-         * own lifetime and get information about itself.  In addition, every job
-         * is assigned a unique ID that can be used to control it's operation
-         * at any time.
-         *
-         * By default a job will continually reschedule itself after being run
-         * unless it calls stop() on it's job object, it is removed using
-         * removeJob() on the cron object, or it is added with addJobOnce.
-         *
-         *@todo A minor change to the job execution system could allow a Timer to
-         * defer or reschedule execution instead of the job executing.  This would,
-         * in effect, allow us to do every type of interesting scheduling that
-         * systems like fcron offer, including time constrained load-balanced
-         * execution.
-         */
-        class MiniCron
-        {
-        public:
-                class Job;
-                class Timer;
-                typedef Bu::Signal1<void, Bu::MiniCron::Job &> CronSignal;
-                typedef int JobId;
-
-                MiniCron();
-                virtual ~MiniCron();
-
-                /**
-                 * Tells you if there are jobs registered in the MiniCron.
-                 *@returns true if there are jobs, false otherwise.
-                 */
-                virtual bool hasJobs();
-
-                /**
-                 * If there are jobs, tells you the time the next one will execute.
-                 *@returns The timestamp that the next job will execute at.
-                 */
-                virtual time_t getNextRun();
-                
-                /**
-                 * Tells you the time the job matching jid will run next.
-                 *@returns The timestamp that the job jid will next run.
-                 */
-                virtual time_t getNextRun( JobId jid );
-
-                /**
-                 * Call this regularly to execute all jobs that should be executed.
-                 * This will loop until all jobs who's run time match the current time
-                 * or are below the current time (we've missed them).
-                 * If there is nothing to run, the runtime of this funcion is constant,
-                 * it is very fast.  Otherwise it executes at log(N) per job run,
-                 * O(N*log(N)).
-                 */
-                virtual void poll();
-
-                /**
-                 * Add a job for repeated scheduling.  Pass in a slot to signal, and a
-                 * Timer object to use to do the scheduling.  This function returns a
-                 * JobId which can be used at a later time to control the execution of
-                 * the job.
-                 */
-                virtual JobId addJob( const Bu::String &sName, CronSignal sigJob,
-                                const Timer &t );
-
-                /**
-                 * Add a job for one time scheduling.  Pass in a slot to signal, and a
-                 * Timer object to use to schodule the one run of this job.  This
-                 * function returns a JobId which can be used at a later time to control
-                 * the execution of the job.
-                 */
-                virtual JobId addJobOnce( const Bu::String &sName, CronSignal sigJob,
-                                const Timer &t );
-
-                /**
-                 * Remove a job, preventing all future runs of the job.  If there is no
-                 * job matching the given JobId then nothing will happen.  However, this
-                 * function is relatively expensive compared to the others in this class
-                 * and has a worse case runtime of 2*N*log(N), still not that bad, and
-                 * a O(N*log(N)).
-                 */
-                virtual void removeJob( JobId jid );
-
-                /**
-                 * Executes the job specified right now.  If bReschedule is true then
-                 * the job is then removed from the queue and rescheduled as though
-                 * it's time had come naturally to be run.  Otherwise, it's run without
-                 * interrupting the normal schedule.
-                 */
-                virtual void runJob( JobId jid, bool bReschedule=false );
-
-                /**
-                 * Executes the job specified right now.  If bReschedule is true then
-                 * the job is then removed from the queue and rescheduled as though
-                 * it's time had come naturally to be run.  Otherwise, it's run without
-                 * interrupting the normal schedule.
-                 */
-                virtual void runJob( const Bu::String &sName, bool bReschedule=false );
-
-                class JobInfo
-                {
-                public:
-                        JobInfo( const Bu::String &sName, JobId jid, time_t tNext );
-                        virtual ~JobInfo();
-                        
-                        bool operator<( const JobInfo &rhs ) const;
-
-                        Bu::String sName;
-                        JobId jid;
-                        time_t tNext;
-                };
-                typedef Bu::List<JobInfo> JobInfoList;
-
-                JobInfoList getJobInfo();
-
-                /**
-                 * The baseclass for timer/schedulers for MiniCron jobs.  Classes that
-                 * inherit from this are used to determine when jobs will run and at
-                 * what interval.
-                 */
-                class Timer
-                {
-                public:
-                        Timer();
-                        virtual ~Timer();
-
-                        /**
-                         * Called by MiniCron when each job is run to determine the next
-                         * time that a job should be run.  When a job is run, this function
-                         * is actually called before the job is executed again so that the
-                         * job can tell when the next time it will be run will be.
-                         */
-                        virtual time_t nextTime()=0;
-
-                        /**
-                         * This function should return a copy of the child class.
-                         */
-                        virtual Timer *clone() const = 0;
-                };
-
-                /**
-                 * Execute the job every tInterval seconds, also you can delay the
-                 * first run by a different amount of time from the job's creation.
-                 */
-                class TimerInterval : public Timer
-                {
-                public:
-                        TimerInterval( time_t tFirst, time_t tInterval );
-                        virtual ~TimerInterval();
-
-                        virtual time_t nextTime();
-                        virtual Timer *clone() const
-                                { return new TimerInterval( *this ); }
-                private:
-                        time_t tNext;
-                        time_t tInterval;
-                };
-
-                /**
-                 * A much more general timer class that can be used for much more
-                 * "cron-like" functionality.  The constructor takes a string that
-                 * describes the times that the job should be run.  At the moment the
-                 * following schemes are understood:
-                 *
-                 * "daily [hour] [minute]"
-                 * "hourly [minute]"
-                 * "weekly [day] [hour] [minute]"
-                 *
-                 * In these examples each word in [brackets] represents a number that
-                 * matches the data type in the brackets.  [day] is the number of days
-                 * since sunday, 0-6.  You can also use lowercase three character
-                 * abbreviations for the day names.
-                 *
-                 * Many more forms follow.
-                 */
-                class TimerBasic : public Timer
-                {
-                public:
-                        TimerBasic( const Bu::String &s );
-                        virtual ~TimerBasic();
-
-                        virtual time_t nextTime();
-                        virtual Timer *clone() const
-                                { return new TimerBasic( *this ); }
-
-                private:
-                        enum Token
-                        {
-                                tokDaily,
-                                tokHourly,
-                                tokWeekly,
-                                tokMonthly,
-                                tokYearly,
-                                valInt,
-                                tokErr,
-                                tokEos
-                        };
-                        Token lex( Bu::String::const_iterator &i );
-                        int lexInt( Bu::String::const_iterator &i );
-                        int iVal; //< A temp variable for parsing.
-                        time_t tLast;
-                        Bu::String sSpec;
-                };
-                
-                /**
-                 * Represents a MiniCron Job.  This class is used for both internal
-                 * job management as well as job slot interaction and control.  Objects
-                 * of this class are passed into the slots that are signaled when a job
-                 * is executed.
-                 */
-                class Job
-                {
-                        friend class Bu::MiniCron;
-                private:
-                        Job( const Bu::String &sName, JobId jid, bool bRepeat=true );
-                        virtual ~Job();
-
-                public:
-
-                        /**
-                         * Execute this job once, increment the runcount and schedule the
-                         * next occurance of it.
-                         */
-                        void run( bool bReschedule=true );
-
-                        /**
-                         * Get the time this job will next run.
-                         */
-                        time_t getNextRun() const;
-
-                        /**
-                         * Compute the time this job will next run.
-                         */
-                        void calcNextRun();
-
-                        /**
-                         * Replace the current job timer with a new one, this will trigger
-                         * a re-schedule.
-                         */
-                        void setTimer( const Timer &t );
-
-                        /**
-                         * Stop execution of this job, never execute this job again.
-                         */
-                        void stop();
-
-                        /**
-                         * Undo a previous stop.  This will cause a job that has been
-                         * stopped or even added with addJobOnce to be set for repeated
-                         * scheduling.
-                         */
-                        void resume();
-
-                        /**
-                         * Get the unique ID of this job.
-                         */
-                        JobId getId() const;
-
-                        /**
-                         * Get the timestamp this job was created.
-                         */
-                        time_t getTimeCreated() const;
-
-                        /**
-                         * Get the current run count of this job, how many times it has been
-                         * executed.  This is incremented before the slot is signaled.
-                         */
-                        int getRunCount() const;
-
-                        /**
-                         * Get the next time that this job will be run.  Certain timers may
-                         * have the ability to delay job executions, so this is the earliest
-                         * time that the job may run.
-                         */
-                        time_t getNextRunTime() const;
-
-                        /**
-                         * Gets the name that was set when the job was created.
-                         */
-                        Bu::String getName() const;
-
-                private:
-                        Bu::String sName;
-                        CronSignal sigJob;
-                        time_t tNextRun;
-                        Timer *pTimer;
-                        bool bContinue;
-                        JobId jid;
-                        time_t tAdded;
-                        int iRunCount;
-                };
-
-        private:
-                struct JobPtrCmp
-                {
-                        bool operator()( const Job *pLeft, const Job *pRight )
-                        {
-                                return pLeft->tNextRun < pRight->tNextRun;
-                        }
-                };
-                typedef Bu::Heap<Job *, JobPtrCmp> JobHeap;
-                JobHeap hJobs;
-                JobId jidNext;
-        };
+    /**
+     * A simple cron like system designed to be embedded in any program.  This
+     * class creates a simple cron system that can run any number of jobs at
+     * customizable intervals or schedules.  It does not support some of the
+     * more complex scheduling that some cron systems can do such as load
+     * balancing directly, but this could be done on the job side.
+     *
+     * This system is synchronous, it does not use any threads on it's own, but
+     * it is threadsafe, so a cron thread could be created if desired.
+     *
+     * The operation is fairly simple, jobs can be added at any time, and use
+     * any timer they would like, even custom timers.  When it is time for a
+     * job to be run it signals the slot provided when the job was added.  Every
+     * job slot recieves a handle to the job object so that it may control it's
+     * own lifetime and get information about itself.  In addition, every job
+     * is assigned a unique ID that can be used to control it's operation
+     * at any time.
+     *
+     * By default a job will continually reschedule itself after being run
+     * unless it calls stop() on it's job object, it is removed using
+     * removeJob() on the cron object, or it is added with addJobOnce.
+     *
+     *@todo A minor change to the job execution system could allow a Timer to
+     * defer or reschedule execution instead of the job executing.  This would,
+     * in effect, allow us to do every type of interesting scheduling that
+     * systems like fcron offer, including time constrained load-balanced
+     * execution.
+     */
+    class MiniCron
+    {
+    public:
+        class Job;
+        class Timer;
+        typedef Bu::Signal1<void, Bu::MiniCron::Job &> CronSignal;
+        typedef int JobId;
+
+        MiniCron();
+        virtual ~MiniCron();
+
+        /**
+         * Tells you if there are jobs registered in the MiniCron.
+         *@returns true if there are jobs, false otherwise.
+         */
+        virtual bool hasJobs();
+
+        /**
+         * If there are jobs, tells you the time the next one will execute.
+         *@returns The timestamp that the next job will execute at.
+         */
+        virtual time_t getNextRun();
+        
+        /**
+         * Tells you the time the job matching jid will run next.
+         *@returns The timestamp that the job jid will next run.
+         */
+        virtual time_t getNextRun( JobId jid );
+
+        /**
+         * Call this regularly to execute all jobs that should be executed.
+         * This will loop until all jobs who's run time match the current time
+         * or are below the current time (we've missed them).
+         * If there is nothing to run, the runtime of this funcion is constant,
+         * it is very fast.  Otherwise it executes at log(N) per job run,
+         * O(N*log(N)).
+         */
+        virtual void poll();
+
+        /**
+         * Add a job for repeated scheduling.  Pass in a slot to signal, and a
+         * Timer object to use to do the scheduling.  This function returns a
+         * JobId which can be used at a later time to control the execution of
+         * the job.
+         */
+        virtual JobId addJob( const Bu::String &sName, CronSignal sigJob,
+                const Timer &t );
+
+        /**
+         * Add a job for one time scheduling.  Pass in a slot to signal, and a
+         * Timer object to use to schodule the one run of this job.  This
+         * function returns a JobId which can be used at a later time to control
+         * the execution of the job.
+         */
+        virtual JobId addJobOnce( const Bu::String &sName, CronSignal sigJob,
+                const Timer &t );
+
+        /**
+         * Remove a job, preventing all future runs of the job.  If there is no
+         * job matching the given JobId then nothing will happen.  However, this
+         * function is relatively expensive compared to the others in this class
+         * and has a worse case runtime of 2*N*log(N), still not that bad, and
+         * a O(N*log(N)).
+         */
+        virtual void removeJob( JobId jid );
+
+        /**
+         * Executes the job specified right now.  If bReschedule is true then
+         * the job is then removed from the queue and rescheduled as though
+         * it's time had come naturally to be run.  Otherwise, it's run without
+         * interrupting the normal schedule.
+         */
+        virtual void runJob( JobId jid, bool bReschedule=false );
+
+        /**
+         * Executes the job specified right now.  If bReschedule is true then
+         * the job is then removed from the queue and rescheduled as though
+         * it's time had come naturally to be run.  Otherwise, it's run without
+         * interrupting the normal schedule.
+         */
+        virtual void runJob( const Bu::String &sName, bool bReschedule=false );
+
+        class JobInfo
+        {
+        public:
+            JobInfo( const Bu::String &sName, JobId jid, time_t tNext );
+            virtual ~JobInfo();
+            
+            bool operator<( const JobInfo &rhs ) const;
+
+            Bu::String sName;
+            JobId jid;
+            time_t tNext;
+        };
+        typedef Bu::List<JobInfo> JobInfoList;
+
+        JobInfoList getJobInfo();
+
+        /**
+         * The baseclass for timer/schedulers for MiniCron jobs.  Classes that
+         * inherit from this are used to determine when jobs will run and at
+         * what interval.
+         */
+        class Timer
+        {
+        public:
+            Timer();
+            virtual ~Timer();
+
+            /**
+             * Called by MiniCron when each job is run to determine the next
+             * time that a job should be run.  When a job is run, this function
+             * is actually called before the job is executed again so that the
+             * job can tell when the next time it will be run will be.
+             */
+            virtual time_t nextTime()=0;
+
+            /**
+             * This function should return a copy of the child class.
+             */
+            virtual Timer *clone() const = 0;
+        };
+
+        /**
+         * Execute the job every tInterval seconds, also you can delay the
+         * first run by a different amount of time from the job's creation.
+         */
+        class TimerInterval : public Timer
+        {
+        public:
+            TimerInterval( time_t tFirst, time_t tInterval );
+            virtual ~TimerInterval();
+
+            virtual time_t nextTime();
+            virtual Timer *clone() const
+                { return new TimerInterval( *this ); }
+        private:
+            time_t tNext;
+            time_t tInterval;
+        };
+
+        /**
+         * A much more general timer class that can be used for much more
+         * "cron-like" functionality.  The constructor takes a string that
+         * describes the times that the job should be run.  At the moment the
+         * following schemes are understood:
+         *
+         * "daily [hour] [minute]"
+         * "hourly [minute]"
+         * "weekly [day] [hour] [minute]"
+         *
+         * In these examples each word in [brackets] represents a number that
+         * matches the data type in the brackets.  [day] is the number of days
+         * since sunday, 0-6.  You can also use lowercase three character
+         * abbreviations for the day names.
+         *
+         * Many more forms follow.
+         */
+        class TimerBasic : public Timer
+        {
+        public:
+            TimerBasic( const Bu::String &s );
+            virtual ~TimerBasic();
+
+            virtual time_t nextTime();
+            virtual Timer *clone() const
+                { return new TimerBasic( *this ); }
+
+        private:
+            enum Token
+            {
+                tokDaily,
+                tokHourly,
+                tokWeekly,
+                tokMonthly,
+                tokYearly,
+                valInt,
+                tokErr,
+                tokEos
+            };
+            Token lex( Bu::String::const_iterator &i );
+            int lexInt( Bu::String::const_iterator &i );
+            int iVal; //< A temp variable for parsing.
+            time_t tLast;
+            Bu::String sSpec;
+        };
+        
+        /**
+         * Represents a MiniCron Job.  This class is used for both internal
+         * job management as well as job slot interaction and control.  Objects
+         * of this class are passed into the slots that are signaled when a job
+         * is executed.
+         */
+        class Job
+        {
+            friend class Bu::MiniCron;
+        private:
+            Job( const Bu::String &sName, JobId jid, bool bRepeat=true );
+            virtual ~Job();
+
+        public:
+
+            /**
+             * Execute this job once, increment the runcount and schedule the
+             * next occurance of it.
+             */
+            void run( bool bReschedule=true );
+
+            /**
+             * Get the time this job will next run.
+             */
+            time_t getNextRun() const;
+
+            /**
+             * Compute the time this job will next run.
+             */
+            void calcNextRun();
+
+            /**
+             * Replace the current job timer with a new one, this will trigger
+             * a re-schedule.
+             */
+            void setTimer( const Timer &t );
+
+            /**
+             * Stop execution of this job, never execute this job again.
+             */
+            void stop();
+
+            /**
+             * Undo a previous stop.  This will cause a job that has been
+             * stopped or even added with addJobOnce to be set for repeated
+             * scheduling.
+             */
+            void resume();
+
+            /**
+             * Get the unique ID of this job.
+             */
+            JobId getId() const;
+
+            /**
+             * Get the timestamp this job was created.
+             */
+            time_t getTimeCreated() const;
+
+            /**
+             * Get the current run count of this job, how many times it has been
+             * executed.  This is incremented before the slot is signaled.
+             */
+            int getRunCount() const;
+
+            /**
+             * Get the next time that this job will be run.  Certain timers may
+             * have the ability to delay job executions, so this is the earliest
+             * time that the job may run.
+             */
+            time_t getNextRunTime() const;
+
+            /**
+             * Gets the name that was set when the job was created.
+             */
+            Bu::String getName() const;
+
+        private:
+            Bu::String sName;
+            CronSignal sigJob;
+            time_t tNextRun;
+            Timer *pTimer;
+            bool bContinue;
+            JobId jid;
+            time_t tAdded;
+            int iRunCount;
+        };
+
+    private:
+        struct JobPtrCmp
+        {
+            bool operator()( const Job *pLeft, const Job *pRight )
+            {
+                return pLeft->tNextRun < pRight->tNextRun;
+            }
+        };
+        typedef Bu::Heap<Job *, JobPtrCmp> JobHeap;
+        JobHeap hJobs;
+        JobId jidNext;
+    };
 };
 
 #endif
diff --git a/src/stable/multiserver.cpp b/src/stable/multiserver.cpp
index 8856117..bb1cacc 100644
--- a/src/stable/multiserver.cpp
+++ b/src/stable/multiserver.cpp
@@ -20,36 +20,36 @@ Bu::MultiServer::~MultiServer()
 }
 
 void Bu::MultiServer::addProtocol( Bu::Protocol *(*proc)(), int iPort,
-        int nPoolSize )
+    int nPoolSize )
 {
-        hProtos[iPort] = proc;
-        addPort( iPort, nPoolSize );
+    hProtos[iPort] = proc;
+    addPort( iPort, nPoolSize );
 }
 
 void Bu::MultiServer::addProtocol( Protocol *(*proc)(), const String &sAddr,
-        int iPort, int nPoolSize )
+    int iPort, int nPoolSize )
 {
-        hProtos[iPort] = proc;
-        addPort( sAddr, iPort, nPoolSize );
+    hProtos[iPort] = proc;
+    addPort( sAddr, iPort, nPoolSize );
 }
 
 void Bu::MultiServer::onNewConnection( Bu::Client *pClient, int nPort )
 {
-        pClient->setProtocol( hProtos.get( nPort )() );
+    pClient->setProtocol( hProtos.get( nPort )() );
 }
 
 void Bu::MultiServer::onClosedConnection( Bu::Client *pClient )
 {
-        delete pClient->getProtocol();
+    delete pClient->getProtocol();
 }
 
 void Bu::MultiServer::shutdown()
 {
-        Bu::Server::shutdown();
+    Bu::Server::shutdown();
 }
 
 void Bu::MultiServer::tick()
 {
-        Bu::Server::tick();
+    Bu::Server::tick();
 }
 
diff --git a/src/stable/multiserver.h b/src/stable/multiserver.h
index b2f633a..8a49bbd 100644
--- a/src/stable/multiserver.h
+++ b/src/stable/multiserver.h
@@ -13,45 +13,45 @@
 
 namespace Bu
 {
-        class Protocol;
-        class Client;
-
-        template<class T>
-        Protocol *genProtocol()
-        {
-                return new T;
-        }
-
-        class MultiServer : protected Server
-        {
-        public:
-                MultiServer();
-                virtual ~MultiServer();
-
-                void addProtocol( Protocol *(*proc)(), int iPort, int nPoolSize=40 );
-                void addProtocol( Protocol *(*proc)(), const String &sAddr, int iPort,
-                                int nPoolSize=40 );
-                
-                void scan()
-                {
-                        Server::scan();
-                }
-
-                void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 )
-                {
-                        Server::setTimeout( nTimeoutSec, nTimeoutUSec );
-                }
-
-                virtual void onNewConnection( Client *pClient, int nPort );
-                virtual void onClosedConnection( Client *pClient );
-
-                void shutdown();
-
-                void tick();
-
-        private:
-                Bu::Hash<int, Protocol *(*)()> hProtos;
-        };
+    class Protocol;
+    class Client;
+
+    template<class T>
+    Protocol *genProtocol()
+    {
+        return new T;
+    }
+
+    class MultiServer : protected Server
+    {
+    public:
+        MultiServer();
+        virtual ~MultiServer();
+
+        void addProtocol( Protocol *(*proc)(), int iPort, int nPoolSize=40 );
+        void addProtocol( Protocol *(*proc)(), const String &sAddr, int iPort,
+                int nPoolSize=40 );
+        
+        void scan()
+        {
+            Server::scan();
+        }
+
+        void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 )
+        {
+            Server::setTimeout( nTimeoutSec, nTimeoutUSec );
+        }
+
+        virtual void onNewConnection( Client *pClient, int nPort );
+        virtual void onClosedConnection( Client *pClient );
+
+        void shutdown();
+
+        void tick();
+
+    private:
+        Bu::Hash<int, Protocol *(*)()> hProtos;
+    };
 }
 
 #endif
diff --git a/src/stable/mutex.cpp b/src/stable/mutex.cpp
index 947364c..0391d7a 100644
--- a/src/stable/mutex.cpp
+++ b/src/stable/mutex.cpp
@@ -9,26 +9,26 @@
 
 Bu::Mutex::Mutex()
 {
-        pthread_mutex_init( &mutex, NULL );
+    pthread_mutex_init( &mutex, NULL );
 }
 
 Bu::Mutex::~Mutex()
 {
-        pthread_mutex_destroy( &mutex );
+    pthread_mutex_destroy( &mutex );
 }
 
 int Bu::Mutex::lock()
 {
-        return pthread_mutex_lock( &mutex );
+    return pthread_mutex_lock( &mutex );
 }
 
 int Bu::Mutex::unlock()
 {
-        return pthread_mutex_unlock( &mutex );
+    return pthread_mutex_unlock( &mutex );
 }
 
 int Bu::Mutex::trylock()
 {
-        return pthread_mutex_trylock( &mutex );
+    return pthread_mutex_trylock( &mutex );
 }
 
diff --git a/src/stable/mutex.h b/src/stable/mutex.h
index 1898118..23963e3 100644
--- a/src/stable/mutex.h
+++ b/src/stable/mutex.h
@@ -12,57 +12,57 @@
 
 namespace Bu
 {
-        /**
-         * Simple mutex wrapper.  Currently this doesn't do anything extra for you
-         * except keep all of the functionality together in an OO sorta' way and
-         * keep you from having to worry about cleaning up your mutexes properly,
-         * or initing them.
-         *@ingroup Threading
-         */
-        class Mutex
-        {
-        public:
-                /**
-                 * Create an unlocked mutex.
-                 */
-                Mutex();
-                
-                /**
-                 * Destroy a mutex.  This can only be done when a mutex is unlocked.
-                 * Failure to unlock before destroying a mutex object could cause it to
-                 * wait for the mutex to unlock, the odds of which are usually farily
-                 * low at deconstruction time.
-                 */
-                ~Mutex();
+    /**
+     * Simple mutex wrapper.  Currently this doesn't do anything extra for you
+     * except keep all of the functionality together in an OO sorta' way and
+     * keep you from having to worry about cleaning up your mutexes properly,
+     * or initing them.
+     *@ingroup Threading
+     */
+    class Mutex
+    {
+    public:
+        /**
+         * Create an unlocked mutex.
+         */
+        Mutex();
+        
+        /**
+         * Destroy a mutex.  This can only be done when a mutex is unlocked.
+         * Failure to unlock before destroying a mutex object could cause it to
+         * wait for the mutex to unlock, the odds of which are usually farily
+         * low at deconstruction time.
+         */
+        ~Mutex();
 
-                /**
-                 * Lock the mutex.  This causes all future calls to lock on this
-                 * instance of mutex to block until the first thread that called mutex
-                 * unlocks it.  At that point the next thread that called lock will get
-                 * a chance to go to work.  Because of the nature of a mutex lock it is
-                 * a very bad idea to do any kind of serious or rather time consuming
-                 * computation within a locked section.  This can cause thread-deadlock
-                 * and your program may hang.
-                 */
-                int lock();
+        /**
+         * Lock the mutex.  This causes all future calls to lock on this
+         * instance of mutex to block until the first thread that called mutex
+         * unlocks it.  At that point the next thread that called lock will get
+         * a chance to go to work.  Because of the nature of a mutex lock it is
+         * a very bad idea to do any kind of serious or rather time consuming
+         * computation within a locked section.  This can cause thread-deadlock
+         * and your program may hang.
+         */
+        int lock();
 
-                /**
-                 * Unlock the mutex.  This allows the next thread that asked for a lock
-                 * to lock the mutex and continue with execution.
-                 */
-                int unlock();
+        /**
+         * Unlock the mutex.  This allows the next thread that asked for a lock
+         * to lock the mutex and continue with execution.
+         */
+        int unlock();
 
-                /**
-                 * Try to lock the mutex.  This is the option to go with if you cannot
-                 * avoid putting lengthy operations within a locked section.  trylock
-                 * will attempt to lock the mutex, if the mutex is already locked this
-                 * function returns immediately with an error code.
-                 */
-                int trylock();
+        /**
+         * Try to lock the mutex.  This is the option to go with if you cannot
+         * avoid putting lengthy operations within a locked section.  trylock
+         * will attempt to lock the mutex, if the mutex is already locked this
+         * function returns immediately with an error code.
+         */
+        int trylock();
 
-        protected:
-                pthread_mutex_t mutex;  /**< The internal mutex reference. */
-        };
+    protected:
+        pthread_mutex_t mutex;  /**< The internal mutex reference. */
+    };
 }
 
 #endif
diff --git a/src/stable/mutexlocker.cpp b/src/stable/mutexlocker.cpp
index 90b730e..c8465a3 100644
--- a/src/stable/mutexlocker.cpp
+++ b/src/stable/mutexlocker.cpp
@@ -2,23 +2,23 @@
 #include "bu/mutex.h"
 
 Bu::MutexLocker::MutexLocker( Bu::Mutex &mu ) :
-        mu( mu )
+    mu( mu )
 {
-        mu.lock();
+    mu.lock();
 }
 
 Bu::MutexLocker::~MutexLocker()
 {
-        mu.unlock();
+    mu.unlock();
 }
 
 void Bu::MutexLocker::unlock()
 {
-        mu.unlock();
+    mu.unlock();
 }
 
 void Bu::MutexLocker::relock()
 {
-        mu.lock();
+    mu.lock();
 }
 
diff --git a/src/stable/mutexlocker.h b/src/stable/mutexlocker.h
index 7c3c97e..30e71e6 100644
--- a/src/stable/mutexlocker.h
+++ b/src/stable/mutexlocker.h
@@ -3,19 +3,19 @@
 
 namespace Bu
 {
-        class Mutex;
-        class MutexLocker
-        {
-        public:
-                MutexLocker( Mutex &mu );
-                virtual ~MutexLocker();
+    class Mutex;
+    class MutexLocker
+    {
+    public:
+        MutexLocker( Mutex &mu );
+        virtual ~MutexLocker();
 
-                void unlock();
-                void relock();
+        void unlock();
+        void relock();
 
-        private:
-                Mutex &mu;
-        };
+    private:
+        Mutex &mu;
+    };
 };
 
 #endif
diff --git a/src/stable/myriad.cpp b/src/stable/myriad.cpp
index 4be82f0..2a6a725 100644
--- a/src/stable/myriad.cpp
+++ b/src/stable/myriad.cpp
@@ -16,720 +16,720 @@
 using Bu::sio;
 using Bu::Fmt;
 
-#define Myriad_MAGIC_CODE               ((unsigned char *)"\x0a\xd3\xfa\x84")
+#define Myriad_MAGIC_CODE       ((unsigned char *)"\x0a\xd3\xfa\x84")
 
 namespace Bu
 {
-        subExceptionDef( MyriadException )
-        template<typename t> t blkDiv( t total, t block ) {
-                return (total/block)+((total%block==0)?(0):(1));
-        }
+    subExceptionDef( MyriadException )
+    template<typename t> t blkDiv( t total, t block ) {
+        return (total/block)+((total%block==0)?(0):(1));
+    }
 }
 
 Bu::Myriad::Myriad( Bu::Stream &sStore, int iBlockSize, int iPreallocate ) :
-        sStore( sStore ),
-        iBlockSize( iBlockSize ),
-        iBlocks( 0 ),
-        iUsed( 0 ),
-        bHeaderChanged( false )
-{
-        try
-        {
-                initialize();
-        }
-        catch( Bu::MyriadException &e )
-        {
-                if( e.getErrorCode() == MyriadException::emptyStream )
-                {
-                        initialize( iBlockSize, iPreallocate );
-                }
-                else
-                {
-                        throw;
-                }
-        }
+    sStore( sStore ),
+    iBlockSize( iBlockSize ),
+    iBlocks( 0 ),
+    iUsed( 0 ),
+    bHeaderChanged( false )
+{
+    try
+    {
+        initialize();
+    }
+    catch( Bu::MyriadException &e )
+    {
+        if( e.getErrorCode() == MyriadException::emptyStream )
+        {
+            initialize( iBlockSize, iPreallocate );
+        }
+        else
+        {
+            throw;
+        }
+    }
 }
 
 Bu::Myriad::~Myriad()
 {
-        mActiveBlocks.lock();
-        if( !hActiveBlocks.isEmpty() )
-        {
-                sio << "Bu::Myriad::~Myriad(): Error: There are "
-                        << hActiveBlocks.getSize() << " unsynced blocks!" << sio.nl;
-        }
-        mActiveBlocks.unlock();
-        sync();
+    mActiveBlocks.lock();
+    if( !hActiveBlocks.isEmpty() )
+    {
+        sio << "Bu::Myriad::~Myriad(): Error: There are "
+            << hActiveBlocks.getSize() << " unsynced blocks!" << sio.nl;
+    }
+    mActiveBlocks.unlock();
+    sync();
 
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                delete *i;
-        }
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        delete *i;
+    }
 }
 
 void Bu::Myriad::sync()
 {
-        updateHeader();
+    updateHeader();
 
-        mActiveBlocks.lock();
-        for( BlockHash::iterator i = hActiveBlocks.begin(); i; i++ )
-        {
-                if( (*i)->bChanged )
-                {
-                        syncBlock( *i );
-                }
-        }
-        mActiveBlocks.unlock();
+    mActiveBlocks.lock();
+    for( BlockHash::iterator i = hActiveBlocks.begin(); i; i++ )
+    {
+        if( (*i)->bChanged )
+        {
+            syncBlock( *i );
+        }
+    }
+    mActiveBlocks.unlock();
 }
 
 void Bu::Myriad::initialize()
 {
-        MutexLocker mLock( mHeader );
-        lFreeBlocks.clear();
-        sStore.setPosEnd( 0 );
-        Bu::size iSize = sStore.tell();
-        sStore.setPos( 0 );
-
-        unsigned char buf[4];
-        if( sStore.read( buf, 4 ) < 4 )
-                throw MyriadException( MyriadException::emptyStream,
-                                "Input stream appears to be empty.");
-        if( memcmp( buf, Myriad_MAGIC_CODE, 4 ) )
-        {
-                throw MyriadException( MyriadException::invalidFormat,
-                        "Stream does not appear to be a valid Myriad format.");
-        }
-        sStore.read( buf, 2 );
-        if( buf[0] != 1 )
-                throw MyriadException( MyriadException::badVersion,
-                        "We can only handle version 1 for now.");
-        if( buf[1] != 32 )
-                throw MyriadException( MyriadException::invalidWordSize,
-                        "We can only handle 32-bit words at the moment.");
-        sStore.read( &iBlockSize, 4 );
-        int iStreams;
-        sStore.read( &iStreams, 4 );
-
-        iBlocks = iSize/iBlockSize;
-        //sio << "Myriad: iSize=" << iSize << ", iBlockSize=" << iBlockSize
-        //      << ", iBlocks=" << iBlocks << ", iStreams=" << iStreams << sio.nl;
-
-        int iHeaderSize = 14 + 8 + 4;
-        int iHeaderBlocks = 0; //blkDiv( iHeaderSize+4, iBlockSize );
-
-        while( iHeaderSize > iHeaderBlocks*iBlockSize )
-        {
-                iHeaderBlocks = blkDiv( iHeaderSize+4, iBlockSize );
-                iHeaderSize = 14 + 8 + 4*iHeaderBlocks;
-        }
-
-        //sio << "Myriad: iHeaderSize=" << iHeaderSize
-        //      << ", iHeaderBlocks=" << iHeaderBlocks << sio.nl;
-
-        Stream *pFakeHdr = new Stream;
-        pFakeHdr->iId = 0;
-        pFakeHdr->iSize = iHeaderSize;
-        for( int j = 0; j < iHeaderBlocks; j++ )
-        {
-                pFakeHdr->aBlocks.append( j );
-        }
-
-//      sio << "Blocks: " << iBlocks << " (size = " << iSize << "/" << iBlockSize
-//              << ")" << sio.nl;
-        Bu::BitString bsBlockUsed( iBlocks, false );
-        bsBlockUsed.clear();
-
-//      bool bCanSkip = false; // Can skip around, post initial header stream i/o
-        MyriadStream *pIn = new MyriadStream( *this, pFakeHdr );
-        pIn->setPos( sStore.tell() );
-        for( int j = 0; j < iStreams; j++ )
-        {
-                aStreams.append( new Stream() );
-                Stream &s = *aStreams[j];
-                pIn->read( &s.iId, 4 );
-                pIn->read( &s.iSize, 4 );
-                int iSBlocks = blkDiv(s.iSize, iBlockSize);
-        //      sio << "Myriad: - Stream::iId=" << s.iId
-        //              << ", Stream::iSize=" << s.iSize
-        //              << ", Stream::aBlocks=" << iSBlocks
-        //              << ", pIn->tell()=" << pIn->tell() << sio.nl;
-                for( int k = 0; k < iSBlocks; k++ )
-                {
-                        int iBId;
-                        pIn->read( &iBId, 4 );
-        //              sio << "Myriad:   - iBId=" << iBId
-        //                      << ", iStartPos=" << iBId*iBlockSize
-        //                      << ", pIn->tell()=" << pIn->tell() << sio.nl;
-                        s.aBlocks.append( iBId );
-                        bsBlockUsed.setBit( iBId );
-                        iUsed++;
-                        if( (j == 0 && k == iHeaderBlocks-1) )
-                        {
-        //                      sio << "Myriad:   - End of prepartition, unlocking skipping."
-        //                              << sio.nl;
-//                              bCanSkip = true;
-                                MyriadStream *pTmp = new MyriadStream( *this, aStreams[0] );
-        //                      sio << "Myriad    - Position = " << pIn->tell() << sio.nl;
-                                pTmp->setPos( pIn->tell() );
-                                delete pIn;
-                                delete pFakeHdr;
-                                pIn = pTmp;
-                        }
-                }
-        }
-        delete pIn;
-
-        for( int j = 0; j < iBlocks; j++ )
-        {
-                if( bsBlockUsed.getBit( j ) == false )
-                {
-//                      sio << "Preinitialized block " << j << " is free." << sio.nl;
-                        lFreeBlocks.append( j );
-                }
-        }
-//      sio << "Myriad: Blocks used: " << bsBlockUsed.toString() << sio.nl;
+    MutexLocker mLock( mHeader );
+    lFreeBlocks.clear();
+    sStore.setPosEnd( 0 );
+    Bu::size iSize = sStore.tell();
+    sStore.setPos( 0 );
+
+    unsigned char buf[4];
+    if( sStore.read( buf, 4 ) < 4 )
+        throw MyriadException( MyriadException::emptyStream,
+                "Input stream appears to be empty.");
+    if( memcmp( buf, Myriad_MAGIC_CODE, 4 ) )
+    {
+        throw MyriadException( MyriadException::invalidFormat,
+            "Stream does not appear to be a valid Myriad format.");
+    }
+    sStore.read( buf, 2 );
+    if( buf[0] != 1 )
+        throw MyriadException( MyriadException::badVersion,
+            "We can only handle version 1 for now.");
+    if( buf[1] != 32 )
+        throw MyriadException( MyriadException::invalidWordSize,
+            "We can only handle 32-bit words at the moment.");
+    sStore.read( &iBlockSize, 4 );
+    int iStreams;
+    sStore.read( &iStreams, 4 );
+
+    iBlocks = iSize/iBlockSize;
+    //sio << "Myriad: iSize=" << iSize << ", iBlockSize=" << iBlockSize
+    //  << ", iBlocks=" << iBlocks << ", iStreams=" << iStreams << sio.nl;
+
+    int iHeaderSize = 14 + 8 + 4;
+    int iHeaderBlocks = 0; //blkDiv( iHeaderSize+4, iBlockSize );
+
+    while( iHeaderSize > iHeaderBlocks*iBlockSize )
+    {
+        iHeaderBlocks = blkDiv( iHeaderSize+4, iBlockSize );
+        iHeaderSize = 14 + 8 + 4*iHeaderBlocks;
+    }
+
+    //sio << "Myriad: iHeaderSize=" << iHeaderSize
+    //  << ", iHeaderBlocks=" << iHeaderBlocks << sio.nl;
+
+    Stream *pFakeHdr = new Stream;
+    pFakeHdr->iId = 0;
+    pFakeHdr->iSize = iHeaderSize;
+    for( int j = 0; j < iHeaderBlocks; j++ )
+    {
+        pFakeHdr->aBlocks.append( j );
+    }
+
+//  sio << "Blocks: " << iBlocks << " (size = " << iSize << "/" << iBlockSize
+//      << ")" << sio.nl;
+    Bu::BitString bsBlockUsed( iBlocks, false );
+    bsBlockUsed.clear();
+
+//  bool bCanSkip = false; // Can skip around, post initial header stream i/o
+    MyriadStream *pIn = new MyriadStream( *this, pFakeHdr );
+    pIn->setPos( sStore.tell() );
+    for( int j = 0; j < iStreams; j++ )
+    {
+        aStreams.append( new Stream() );
+        Stream &s = *aStreams[j];
+        pIn->read( &s.iId, 4 );
+        pIn->read( &s.iSize, 4 );
+        int iSBlocks = blkDiv(s.iSize, iBlockSize);
+    //  sio << "Myriad: - Stream::iId=" << s.iId
+    //      << ", Stream::iSize=" << s.iSize
+    //      << ", Stream::aBlocks=" << iSBlocks
+    //      << ", pIn->tell()=" << pIn->tell() << sio.nl;
+        for( int k = 0; k < iSBlocks; k++ )
+        {
+            int iBId;
+            pIn->read( &iBId, 4 );
+    //      sio << "Myriad:   - iBId=" << iBId
+    //          << ", iStartPos=" << iBId*iBlockSize
+    //          << ", pIn->tell()=" << pIn->tell() << sio.nl;
+            s.aBlocks.append( iBId );
+            bsBlockUsed.setBit( iBId );
+            iUsed++;
+            if( (j == 0 && k == iHeaderBlocks-1) )
+            {
+    //          sio << "Myriad:   - End of prepartition, unlocking skipping."
+    //              << sio.nl;
+//              bCanSkip = true;
+                MyriadStream *pTmp = new MyriadStream( *this, aStreams[0] );
+    //          sio << "Myriad    - Position = " << pIn->tell() << sio.nl;
+                pTmp->setPos( pIn->tell() );
+                delete pIn;
+                delete pFakeHdr;
+                pIn = pTmp;
+            }
+        }
+    }
+    delete pIn;
+
+    for( int j = 0; j < iBlocks; j++ )
+    {
+        if( bsBlockUsed.getBit( j ) == false )
+        {
+//          sio << "Preinitialized block " << j << " is free." << sio.nl;
+            lFreeBlocks.append( j );
+        }
+    }
+//  sio << "Myriad: Blocks used: " << bsBlockUsed.toString() << sio.nl;
 }
 
 void Bu::Myriad::initialize( int iBlockSize, int iPreAllocate )
 {
-        MutexLocker mLock( mHeader );
-        lFreeBlocks.clear();
-
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                delete *i;
-        }
-        aStreams.clear();
-        iUsed = 0;
-
-        int iHeaderSize = 14 + 8 + 4;
-        int iHeaderBlocks = 0; //blkDiv( iHeaderSize+4, iBlockSize );
-        char cBuf = 1;
-        int iBuf = 0;
-        
-        Stream *pStr = new Stream;
-        pStr->iId = 0;
-
-        while( iHeaderSize > iHeaderBlocks*iBlockSize )
-        {
-                iHeaderBlocks = blkDiv( iHeaderSize+4, iBlockSize );
-                iHeaderSize = 14 + 8 + 4*iHeaderBlocks;
-        }
-
-        iPreAllocate += iHeaderBlocks;
-
-        //sio << "Myriad: iHeaderSize=" << iHeaderSize << ", iBlockSize="
-        //      << iBlockSize << ", iHeaderBlocks=" << iHeaderBlocks << sio.nl;
-        
-//      bsBlockUsed.setSize( iPreAllocate, true );
-        iUsed++;
-
-        char *pBlock = new char[iBlockSize];
-        memset( pBlock, 0, iBlockSize );
-        for( int j = 0; j < iPreAllocate; j++ )
-        {
-                sStore.write( pBlock, iBlockSize );
-        }
-        delete[] (char *)pBlock;
-
-        sStore.setPos( 0 );
-
-        // Magic number
-        sStore.write( Myriad_MAGIC_CODE, 4 );
-
-        // Version (0)
-        sStore.write( &cBuf, 1 );
-
-        // Bits per int
-        cBuf = 32;
-        sStore.write( &cBuf, 1 );
-
-        // The size of each block
-        sStore.write( &iBlockSize, 4 );
-
-        iBuf = 1;
-        // The number of streams
-        sStore.write( &iBuf, 4 );
-        
-        // Stream header
-        iBuf = 0;
-        sStore.write( &iBuf, 4 );
-        sStore.write( &iHeaderSize, 4 );
-        for( iBuf = 0; iBuf < iHeaderBlocks; iBuf++ )
-        {
-                sStore.write( &iBuf, 4 );
-        }
-
-        this->iBlockSize = iBlockSize;
-        this->iBlocks = iPreAllocate;
-        
-        pStr->iSize = sStore.tell();
-//      sio << "Myriad: Actual end of header stream = " << pStr->iSize << sio.nl;
-
-        pStr->iSize = iHeaderSize;
-        for( int j = 0; j < iHeaderBlocks; j++ )
-        {
-//              sio << "Started block " << j << " is header." << sio.nl;
-                pStr->aBlocks.append( j );
-//              bsBlockUsed.setBit( j );
-                iUsed++;
-        }
-        for( int j = iHeaderBlocks; j < this->iBlocks; j++ )
-        {
-//              sio << "Started block " << j << " is free." << sio.nl;
-                lFreeBlocks.append( j );
-        }
-
-        aStreams.append( pStr );
-
-        //sio << bsBlockUsed.toString() << " - " << pStr->aBlocks << sio.nl;
-
-        bHeaderChanged = true;
-        //hStreams.insert( 0, BlockArray( 0 ) );
+    MutexLocker mLock( mHeader );
+    lFreeBlocks.clear();
+
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        delete *i;
+    }
+    aStreams.clear();
+    iUsed = 0;
+
+    int iHeaderSize = 14 + 8 + 4;
+    int iHeaderBlocks = 0; //blkDiv( iHeaderSize+4, iBlockSize );
+    char cBuf = 1;
+    int iBuf = 0;
+    
+    Stream *pStr = new Stream;
+    pStr->iId = 0;
+
+    while( iHeaderSize > iHeaderBlocks*iBlockSize )
+    {
+        iHeaderBlocks = blkDiv( iHeaderSize+4, iBlockSize );
+        iHeaderSize = 14 + 8 + 4*iHeaderBlocks;
+    }
+
+    iPreAllocate += iHeaderBlocks;
+
+    //sio << "Myriad: iHeaderSize=" << iHeaderSize << ", iBlockSize="
+    //  << iBlockSize << ", iHeaderBlocks=" << iHeaderBlocks << sio.nl;
+    
+//  bsBlockUsed.setSize( iPreAllocate, true );
+    iUsed++;
+
+    char *pBlock = new char[iBlockSize];
+    memset( pBlock, 0, iBlockSize );
+    for( int j = 0; j < iPreAllocate; j++ )
+    {
+        sStore.write( pBlock, iBlockSize );
+    }
+    delete[] (char *)pBlock;
+
+    sStore.setPos( 0 );
+
+    // Magic number
+    sStore.write( Myriad_MAGIC_CODE, 4 );
+
+    // Version (0)
+    sStore.write( &cBuf, 1 );
+
+    // Bits per int
+    cBuf = 32;
+    sStore.write( &cBuf, 1 );
+
+    // The size of each block
+    sStore.write( &iBlockSize, 4 );
+
+    iBuf = 1;
+    // The number of streams
+    sStore.write( &iBuf, 4 );
+    
+    // Stream header
+    iBuf = 0;
+    sStore.write( &iBuf, 4 );
+    sStore.write( &iHeaderSize, 4 );
+    for( iBuf = 0; iBuf < iHeaderBlocks; iBuf++ )
+    {
+        sStore.write( &iBuf, 4 );
+    }
+
+    this->iBlockSize = iBlockSize;
+    this->iBlocks = iPreAllocate;
+    
+    pStr->iSize = sStore.tell();
+//  sio << "Myriad: Actual end of header stream = " << pStr->iSize << sio.nl;
+
+    pStr->iSize = iHeaderSize;
+    for( int j = 0; j < iHeaderBlocks; j++ )
+    {
+//      sio << "Started block " << j << " is header." << sio.nl;
+        pStr->aBlocks.append( j );
+//      bsBlockUsed.setBit( j );
+        iUsed++;
+    }
+    for( int j = iHeaderBlocks; j < this->iBlocks; j++ )
+    {
+//      sio << "Started block " << j << " is free." << sio.nl;
+        lFreeBlocks.append( j );
+    }
+
+    aStreams.append( pStr );
+
+    //sio << bsBlockUsed.toString() << " - " << pStr->aBlocks << sio.nl;
+
+    bHeaderChanged = true;
+    //hStreams.insert( 0, BlockArray( 0 ) );
 }
 
 void Bu::Myriad::updateHeader()
 {
-        MutexLocker mLock( mHeader );
-
-        if( bHeaderChanged == false )
-                return;
-        if( !sStore.canWrite() )
-                return;
-
-        char cBuf;
-        int iBuf;
-
-        //for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        //{
-        //      sio << "Myriad: Stream " << Fmt(4) << (*i)->iId << ": " << (*i)->aBlocks << sio.nl;
-        //}
-
-        // Compute the new size of the header.
-        int iHeaderSize = 14 + 8*aStreams.getSize();
-//      sio << "Myriad: updateHeader: aStreams.getSize() = " << aStreams.getSize()
-//              << sio.nl;
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                iHeaderSize += 4*(*i)->aBlocks.getSize();
-//              sio << "Myriad: updateHeader: (*i)->aBlocks.getSize() = "
-//                      << (*i)->aBlocks.getSize() << sio.nl;
-        }
-        int iNewBlocks = blkDiv( iHeaderSize, iBlockSize );
-        while( iNewBlocks > aStreams[0]->aBlocks.getSize() )
-        {
-                int iBlock = findEmptyBlock();
-//              sio << "Myriad: updateHeader: Appending block " << iBlock
-//                      << " to header." << sio.nl;
-                aStreams[0]->aBlocks.append( iBlock );
-//              bsBlockUsed.setBit( iBlock );
-                iUsed++;
-                iHeaderSize += 4;
-                iNewBlocks = blkDiv( iHeaderSize, iBlockSize );
-        }
-        aStreams[0]->iSize = iHeaderSize;
-//      sio << "Myriad: updateHeader: iHeaderSize=" << iHeaderSize
-//              << ", iNewBlocks=" << iNewBlocks << ", curBlocks="
-//              << aStreams[0]->aBlocks.getSize() << sio.nl;
-
-        MyriadStream sHdr( *this, aStreams[0] );
-        sHdr.write( Myriad_MAGIC_CODE, 4 );
-
-        // Version (1)
-        cBuf = 1;
-        sHdr.write( &cBuf, 1 );
-
-        // Bits per int
-        cBuf = 32;
-        sHdr.write( &cBuf, 1 );
-
-        // The size of each block
-        sHdr.write( &iBlockSize, 4 );
-
-        iBuf = aStreams.getSize();
-        // The number of streams
-        sHdr.write( &iBuf, 4 );
-        
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                sHdr.write( &(*i)->iId, 4 );
-                sHdr.write( &(*i)->iSize, 4 );
-                int iUsedBlocks = blkDiv( (*i)->iSize, iBlockSize );
-//              for( BlockArray::iterator j = (*i)->aBlocks.begin(); j; j++ )
-                for( int j = 0; j < iUsedBlocks; j++ )
-                {
-                        sHdr.write( &(*i)->aBlocks[j], 4 );
-                }
-        }
-        
-        bHeaderChanged = false;
+    MutexLocker mLock( mHeader );
+
+    if( bHeaderChanged == false )
+        return;
+    if( !sStore.canWrite() )
+        return;
+
+    char cBuf;
+    int iBuf;
+
+    //for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    //{
+    //  sio << "Myriad: Stream " << Fmt(4) << (*i)->iId << ": " << (*i)->aBlocks << sio.nl;
+    //}
+
+    // Compute the new size of the header.
+    int iHeaderSize = 14 + 8*aStreams.getSize();
+//  sio << "Myriad: updateHeader: aStreams.getSize() = " << aStreams.getSize()
+//      << sio.nl;
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        iHeaderSize += 4*(*i)->aBlocks.getSize();
+//      sio << "Myriad: updateHeader: (*i)->aBlocks.getSize() = "
+//          << (*i)->aBlocks.getSize() << sio.nl;
+    }
+    int iNewBlocks = blkDiv( iHeaderSize, iBlockSize );
+    while( iNewBlocks > aStreams[0]->aBlocks.getSize() )
+    {
+        int iBlock = findEmptyBlock();
+//      sio << "Myriad: updateHeader: Appending block " << iBlock
+//          << " to header." << sio.nl;
+        aStreams[0]->aBlocks.append( iBlock );
+//      bsBlockUsed.setBit( iBlock );
+        iUsed++;
+        iHeaderSize += 4;
+        iNewBlocks = blkDiv( iHeaderSize, iBlockSize );
+    }
+    aStreams[0]->iSize = iHeaderSize;
+//  sio << "Myriad: updateHeader: iHeaderSize=" << iHeaderSize
+//      << ", iNewBlocks=" << iNewBlocks << ", curBlocks="
+//      << aStreams[0]->aBlocks.getSize() << sio.nl;
+
+    MyriadStream sHdr( *this, aStreams[0] );
+    sHdr.write( Myriad_MAGIC_CODE, 4 );
+
+    // Version (1)
+    cBuf = 1;
+    sHdr.write( &cBuf, 1 );
+
+    // Bits per int
+    cBuf = 32;
+    sHdr.write( &cBuf, 1 );
+
+    // The size of each block
+    sHdr.write( &iBlockSize, 4 );
+
+    iBuf = aStreams.getSize();
+    // The number of streams
+    sHdr.write( &iBuf, 4 );
+    
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        sHdr.write( &(*i)->iId, 4 );
+        sHdr.write( &(*i)->iSize, 4 );
+        int iUsedBlocks = blkDiv( (*i)->iSize, iBlockSize );
+//      for( BlockArray::iterator j = (*i)->aBlocks.begin(); j; j++ )
+        for( int j = 0; j < iUsedBlocks; j++ )
+        {
+            sHdr.write( &(*i)->aBlocks[j], 4 );
+        }
+    }
+    
+    bHeaderChanged = false;
 }
 
 int Bu::Myriad::createStream( int iPreAllocate )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        Stream *pStr = new Stream();
-        pStr->iId = aStreams.last()->iId+1;
-        //sio << "Myriad: New stream id=" << pStr->iId << ", iPreAllocate="
-        //      << iPreAllocate << sio.nl;
-        pStr->iSize = 0;
-        aStreams.append( pStr );
+    Stream *pStr = new Stream();
+    pStr->iId = aStreams.last()->iId+1;
+    //sio << "Myriad: New stream id=" << pStr->iId << ", iPreAllocate="
+    //  << iPreAllocate << sio.nl;
+    pStr->iSize = 0;
+    aStreams.append( pStr );
 
-        for( int j = 0; j < iPreAllocate; j++ )
-        {
-                int iFreeBlock = findEmptyBlock();
-//              sio << "Myriad: Adding block " << iFreeBlock << sio.nl;
-                pStr->aBlocks.append( iFreeBlock );
-//              bsBlockUsed.setBit( iFreeBlock );
-                iUsed++;
-        }
+    for( int j = 0; j < iPreAllocate; j++ )
+    {
+        int iFreeBlock = findEmptyBlock();
+//      sio << "Myriad: Adding block " << iFreeBlock << sio.nl;
+        pStr->aBlocks.append( iFreeBlock );
+//      bsBlockUsed.setBit( iFreeBlock );
+        iUsed++;
+    }
 
-        bHeaderChanged = true;
+    bHeaderChanged = true;
 
-        return pStr->iId;
+    return pStr->iId;
 }
 
 int Bu::Myriad::createStreamWithId( int iId, int iPreAllocate )
 {
-        MutexLocker mLock( mHeader );
-
-        try
-        {
-                findStream( iId );
-                throw MyriadException( MyriadException::streamExists,
-                        "There is already a stream with the given id.");
-        }
-        catch( MyriadException &e )
-        {
-                Stream *pStr = new Stream();
-                pStr->iId = iId;
-                //sio << "Myriad: New stream id=" << pStr->iId << ", iPreAllocate="
-                //      << iPreAllocate << sio.nl;
-                pStr->iSize = 0;
-                if( aStreams.last()->iId < iId )
-                {
-                        aStreams.append( pStr );
-                }
-                else
-                {
-                        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-                        {
-                                if( (*i)->iId > iId )
-                                {
-                                        aStreams.insert( i, pStr );
-                                        break;
-                                }
-                        }
-                }
-
-                for( int j = 0; j < iPreAllocate; j++ )
-                {
-                        int iFreeBlock = findEmptyBlock();
-        //              sio << "Myriad: Adding block " << iFreeBlock << sio.nl;
-                        pStr->aBlocks.append( iFreeBlock );
-//                      bsBlockUsed.setBit( iFreeBlock );
-                        iUsed++;
-                }
-
-                bHeaderChanged = true;
-
-                return pStr->iId;
-        }
+    MutexLocker mLock( mHeader );
+
+    try
+    {
+        findStream( iId );
+        throw MyriadException( MyriadException::streamExists,
+            "There is already a stream with the given id.");
+    }
+    catch( MyriadException &e )
+    {
+        Stream *pStr = new Stream();
+        pStr->iId = iId;
+        //sio << "Myriad: New stream id=" << pStr->iId << ", iPreAllocate="
+        //  << iPreAllocate << sio.nl;
+        pStr->iSize = 0;
+        if( aStreams.last()->iId < iId )
+        {
+            aStreams.append( pStr );
+        }
+        else
+        {
+            for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+            {
+                if( (*i)->iId > iId )
+                {
+                    aStreams.insert( i, pStr );
+                    break;
+                }
+            }
+        }
+
+        for( int j = 0; j < iPreAllocate; j++ )
+        {
+            int iFreeBlock = findEmptyBlock();
+    //      sio << "Myriad: Adding block " << iFreeBlock << sio.nl;
+            pStr->aBlocks.append( iFreeBlock );
+//          bsBlockUsed.setBit( iFreeBlock );
+            iUsed++;
+        }
+
+        bHeaderChanged = true;
+
+        return pStr->iId;
+    }
 }
 
 int Bu::Myriad::findEmptyBlock()
 {
-        bHeaderChanged = true;
+    bHeaderChanged = true;
 
-        if( lFreeBlocks.isEmpty() )
-        {
-                sStore.setSize( (iBlocks+1)*(Bu::size)iBlockSize );
-                return iBlocks++;
-        }
-        else
-        {
-                return lFreeBlocks.dequeue();
-        }
+    if( lFreeBlocks.isEmpty() )
+    {
+        sStore.setSize( (iBlocks+1)*(Bu::size)iBlockSize );
+        return iBlocks++;
+    }
+    else
+    {
+        return lFreeBlocks.dequeue();
+    }
 }
 
 void Bu::Myriad::deleteStream( int iId )
 {
-        MutexLocker mLock( mHeader );
-
-        if( iId < 0 )
-                throw MyriadException( MyriadException::invalidStreamId,
-                                "Invalid stream id.");
-        if( iId == 0 )
-                throw MyriadException( MyriadException::protectedStream,
-                                "You cannot delete stream zero, it is protected.");
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                if( (*i)->iId == iId )
-                {
-                        Stream *pStream = *i;
-                        for( BlockArray::iterator j = pStream->aBlocks.begin(); j; j++ )
-                        {
-                                lFreeBlocks.append( *j );
-//                              bsBlockUsed.setBit( *j, false );
-                                iUsed--;
-                        }
-                        aStreams.erase( i );
-                        bHeaderChanged = true;
-                        delete pStream;
-                        return;
-                }
-        }
+    MutexLocker mLock( mHeader );
+
+    if( iId < 0 )
+        throw MyriadException( MyriadException::invalidStreamId,
+                "Invalid stream id.");
+    if( iId == 0 )
+        throw MyriadException( MyriadException::protectedStream,
+                "You cannot delete stream zero, it is protected.");
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        if( (*i)->iId == iId )
+        {
+            Stream *pStream = *i;
+            for( BlockArray::iterator j = pStream->aBlocks.begin(); j; j++ )
+            {
+                lFreeBlocks.append( *j );
+//              bsBlockUsed.setBit( *j, false );
+                iUsed--;
+            }
+            aStreams.erase( i );
+            bHeaderChanged = true;
+            delete pStream;
+            return;
+        }
+    }
 }
 
 Bu::Array<int> Bu::Myriad::getStreamIds()
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        Bu::Array<int> aRet( aStreams.getSize() );
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                aRet.append( (*i)->iId );
-        }
+    Bu::Array<int> aRet( aStreams.getSize() );
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        aRet.append( (*i)->iId );
+    }
 
-        return aRet;
+    return aRet;
 }
 
 int Bu::Myriad::getStreamSize( int iId )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        return findStream( iId )->iSize;
+    return findStream( iId )->iSize;
 }
 
 bool Bu::Myriad::hasStream( int iId )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        try
-        {
-                findStream( iId );
-                return true;
-        }catch(...)
-        {
-                return false;
-        }
+    try
+    {
+        findStream( iId );
+        return true;
+    }catch(...)
+    {
+        return false;
+    }
 }
 
 Bu::MyriadStream Bu::Myriad::openStream( int iId )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        //sio << "Myriad:  Request to open stream: " << iId << sio.nl;
-        return MyriadStream( *this, findStream( iId ) );
+    //sio << "Myriad:  Request to open stream: " << iId << sio.nl;
+    return MyriadStream( *this, findStream( iId ) );
 }
 
 int Bu::Myriad::getNumStreams()
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        return aStreams.getSize();
+    return aStreams.getSize();
 }
 
 int Bu::Myriad::getBlockSize()
 {
-        return iBlockSize;
+    return iBlockSize;
 }
 
 int Bu::Myriad::getNumBlocks()
 {
-        return iBlocks;
+    return iBlocks;
 }
 
 int Bu::Myriad::getNumUsedBlocks()
 {
-        return iUsed;
+    return iUsed;
 }
 
 Bu::size Bu::Myriad::getTotalUsedBytes()
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        Bu::size iTotalSize = 0;
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                iTotalSize += (*i)->iSize;
-        }
-        return iTotalSize;
+    Bu::size iTotalSize = 0;
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        iTotalSize += (*i)->iSize;
+    }
+    return iTotalSize;
 }
 
 Bu::size Bu::Myriad::getTotalUnusedBytes()
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        Bu::size iTotalSize = (iBlocks-iUsed)*iBlockSize;
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                iTotalSize += iBlockSize - ((Bu::size)(*i)->iSize%iBlockSize);
-        }
-        return iTotalSize;
+    Bu::size iTotalSize = (iBlocks-iUsed)*iBlockSize;
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        iTotalSize += iBlockSize - ((Bu::size)(*i)->iSize%iBlockSize);
+    }
+    return iTotalSize;
 }
 
 Bu::size Bu::Myriad::getTotalUnusedBytes( int iFakeBlockSize )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        Bu::size iTotalSize = (iBlocks-iUsed)*iFakeBlockSize;
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                iTotalSize += iFakeBlockSize - ((*i)->iSize%iFakeBlockSize);
-        }
-        return iTotalSize;
+    Bu::size iTotalSize = (iBlocks-iUsed)*iFakeBlockSize;
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        iTotalSize += iFakeBlockSize - ((*i)->iSize%iFakeBlockSize);
+    }
+    return iTotalSize;
 }
 
 Bu::Myriad::Stream *Bu::Myriad::findStream( int iId )
 {
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                if( (*i)->iId == iId )
-                        return *i;
-        }
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        if( (*i)->iId == iId )
+            return *i;
+    }
 
-        throw MyriadException( MyriadException::noSuchStream,
-                "The requested stream doesn't exist and cannot be opened." );
+    throw MyriadException( MyriadException::noSuchStream,
+        "The requested stream doesn't exist and cannot be opened." );
 
-        return NULL;
+    return NULL;
 }
 
 Bu::Myriad::Block *Bu::Myriad::getBlock( int iBlock )
 {
-//      sio << "Myriad:  Reading block " << iBlock << ", bytes "
-//              << iBlockSize*iBlock << "-" << iBlockSize*(iBlock+1) << sio.nl;
-        Block *pBlock = new Block;
-        pBlock->pData = new char[iBlockSize];
-        sStore.setPos( iBlockSize * (Bu::size)iBlock );
-        sStore.read( pBlock->pData, iBlockSize );
-        pBlock->bChanged = false;
-        pBlock->iBlockIndex = iBlock;
+//  sio << "Myriad:  Reading block " << iBlock << ", bytes "
+//      << iBlockSize*iBlock << "-" << iBlockSize*(iBlock+1) << sio.nl;
+    Block *pBlock = new Block;
+    pBlock->pData = new char[iBlockSize];
+    sStore.setPos( iBlockSize * (Bu::size)iBlock );
+    sStore.read( pBlock->pData, iBlockSize );
+    pBlock->bChanged = false;
+    pBlock->iBlockIndex = iBlock;
 
-        mActiveBlocks.lock();
-        hActiveBlocks.insert( iBlock, pBlock );
-        mActiveBlocks.unlock();
+    mActiveBlocks.lock();
+    hActiveBlocks.insert( iBlock, pBlock );
+    mActiveBlocks.unlock();
 
-        return pBlock;
+    return pBlock;
 }
 
 void Bu::Myriad::releaseBlock( Bu::Myriad::Block *pBlock )
 {
-        if( pBlock == NULL )
-                return;
-//      sio << "Myriad:  Releasing block " << pBlock->iBlockIndex << sio.nl;
-        syncBlock( pBlock );
-        mActiveBlocks.lock();
-        hActiveBlocks.erase( pBlock->iBlockIndex );
-        mActiveBlocks.unlock();
+    if( pBlock == NULL )
+        return;
+//  sio << "Myriad:  Releasing block " << pBlock->iBlockIndex << sio.nl;
+    syncBlock( pBlock );
+    mActiveBlocks.lock();
+    hActiveBlocks.erase( pBlock->iBlockIndex );
+    mActiveBlocks.unlock();
 
-        delete[] pBlock->pData;
-        delete pBlock;
+    delete[] pBlock->pData;
+    delete pBlock;
 }
 
 void Bu::Myriad::syncBlock( Block *pBlock )
 {
-        if( pBlock->bChanged )
-        {
-//              sio << "Myriad:    - Block changed, writing back to stream." << sio.nl;
-                sStore.setPos( iBlockSize * (Bu::size)pBlock->iBlockIndex );
-                sStore.write( pBlock->pData, iBlockSize );
-                pBlock->bChanged = false;
-        }
+    if( pBlock->bChanged )
+    {
+//      sio << "Myriad:    - Block changed, writing back to stream." << sio.nl;
+        sStore.setPos( iBlockSize * (Bu::size)pBlock->iBlockIndex );
+        sStore.write( pBlock->pData, iBlockSize );
+        pBlock->bChanged = false;
+    }
 }
 
 int Bu::Myriad::streamAddBlock( Stream *pStream )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        int iBlock = findEmptyBlock();
-        pStream->aBlocks.append( iBlock );
-//      bsBlockUsed.setBit( iBlock );
-//      bHeaderChanged = true;
-        iUsed++;
-        return iBlock;
+    int iBlock = findEmptyBlock();
+    pStream->aBlocks.append( iBlock );
+//  bsBlockUsed.setBit( iBlock );
+//  bHeaderChanged = true;
+    iUsed++;
+    return iBlock;
 }
 
 void Bu::Myriad::setStreamSize( Stream *pStream, long iSize )
 {
-        MutexLocker mLock( mHeader );
-
-        if( pStream->iSize == iSize )
-        {
-                return;
-        }
-        else if( pStream->iSize > iSize )
-        {
-                // Shrink
-                for( int iNewSize = pStream->aBlocks.getSize()*iBlockSize;
-                         iNewSize-iBlockSize > iSize; iNewSize -= iBlockSize )
-                {
-//                      if( bsBlockUsed.getBit( pStream->aBlocks.last() ) )
-                                iUsed--;
-//                      else
-//                              sio << "Unused block used in stream? " << pStream->aBlocks.last() << sio.nl;
-                        lFreeBlocks.enqueue( pStream->aBlocks.last() );
-//                      bsBlockUsed.setBit( pStream->aBlocks.last(), false );
-                        pStream->aBlocks.eraseLast();
-                }
-                pStream->iSize = iSize;
-                bHeaderChanged = true;
-        }
-        else
-        {
-                // Grow
-                for( int iNewSize = pStream->aBlocks.getSize()*iBlockSize;
-                         iNewSize < iSize; iNewSize += iBlockSize )
-                {
-                        //streamAddBlock( pStream );
-                        int iBlock = findEmptyBlock();
-                        pStream->aBlocks.append( iBlock );
-//                      bsBlockUsed.setBit( iBlock );
-//                      bHeaderChanged = true;
-                        iUsed++;
-                }
-                pStream->iSize = iSize;
-                bHeaderChanged = true;
-        }
+    MutexLocker mLock( mHeader );
+
+    if( pStream->iSize == iSize )
+    {
+        return;
+    }
+    else if( pStream->iSize > iSize )
+    {
+        // Shrink
+        for( int iNewSize = pStream->aBlocks.getSize()*iBlockSize;
+             iNewSize-iBlockSize > iSize; iNewSize -= iBlockSize )
+        {
+//          if( bsBlockUsed.getBit( pStream->aBlocks.last() ) )
+                iUsed--;
+//          else
+//              sio << "Unused block used in stream? " << pStream->aBlocks.last() << sio.nl;
+            lFreeBlocks.enqueue( pStream->aBlocks.last() );
+//          bsBlockUsed.setBit( pStream->aBlocks.last(), false );
+            pStream->aBlocks.eraseLast();
+        }
+        pStream->iSize = iSize;
+        bHeaderChanged = true;
+    }
+    else
+    {
+        // Grow
+        for( int iNewSize = pStream->aBlocks.getSize()*iBlockSize;
+             iNewSize < iSize; iNewSize += iBlockSize )
+        {
+            //streamAddBlock( pStream );
+            int iBlock = findEmptyBlock();
+            pStream->aBlocks.append( iBlock );
+//          bsBlockUsed.setBit( iBlock );
+//          bHeaderChanged = true;
+            iUsed++;
+        }
+        pStream->iSize = iSize;
+        bHeaderChanged = true;
+    }
 }
 
 void Bu::Myriad::headerChanged()
 {
-        bHeaderChanged = true;
+    bHeaderChanged = true;
 }
 
 bool Bu::Myriad::isMyriad( Bu::Stream &sStore )
 {
-        uint8_t uTmp;
+    uint8_t uTmp;
 
-        return isMyriad( sStore, uTmp );
+    return isMyriad( sStore, uTmp );
 }
 
 bool Bu::Myriad::isMyriad( Bu::Stream &sStore, uint8_t &uTmp )
 {
-        sStore.setPos( 0 );
+    sStore.setPos( 0 );
 
-        unsigned char buf[4];
-        if( sStore.read( buf, 4 ) < 4 )
-                throw MyriadException( MyriadException::emptyStream,
-                                "Input stream appears to be empty.");
-        sStore.read( &uTmp, 1 );
-        sStore.setPos( 0 );
-        if( memcmp( buf, Myriad_MAGIC_CODE, 4 ) )
-        {
-                return false;
-        }
-        return true;
+    unsigned char buf[4];
+    if( sStore.read( buf, 4 ) < 4 )
+        throw MyriadException( MyriadException::emptyStream,
+                "Input stream appears to be empty.");
+    sStore.read( &uTmp, 1 );
+    sStore.setPos( 0 );
+    if( memcmp( buf, Myriad_MAGIC_CODE, 4 ) )
+    {
+        return false;
+    }
+    return true;
 }
 
 const Bu::BitString Bu::Myriad::getBlocksUsed() const
 {
-        Bu::BitString bs( iBlocks, false );
-        for( int j = 0; j < iBlocks; j++ )
-                bs.setBit( j );
-        for( IndexList::const_iterator i = lFreeBlocks.begin(); i; i++ )
-                bs.setBit( *i, false );
-        return bs;
+    Bu::BitString bs( iBlocks, false );
+    for( int j = 0; j < iBlocks; j++ )
+        bs.setBit( j );
+    for( IndexList::const_iterator i = lFreeBlocks.begin(); i; i++ )
+        bs.setBit( *i, false );
+    return bs;
 }
 
diff --git a/src/stable/myriad.h b/src/stable/myriad.h
index 6b1db41..4bfd88e 100644
--- a/src/stable/myriad.h
+++ b/src/stable/myriad.h
@@ -18,219 +18,219 @@
 
 namespace Bu
 {
-        class Stream;
-        class MyriadStream;
-
-        subExceptionDeclBegin( MyriadException )
-                enum
-                {
-                        emptyStream,
-                        invalidFormat,
-                        badVersion,
-                        invalidWordSize,
-                        noSuchStream,
-                        streamExists,
-                        invalidStreamId,
-                        protectedStream
-                };
-        subExceptionDeclEnd();
-
-        /**
-         * Myriad block-allocated stream multiplexing system.  This is a system for
-         * creating streams that contain other streams in a flexible and lightweight
-         * manner.  Basically, you can create a file (or any other stream) that can
-         * store any number of flexible, growing streams.  The streams within the
-         * Myriad stream are automatically numbered, not named.  This works more
-         * or less like a filesystem, but without the extra layer for managing
-         * file and directory links.  This would actually be very easy to add
-         * on top of Myriad, but is not required.
-         *
-         * Header format is as follows:
-         *
-         * MMMMvBssssSSSS*
-         * M = Magic number (0AD3FA84)
-         * v = version number
-         * B = Bits per int
-         * s = Blocksize in bytes
-         * S = Number of Streams
-         * 
-         * The * represents the Stream headers, one per stream, as follows:
-         * IIIIssss$
-         * I = Id number of the stream
-         * s = size of stream in bytes
-         *
-         * The $ represents the Block headers, one per used block, as  follows:
-         * IIII
-         * I = Index of the block
-         *
-         * The stream/block data is interleaved in the header, so all blocks stored
-         * with one stream are together.  The block headers are in order, and the
-         * data in them is required to be "solid" you cannot fill partial blocks
-         * mid-way through a stream.
-         *
-         * The initial block starts with the nids header, and is both the zero block
-         * and the zero stream.  For now, the minimum block size is the size needed
-         * to store the base header, the zero stream header, and the first two
-         * blocks of the zero stream, so 30 bytes.  Since it's reccomended to use
-         * a size that will fit evenly into filesystem blocks, then a size of 32 is
-         * probably the smallest reccomended size because all powers of two equal
-         * to or greater than 32 are evenly divisible by 32.
-         *
-         * I have had a thought that if the block size were smaller than 42 bytes
-         * the header would consume the first N blocks where N * block size is
-         * enough space to house the initial header, the first stream header, and
-         * the first N block headers.  This, of course, causes you to hit an
-         * infinite header if the block size is small enough.
-         */
-        class Myriad
-        {
-                friend class MyriadStream;
-        public:
-                /**
-                 * Create a Myriad object that uses the given stream to store data.
-                 * This stream must be random access.  The block size and preallocate
-                 * values passed in are values that will be used if the given stream
-                 * is empty.  In that case the stream will be "formatted" for myriad
-                 * with the specified block size.  If there is already a viable Myriad
-                 * format present in the stream, then the blocksize and preallocate
-                 * values will be ignored and the values from the stream will be used
-                 * instead.  If the stream doesn't appear to be Myriad formatted an
-                 * exception will be thrown.
-                 */
-                Myriad( Bu::Stream &sStore, int iBlockSize=512, int iPreallocate=8 );
-                virtual ~Myriad();
-
-                /**
-                 * Destroy whatever data may be in the base stream and create a new
-                 * Myriad system there with the given blocksize.  Use this with care,
-                 * it will destroy anything that was already in the stream, and
-                 * generally, should not ever have to be used.
-                 */
-                void initialize( int iBlockSize, int iPreAllocate=1 );
-
-                /**
-                 * Create a new stream within the Myriad system.  The ID of the new
-                 * stream is returned.
-                 */
-                int createStream( int iPreAllocate=1 );
-
-                /**
-                 * Create a new stream within the Myriad system with a given id.  The
-                 * id that you provide will be the new id of the stream unless it's
-                 * already used, in which case an error is thrown.  This is primarilly
-                 * useful when copying an old Myriad file into a new one.
-                 */
-                int createStreamWithId( int iId, int iPreAllocate=1 );
-
-                /**
-                 * Delete a stream that's already within the Myriad.
-                 */
-                void deleteStream( int iId );
-
-                /**
-                 * Return a new Stream object assosiated with the given stream ID.
-                 */
-                MyriadStream openStream( int iId );
-
-                Bu::Array<int> getStreamIds();
-                int getStreamSize( int iId );
-                bool hasStream( int iId );
-
-                int getNumStreams();
-                int getBlockSize();
-                int getNumBlocks();
-                int getNumUsedBlocks();
-                Bu::size getTotalUsedBytes();
-                Bu::size getTotalUnusedBytes();
-                Bu::size getTotalUnusedBytes( int iFakeBlockSize );
-
-                /**
-                 * Syncronize the header data, etc. with the storage stream.  It's not
-                 * a bad idea to call this periodically.
-                 */
-                void sync();
-
-                /**
-                 * Read the first few bytes from the given stream and return true/false
-                 * depending on weather or not it's a Myriad stream.  This will throw
-                 * an exception if the stream is empty, or is not random access.
-                 */
-                static bool isMyriad( Bu::Stream &sStore, uint8_t &uVer );
-                
-                /**
-                 * Read the first few bytes from the given stream and return true/false
-                 * depending on weather or not it's a Myriad stream.  This will throw
-                 * an exception if the stream is empty, or is not random access.
-                 */
-                static bool isMyriad( Bu::Stream &sStore );
-
-                const Bu::BitString getBlocksUsed() const;
-
-        private:
-                /**
-                 * Initialize this object based on the data already in the assosiated
-                 * stream.  This will be called automatically for you if you forget,
-                 * but if you want to pre-initialize for some reason, just call this
-                 * once before you actually start doing anything with your Myriad.
-                 */
-                void initialize();
-
-                enum
-                {
-                        blockUnused     =       0xFFFFFFFFUL
-                };
-                
-                typedef Bu::Array<int> BlockArray;
-                class Stream
-                {
-                public:
-                        int iId;
-                        int iSize;
-                        BlockArray aBlocks;
-                };
-                typedef Bu::Array<Stream *> StreamArray;
-
-                class Block
-                {
-                public:
-                        char *pData;
-                        bool bChanged;
-                        int iBlockIndex;
-                };
-
-                void updateHeader();
-                int findEmptyBlock();
-
-                /**
-                 *@todo Change this to use a binary search, it's nicer.
-                 */
-                Stream *findStream( int iId );
-
-                Block *getBlock( int iBlock );
-                void releaseBlock( Block *pBlock );
-                void syncBlock( Block *pBlock );
-
-                int streamAddBlock( Stream *pStream );
-                void setStreamSize( Stream *pStream, long iSize );
-
-                void headerChanged();
-
-        private:
-                Bu::Stream &sStore;
-                int iBlockSize;
-                int iBlocks;
-                int iUsed;
-                typedef Bu::List<int> IndexList;
-                IndexList lFreeBlocks;
-//              Bu::BitString bsBlockUsed;
-                StreamArray aStreams;
-                typedef Bu::Hash<int, Block *> BlockHash;
-                BlockHash hActiveBlocks;
-                bool bHeaderChanged;
-
-                Bu::Mutex mHeader;
-                Bu::Mutex mActiveBlocks;
-        };
+    class Stream;
+    class MyriadStream;
+
+    subExceptionDeclBegin( MyriadException )
+        enum
+        {
+            emptyStream,
+            invalidFormat,
+            badVersion,
+            invalidWordSize,
+            noSuchStream,
+            streamExists,
+            invalidStreamId,
+            protectedStream
+        };
+    subExceptionDeclEnd();
+
+    /**
+     * Myriad block-allocated stream multiplexing system.  This is a system for
+     * creating streams that contain other streams in a flexible and lightweight
+     * manner.  Basically, you can create a file (or any other stream) that can
+     * store any number of flexible, growing streams.  The streams within the
+     * Myriad stream are automatically numbered, not named.  This works more
+     * or less like a filesystem, but without the extra layer for managing
+     * file and directory links.  This would actually be very easy to add
+     * on top of Myriad, but is not required.
+     *
+     * Header format is as follows:
+     *
+     * MMMMvBssssSSSS*
+     * M = Magic number (0AD3FA84)
+     * v = version number
+     * B = Bits per int
+     * s = Blocksize in bytes
+     * S = Number of Streams
+     * 
+     * The * represents the Stream headers, one per stream, as follows:
+     * IIIIssss$
+     * I = Id number of the stream
+     * s = size of stream in bytes
+     *
+     * The $ represents the Block headers, one per used block, as  follows:
+     * IIII
+     * I = Index of the block
+     *
+     * The stream/block data is interleaved in the header, so all blocks stored
+     * with one stream are together.  The block headers are in order, and the
+     * data in them is required to be "solid" you cannot fill partial blocks
+     * mid-way through a stream.
+     *
+     * The initial block starts with the nids header, and is both the zero block
+     * and the zero stream.  For now, the minimum block size is the size needed
+     * to store the base header, the zero stream header, and the first two
+     * blocks of the zero stream, so 30 bytes.  Since it's reccomended to use
+     * a size that will fit evenly into filesystem blocks, then a size of 32 is
+     * probably the smallest reccomended size because all powers of two equal
+     * to or greater than 32 are evenly divisible by 32.
+     *
+     * I have had a thought that if the block size were smaller than 42 bytes
+     * the header would consume the first N blocks where N * block size is
+     * enough space to house the initial header, the first stream header, and
+     * the first N block headers.  This, of course, causes you to hit an
+     * infinite header if the block size is small enough.
+     */
+    class Myriad
+    {
+        friend class MyriadStream;
+    public:
+        /**
+         * Create a Myriad object that uses the given stream to store data.
+         * This stream must be random access.  The block size and preallocate
+         * values passed in are values that will be used if the given stream
+         * is empty.  In that case the stream will be "formatted" for myriad
+         * with the specified block size.  If there is already a viable Myriad
+         * format present in the stream, then the blocksize and preallocate
+         * values will be ignored and the values from the stream will be used
+         * instead.  If the stream doesn't appear to be Myriad formatted an
+         * exception will be thrown.
+         */
+        Myriad( Bu::Stream &sStore, int iBlockSize=512, int iPreallocate=8 );
+        virtual ~Myriad();
+
+        /**
+         * Destroy whatever data may be in the base stream and create a new
+         * Myriad system there with the given blocksize.  Use this with care,
+         * it will destroy anything that was already in the stream, and
+         * generally, should not ever have to be used.
+         */
+        void initialize( int iBlockSize, int iPreAllocate=1 );
+
+        /**
+         * Create a new stream within the Myriad system.  The ID of the new
+         * stream is returned.
+         */
+        int createStream( int iPreAllocate=1 );
+
+        /**
+         * Create a new stream within the Myriad system with a given id.  The
+         * id that you provide will be the new id of the stream unless it's
+         * already used, in which case an error is thrown.  This is primarilly
+         * useful when copying an old Myriad file into a new one.
+         */
+        int createStreamWithId( int iId, int iPreAllocate=1 );
+
+        /**
+         * Delete a stream that's already within the Myriad.
+         */
+        void deleteStream( int iId );
+
+        /**
+         * Return a new Stream object assosiated with the given stream ID.
+         */
+        MyriadStream openStream( int iId );
+
+        Bu::Array<int> getStreamIds();
+        int getStreamSize( int iId );
+        bool hasStream( int iId );
+
+        int getNumStreams();
+        int getBlockSize();
+        int getNumBlocks();
+        int getNumUsedBlocks();
+        Bu::size getTotalUsedBytes();
+        Bu::size getTotalUnusedBytes();
+        Bu::size getTotalUnusedBytes( int iFakeBlockSize );
+
+        /**
+         * Syncronize the header data, etc. with the storage stream.  It's not
+         * a bad idea to call this periodically.
+         */
+        void sync();
+
+        /**
+         * Read the first few bytes from the given stream and return true/false
+         * depending on weather or not it's a Myriad stream.  This will throw
+         * an exception if the stream is empty, or is not random access.
+         */
+        static bool isMyriad( Bu::Stream &sStore, uint8_t &uVer );
+        
+        /**
+         * Read the first few bytes from the given stream and return true/false
+         * depending on weather or not it's a Myriad stream.  This will throw
+         * an exception if the stream is empty, or is not random access.
+         */
+        static bool isMyriad( Bu::Stream &sStore );
+
+        const Bu::BitString getBlocksUsed() const;
+
+    private:
+        /**
+         * Initialize this object based on the data already in the assosiated
+         * stream.  This will be called automatically for you if you forget,
+         * but if you want to pre-initialize for some reason, just call this
+         * once before you actually start doing anything with your Myriad.
+         */
+        void initialize();
+
+        enum
+        {
+            blockUnused =   0xFFFFFFFFUL
+        };
+        
+        typedef Bu::Array<int> BlockArray;
+        class Stream
+        {
+        public:
+            int iId;
+            int iSize;
+            BlockArray aBlocks;
+        };
+        typedef Bu::Array<Stream *> StreamArray;
+
+        class Block
+        {
+        public:
+            char *pData;
+            bool bChanged;
+            int iBlockIndex;
+        };
+
+        void updateHeader();
+        int findEmptyBlock();
+
+        /**
+         *@todo Change this to use a binary search, it's nicer.
+         */
+        Stream *findStream( int iId );
+
+        Block *getBlock( int iBlock );
+        void releaseBlock( Block *pBlock );
+        void syncBlock( Block *pBlock );
+
+        int streamAddBlock( Stream *pStream );
+        void setStreamSize( Stream *pStream, long iSize );
+
+        void headerChanged();
+
+    private:
+        Bu::Stream &sStore;
+        int iBlockSize;
+        int iBlocks;
+        int iUsed;
+        typedef Bu::List<int> IndexList;
+        IndexList lFreeBlocks;
+//      Bu::BitString bsBlockUsed;
+        StreamArray aStreams;
+        typedef Bu::Hash<int, Block *> BlockHash;
+        BlockHash hActiveBlocks;
+        bool bHeaderChanged;
+
+        Bu::Mutex mHeader;
+        Bu::Mutex mActiveBlocks;
+    };
 };
 
 #endif
diff --git a/src/stable/myriadstream.cpp b/src/stable/myriadstream.cpp
index 58d3936..c33445a 100644
--- a/src/stable/myriadstream.cpp
+++ b/src/stable/myriadstream.cpp
@@ -9,7 +9,7 @@
 
 #include <string.h>
 
-// #define MYRIAD_STREAM_DEBUG  1
+// #define MYRIAD_STREAM_DEBUG  1
 
 #ifdef MYRIAD_STREAM_DEBUG
 #include "bu/sio.h"
@@ -19,27 +19,27 @@ using Bu::Fmt;
 #endif
 
 Bu::MyriadStream::MyriadStream( Bu::Myriad &rMyriad,
-                Bu::Myriad::Stream *pStream ) :
-        rMyriad( rMyriad ),
-        pStream( pStream ),
-        pCurBlock( NULL ),
-        iPos( 0 )
+        Bu::Myriad::Stream *pStream ) :
+    rMyriad( rMyriad ),
+    pStream( pStream ),
+    pCurBlock( NULL ),
+    iPos( 0 )
 {
 #ifdef MYRIAD_STREAM_DEBUG
-        sio << "MyriadStream: " << __LINE__ << ": Created, iId=" << pStream->iId << ", iSize="
-                << pStream->iSize << sio.nl;
+    sio << "MyriadStream: " << __LINE__ << ": Created, iId=" << pStream->iId << ", iSize="
+        << pStream->iSize << sio.nl;
 #endif
-        //pCurBlock = rMyriad.newBlock();
-        //rMyriad.getBlock( uStream, pCurBlock );
-        //uSize = pCurBlock->uBytesUsed;
+    //pCurBlock = rMyriad.newBlock();
+    //rMyriad.getBlock( uStream, pCurBlock );
+    //uSize = pCurBlock->uBytesUsed;
 }
 
 Bu::MyriadStream::~MyriadStream()
 {
-        if( pCurBlock )
-                rMyriad.releaseBlock( pCurBlock );
-        //rMyriad.updateStreamSize( uStream, uSize );
-        //rMyriad.deleteBlock( pCurBlock );
+    if( pCurBlock )
+        rMyriad.releaseBlock( pCurBlock );
+    //rMyriad.updateStreamSize( uStream, uSize );
+    //rMyriad.deleteBlock( pCurBlock );
 }
 
 void Bu::MyriadStream::close()
@@ -49,200 +49,200 @@ void Bu::MyriadStream::close()
 Bu::size Bu::MyriadStream::read( void *pBuf, Bu::size nBytes )
 {
 #ifdef MYRIAD_STREAM_DEBUG
-        sio << "MyriadStream: read: " << __LINE__ << ": Started, asked to read " << nBytes << "b."
-                << sio.nl;
+    sio << "MyriadStream: read: " << __LINE__ << ": Started, asked to read " << nBytes << "b."
+        << sio.nl;
 #endif
-        if( nBytes > (Bu::size)pStream->iSize-iPos )
-                nBytes = pStream->iSize-iPos;
-        if( nBytes <= 0 )
-                return 0;
-        int iLeft = nBytes;
+    if( nBytes > (Bu::size)pStream->iSize-iPos )
+        nBytes = pStream->iSize-iPos;
+    if( nBytes <= 0 )
+        return 0;
+    int iLeft = nBytes;
 #ifdef MYRIAD_STREAM_DEBUG
-        sio << "MyriadStream: read: " << __LINE__ << ": Started, going to read " << nBytes << "b."
-                << sio.nl;
+    sio << "MyriadStream: read: " << __LINE__ << ": Started, going to read " << nBytes << "b."
+        << sio.nl;
 #endif
-        if( pCurBlock == NULL )
-        {
+    if( pCurBlock == NULL )
+    {
 #ifdef MYRIAD_STREAM_DEBUG
-                sio << "MyriadStream: read: " << __LINE__ << ": No block loaded, loading initial block."
-                        << sio.nl;
+        sio << "MyriadStream: read: " << __LINE__ << ": No block loaded, loading initial block."
+            << sio.nl;
 #endif
-                pCurBlock = rMyriad.getBlock(
-                        pStream->aBlocks[iPos/rMyriad.iBlockSize]
-                        );
-        }
-        while( iLeft > 0 )
-        {
-                int iCurBlock = pStream->aBlocks[iPos/rMyriad.iBlockSize];
-                if( pCurBlock->iBlockIndex != iCurBlock )
-                {
+        pCurBlock = rMyriad.getBlock(
+            pStream->aBlocks[iPos/rMyriad.iBlockSize]
+            );
+    }
+    while( iLeft > 0 )
+    {
+        int iCurBlock = pStream->aBlocks[iPos/rMyriad.iBlockSize];
+        if( pCurBlock->iBlockIndex != iCurBlock )
+        {
 #ifdef MYRIAD_STREAM_DEBUG
-                        sio << "MyriadStream: read: " << __LINE__ << ": Loading new block " << iCurBlock << "."
-                                << sio.nl;
+            sio << "MyriadStream: read: " << __LINE__ << ": Loading new block " << iCurBlock << "."
+                << sio.nl;
 #endif
-                        rMyriad.releaseBlock( pCurBlock );
-                        pCurBlock = rMyriad.getBlock( iCurBlock );
-                }
-
-                int iAmnt = Bu::buMin(
-                        Bu::buMin(
-                                rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
-                                iLeft
-                                ),
-                        pStream->iSize-iPos
-                        );
+            rMyriad.releaseBlock( pCurBlock );
+            pCurBlock = rMyriad.getBlock( iCurBlock );
+        }
+
+        int iAmnt = Bu::buMin(
+            Bu::buMin(
+                rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
+                iLeft
+                ),
+            pStream->iSize-iPos
+            );
 #ifdef MYRIAD_STREAM_DEBUG
-                sio << "MyriadStream: read: " << __LINE__ << ": Copying out bytes: "
-                        << iPos << "(" << (iPos%rMyriad.iBlockSize) << ")+"
-                        << iAmnt
-                        << ", " << iLeft << "b left." << sio.nl;
+        sio << "MyriadStream: read: " << __LINE__ << ": Copying out bytes: "
+            << iPos << "(" << (iPos%rMyriad.iBlockSize) << ")+"
+            << iAmnt
+            << ", " << iLeft << "b left." << sio.nl;
 #endif
-                memcpy(
-                        pBuf,
-                        pCurBlock->pData+(iPos%rMyriad.iBlockSize),
-                        iAmnt
-                        );
-                iPos += iAmnt;
-                pBuf = &((char *)pBuf)[iAmnt];
-                iLeft -= iAmnt;
-        }
-        return nBytes;
+        memcpy(
+            pBuf,
+            pCurBlock->pData+(iPos%rMyriad.iBlockSize),
+            iAmnt
+            );
+        iPos += iAmnt;
+        pBuf = &((char *)pBuf)[iAmnt];
+        iLeft -= iAmnt;
+    }
+    return nBytes;
 }
 
 Bu::size Bu::MyriadStream::write( const void *pBuf, Bu::size nBytes )
 {
-        if( nBytes <= 0 )
-                return 0;
+    if( nBytes <= 0 )
+        return 0;
 
 #ifdef MYRIAD_STREAM_DEBUG
-        sio << "MyriadStream: write: " << __LINE__ << ": Started, asked to write " << nBytes << "b."
-                << sio.nl;
+    sio << "MyriadStream: write: " << __LINE__ << ": Started, asked to write " << nBytes << "b."
+        << sio.nl;
 #endif
-        if( nBytes <= 0 )
-                return 0;
-        int iLeft = nBytes;
-        /*
-        if( pCurBlock == NULL )
-        {
+    if( nBytes <= 0 )
+        return 0;
+    int iLeft = nBytes;
+    /*
+    if( pCurBlock == NULL )
+    {
 #ifdef MYRIAD_STREAM_DEBUG
-                sio << "MyriadStream: write: No block loaded, loading initial block."
-                        << sio.nl;
+        sio << "MyriadStream: write: No block loaded, loading initial block."
+            << sio.nl;
 #endif
-                pCurBlock = rMyriad.getBlock(
-                        pStream->aBlocks[iPos/rMyriad.iBlockSize]
-                        );
-        }*/
-        
-        while( iLeft > 0 )
-        {
-                int iCurBlock;
-                if( iPos/rMyriad.iBlockSize < pStream->aBlocks.getSize() )
-                {
-                        iCurBlock = pStream->aBlocks[iPos/rMyriad.iBlockSize];
-                }
-                else
-                {
-                        iCurBlock = rMyriad.streamAddBlock( pStream );
+        pCurBlock = rMyriad.getBlock(
+            pStream->aBlocks[iPos/rMyriad.iBlockSize]
+            );
+    }*/
+    
+    while( iLeft > 0 )
+    {
+        int iCurBlock;
+        if( iPos/rMyriad.iBlockSize < pStream->aBlocks.getSize() )
+        {
+            iCurBlock = pStream->aBlocks[iPos/rMyriad.iBlockSize];
+        }
+        else
+        {
+            iCurBlock = rMyriad.streamAddBlock( pStream );
 #ifdef MYRIAD_STREAM_DEBUG
-                        sio << "MyriadStream: write: " << __LINE__ << ": New block allocated and appended: "
-                                << iCurBlock << "." << sio.nl;
+            sio << "MyriadStream: write: " << __LINE__ << ": New block allocated and appended: "
+                << iCurBlock << "." << sio.nl;
 
 #endif
-                }
-                if( !pCurBlock || pCurBlock->iBlockIndex != iCurBlock )
-                {
+        }
+        if( !pCurBlock || pCurBlock->iBlockIndex != iCurBlock )
+        {
 #ifdef MYRIAD_STREAM_DEBUG
-                        sio << "MyriadStream: write: " << __LINE__ << ": Loading new block " << iCurBlock << "."
-                                << sio.nl;
+            sio << "MyriadStream: write: " << __LINE__ << ": Loading new block " << iCurBlock << "."
+                << sio.nl;
 #endif
-                        rMyriad.releaseBlock( pCurBlock );
-                        pCurBlock = rMyriad.getBlock( iCurBlock );
-                }
-                pCurBlock->bChanged = true;
-                
-                // There are two main writing modes when it comes down to it.
-                // Overwrite mode and append mode.  Append is what pretty much always
-                // happens when creating a new stream.
-                if( iPos < pStream->iSize )
-                {
-                        int iAmnt = Bu::buMin(
-                                Bu::buMin(
-                                        rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
-                                        iLeft
-                                        ),
-                                pStream->iSize-iPos
-                                );
+            rMyriad.releaseBlock( pCurBlock );
+            pCurBlock = rMyriad.getBlock( iCurBlock );
+        }
+        pCurBlock->bChanged = true;
+        
+        // There are two main writing modes when it comes down to it.
+        // Overwrite mode and append mode.  Append is what pretty much always
+        // happens when creating a new stream.
+        if( iPos < pStream->iSize )
+        {
+            int iAmnt = Bu::buMin(
+                Bu::buMin(
+                    rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
+                    iLeft
+                    ),
+                pStream->iSize-iPos
+                );
 #ifdef MYRIAD_STREAM_DEBUG
-                        sio << "MyriadStream: write (ovr): " << __LINE__ << ": Copying in bytes: "
-                                << (iPos%rMyriad.iBlockSize) << "+"
-                                << iAmnt
-                                << ", " << iLeft << "b left." << sio.nl;
+            sio << "MyriadStream: write (ovr): " << __LINE__ << ": Copying in bytes: "
+                << (iPos%rMyriad.iBlockSize) << "+"
+                << iAmnt
+                << ", " << iLeft << "b left." << sio.nl;
 #endif
-                        memcpy(
-                                pCurBlock->pData+(iPos%rMyriad.iBlockSize),
-                                pBuf,
-                                iAmnt
-                                );
-                        iPos += iAmnt;
-                        pBuf = &((char *)pBuf)[iAmnt];
-                        iLeft -= iAmnt;
-                }
-                else
-                {
-                        int iAmnt = Bu::buMin(
-                                rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
-                                iLeft
-                                );
+            memcpy(
+                pCurBlock->pData+(iPos%rMyriad.iBlockSize),
+                pBuf,
+                iAmnt
+                );
+            iPos += iAmnt;
+            pBuf = &((char *)pBuf)[iAmnt];
+            iLeft -= iAmnt;
+        }
+        else
+        {
+            int iAmnt = Bu::buMin(
+                rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
+                iLeft
+                );
 #ifdef MYRIAD_STREAM_DEBUG
-                        sio << "MyriadStream: write (app): " << __LINE__ << ": Copying in bytes: "
-                                << (iPos%rMyriad.iBlockSize) << "+"
-                                << iAmnt
-                                << ", " << iLeft << "b left." << sio.nl;
+            sio << "MyriadStream: write (app): " << __LINE__ << ": Copying in bytes: "
+                << (iPos%rMyriad.iBlockSize) << "+"
+                << iAmnt
+                << ", " << iLeft << "b left." << sio.nl;
 #endif
-                        memcpy(
-                                pCurBlock->pData+(iPos%rMyriad.iBlockSize),
-                                pBuf,
-                                iAmnt
-                                );
-                        iPos += iAmnt;
-                        pStream->iSize += iAmnt;
-                        rMyriad.headerChanged();
-                        pBuf = &((char *)pBuf)[iAmnt];
-                        iLeft -= iAmnt;
-                }
-        }
-
-        return nBytes;
+            memcpy(
+                pCurBlock->pData+(iPos%rMyriad.iBlockSize),
+                pBuf,
+                iAmnt
+                );
+            iPos += iAmnt;
+            pStream->iSize += iAmnt;
+            rMyriad.headerChanged();
+            pBuf = &((char *)pBuf)[iAmnt];
+            iLeft -= iAmnt;
+        }
+    }
+
+    return nBytes;
 }
 
 Bu::size Bu::MyriadStream::tell()
 {
-        return iPos;
+    return iPos;
 }
 
 void Bu::MyriadStream::seek( Bu::size offset )
 {
-        iPos += offset;
+    iPos += offset;
 }
 
 void Bu::MyriadStream::setPos( Bu::size pos )
 {
-        iPos = pos;
+    iPos = pos;
 }
 
 void Bu::MyriadStream::setPosEnd( Bu::size pos )
 {
-        iPos = pStream->iSize-pos;
+    iPos = pStream->iSize-pos;
 }
 
 bool Bu::MyriadStream::isEos()
 {
-        return iPos >= pStream->iSize;
+    return iPos >= pStream->iSize;
 }
 
 bool Bu::MyriadStream::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::MyriadStream::flush()
@@ -251,32 +251,32 @@ void Bu::MyriadStream::flush()
 
 bool Bu::MyriadStream::canRead()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MyriadStream::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MyriadStream::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MyriadStream::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MyriadStream::isSeekable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MyriadStream::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::MyriadStream::setBlocking( bool /*bBlocking*/ )
@@ -285,25 +285,25 @@ void Bu::MyriadStream::setBlocking( bool /*bBlocking*/ )
 
 void Bu::MyriadStream::setSize( Bu::size iSize )
 {
-        if( iSize < 0 )
-                iSize = 0;
-        rMyriad.setStreamSize( pStream, iSize );
-        if( iPos > iSize )
-                iPos = iSize;
+    if( iSize < 0 )
+        iSize = 0;
+    rMyriad.setStreamSize( pStream, iSize );
+    if( iPos > iSize )
+        iPos = iSize;
 }
 
 Bu::size Bu::MyriadStream::getSize() const
 {
-        return pStream->iSize;
+    return pStream->iSize;
 }
 
 Bu::size Bu::MyriadStream::getBlockSize() const
 {
-        return rMyriad.getBlockSize();
+    return rMyriad.getBlockSize();
 }
 
 Bu::String Bu::MyriadStream::getLocation() const
 {
-        return Bu::String("%1").arg( pStream->iId );
+    return Bu::String("%1").arg( pStream->iId );
 }
 
diff --git a/src/stable/myriadstream.h b/src/stable/myriadstream.h
index 7cc2fc0..fe7453f 100644
--- a/src/stable/myriadstream.h
+++ b/src/stable/myriadstream.h
@@ -13,49 +13,49 @@
 
 namespace Bu
 {
-        class MyriadStream : public Bu::Stream
-        {
-                friend class Myriad;
-        private:
-                /**
-                 * These can only be created by the Myriad class.
-                 */
-                MyriadStream( Myriad &rMyriad, Myriad::Stream *pStream );
-
-        public:
-                virtual ~MyriadStream();
-
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
-
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-
-        private:
-                Myriad &rMyriad;
-                Myriad::Stream *pStream;
-                Myriad::Block *pCurBlock;
-                int iBlockSize;
-                int iPos; 
-        };
+    class MyriadStream : public Bu::Stream
+    {
+        friend class Myriad;
+    private:
+        /**
+         * These can only be created by the Myriad class.
+         */
+        MyriadStream( Myriad &rMyriad, Myriad::Stream *pStream );
+
+    public:
+        virtual ~MyriadStream();
+
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
+
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+
+    private:
+        Myriad &rMyriad;
+        Myriad::Stream *pStream;
+        Myriad::Block *pCurBlock;
+        int iBlockSize;
+        int iPos; 
+    };
 };
 
 #endif
diff --git a/src/stable/nullstream.cpp b/src/stable/nullstream.cpp
index 0dcede2..5f568b9 100644
--- a/src/stable/nullstream.cpp
+++ b/src/stable/nullstream.cpp
@@ -8,8 +8,8 @@
 #include "bu/nullstream.h"
 
 Bu::NullStream::NullStream() :
-        sRead( 0 ),
-        sWrote( 0 )
+    sRead( 0 ),
+    sWrote( 0 )
 {
 }
 
@@ -19,31 +19,31 @@ Bu::NullStream::~NullStream()
 
 void Bu::NullStream::close()
 {
-        sRead = sWrote = 0;
+    sRead = sWrote = 0;
 }
 
 Bu::size Bu::NullStream::read( void *pBuf, Bu::size nBytes )
 {
-        memset( pBuf, 0, nBytes );
-        sRead += nBytes;
-        return nBytes;
+    memset( pBuf, 0, nBytes );
+    sRead += nBytes;
+    return nBytes;
 }
 
 Bu::String Bu::NullStream::readLine()
 {
-        sRead++;
-        return Bu::String("\0", 1 );
+    sRead++;
+    return Bu::String("\0", 1 );
 }
 
 Bu::size Bu::NullStream::write( const void *, Bu::size nBytes )
 {
-        sWrote += nBytes;
-        return nBytes;
+    sWrote += nBytes;
+    return nBytes;
 }
 
 Bu::size Bu::NullStream::tell()
 {
-        return sRead + sWrote;
+    return sRead + sWrote;
 }
 
 void Bu::NullStream::seek( Bu::size )
@@ -60,12 +60,12 @@ void Bu::NullStream::setPosEnd( Bu::size )
 
 bool Bu::NullStream::isEos()
 {
-        return false;
+    return false;
 }
 
 bool Bu::NullStream::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::NullStream::flush()
@@ -74,32 +74,32 @@ void Bu::NullStream::flush()
 
 bool Bu::NullStream::canRead()
 {
-        return true;
+    return true;
 }
 
 bool Bu::NullStream::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::NullStream::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::NullStream::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::NullStream::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::NullStream::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::NullStream::setBlocking( bool )
@@ -112,16 +112,16 @@ void Bu::NullStream::setSize( Bu::size )
 
 Bu::size Bu::NullStream::getSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::NullStream::getBlockSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::String Bu::NullStream::getLocation() const
 {
-        return "";
+    return "";
 }
 
diff --git a/src/stable/nullstream.h b/src/stable/nullstream.h
index 034b0c5..a8b24e3 100644
--- a/src/stable/nullstream.h
+++ b/src/stable/nullstream.h
@@ -12,56 +12,56 @@
 
 namespace Bu
 {
-        /**
-         * Works a lot like /dev/null on *nix style systems.  This class allows
-         * infinite reading and writing.  All operatorns "succeed" even if they
-         * don't seem to do anything.  This is great for testing writing code or
-         * doing dry runs.  When reading, it will produce NULL bytes, so any
-         * application that would like the ability to produce null streams as a
-         * snap-in replacement for any other Bu::Stream, this is the right option.
-         *
-         * As an added feature, the NullStream will track how many bytes it was
-         * asked to read and write, allowing you to use it to determine how many
-         * bytes a write opretion would use without actually writing anything.
-         */
-        class NullStream : public Bu::Stream
-        {
-        public:
-                NullStream();
-                virtual ~NullStream();
+    /**
+     * Works a lot like /dev/null on *nix style systems.  This class allows
+     * infinite reading and writing.  All operatorns "succeed" even if they
+     * don't seem to do anything.  This is great for testing writing code or
+     * doing dry runs.  When reading, it will produce NULL bytes, so any
+     * application that would like the ability to produce null streams as a
+     * snap-in replacement for any other Bu::Stream, this is the right option.
+     *
+     * As an added feature, the NullStream will track how many bytes it was
+     * asked to read and write, allowing you to use it to determine how many
+     * bytes a write opretion would use without actually writing anything.
+     */
+    class NullStream : public Bu::Stream
+    {
+    public:
+        NullStream();
+        virtual ~NullStream();
 
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::String readLine();
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Bu::Stream::write;
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::String readLine();
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Bu::Stream::write;
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-                Bu::size getBytesRead() { return sRead; }
-                Bu::size getByetsWritten() { return sWrote; }
+        Bu::size getBytesRead() { return sRead; }
+        Bu::size getByetsWritten() { return sWrote; }
 
-        private:
-                Bu::size sRead;
-                Bu::size sWrote;
-        };
+    private:
+        Bu::size sRead;
+        Bu::size sWrote;
+    };
 };
 
 #endif
diff --git a/src/stable/optparser.cpp b/src/stable/optparser.cpp
index 10a8fb6..aca36a2 100644
--- a/src/stable/optparser.cpp
+++ b/src/stable/optparser.cpp
@@ -21,168 +21,168 @@ Bu::OptParser::~OptParser()
 
 void Bu::OptParser::parse( int argc, char **argv )
 {
-        for( int j = 1; j < argc; j++ )
-        {
-                if( argv[j][0] == '-' )
-                {
-                        // Now we're on to something, which kind is it?
-                        if( argv[j][1] == '-' )
-                        {
-                                int iEPos;
-                                for( iEPos = 2; argv[j][iEPos] != '\0' &&
-                                         argv[j][iEPos] != '='; iEPos++ ) { }
-
-                                Bu::String sOpt;
-                                int iCount = argc-j;
-                                Bu::String sExtraParam;
-                                if( argv[j][iEPos] == '=' )
-                                {
-                                        sOpt.set( argv[j]+2, iEPos-2 );
-                                        iCount++;
-                                        sExtraParam.set( argv[j]+iEPos+1 );
-                                }
-                                else
-                                {
-                                        sOpt.set( argv[j]+2 );
-                                }
-                                if( !hlOption.has( sOpt ) )
-                                {
-                                        optionError( "--" + sOpt );
-                                }
-                                else
-                                {
-                                        // Long param, cool, that's easy, first search for =
-                                        Option *pOpt = hlOption.get( sOpt );
-                                        if( pOpt->sUsed )
-                                        {
-                                                Bu::StrArray aParams( iCount );
-                                                aParams.append( sOpt );
-                                                if( sExtraParam.isSet() )
-                                                {
-                                                        aParams.append( argv[j]+iEPos+1 );
-                                                }
-                                                for( int k = j+1; k < argc; k++ )
-                                                {
-                                                        aParams.append( argv[k] );
-                                                }
-                                                j += pOpt->sUsed( aParams );
-                                        }
-                                        else if( pOpt->pProxy )
-                                        {
-                                                if( pOpt->sOverride.isSet() )
-                                                {
-                                                        pOpt->pProxy->setValue( pOpt->sOverride );
-                                                }
-                                                else if( sExtraParam.isSet() )
-                                                {
-                                                        pOpt->pProxy->setValueFromStr( sExtraParam );
-                                                }
-                                                else if( argv[j+1] != '\0' )
-                                                {
-                                                        pOpt->pProxy->setValueFromStr( argv[j+1] );
-                                                        j++;
-                                                }
-                                        }
-                                }
-                        }
-                        else
-                        {
-                                int iCPos;
-                                for( iCPos = 1; argv[j][iCPos] != '\0'; iCPos++ )
-                                {
-                                        if( !hsOption.has( argv[j][iCPos] ) )
-                                        {
-                                                Bu::String sOpt("-");
-                                                sOpt += argv[j][iCPos];
-                                                optionError( sOpt );
-                                        }
-                                        else
-                                        {
-                                                Option *pOpt = hsOption.get( argv[j][iCPos] );
-                                                char buf[2] = {argv[j][iCPos], '\0'};
-                                                if( pOpt->sUsed )
-                                                {
-                                                        Bu::StrArray aParams( argc-j+1 );
-                                                        aParams.append( buf );
-                                                        int iMod = 0;
-                                                        if( argv[j][iCPos+1] != '\0' )
-                                                        {
-                                                                aParams.append( argv[j]+iCPos+1 );
-                                                                iMod = -1;
-                                                        }
-                                                        for( int k = j+1; k < argc; k++ )
-                                                        {
-                                                                aParams.append( argv[k] );
-                                                        }
-                                                        int iUsed = pOpt->sUsed( aParams );
-                                                        if( iUsed > 0 )
-                                                        {
-                                                                j += iUsed + iMod;
-                                                                break;
-                                                        }
-                                                }
-                                                else if( pOpt->pProxy )
-                                                {
-                                                        if( pOpt->sOverride.isSet() )
-                                                        {
-                                                                pOpt->pProxy->setValue( pOpt->sOverride );
-                                                        }
-                                                        else if( argv[j][iCPos+1] != '\0' )
-                                                        {
-                                                                pOpt->pProxy->setValueFromStr(
-                                                                        argv[j]+iCPos+1
-                                                                        );
-                                                                break;
-                                                        }
-                                                        else if( argv[j+1] )
-                                                        {
-                                                                pOpt->pProxy->setValueFromStr(
-                                                                        argv[j+1]
-                                                                        );
-                                                                j++;
-                                                                break;
-                                                        }
-                                                }
-                                        }
-                                }
-                        }
-                }
-                else
-                {
-                        if( !sNonOption )
-                        {
-                                optionError( argv[j] );
-                        }
-                        else
-                        {
-                                int iCount = argc-j;
-                                Bu::StrArray aParams( iCount );
-                                for( int k = j; k < argc; k++ )
-                                {
-                                        aParams.append( argv[k] );
-                                }
-                                j += sNonOption( aParams );
-                        }
-                }
-        }
+    for( int j = 1; j < argc; j++ )
+    {
+        if( argv[j][0] == '-' )
+        {
+            // Now we're on to something, which kind is it?
+            if( argv[j][1] == '-' )
+            {
+                int iEPos;
+                for( iEPos = 2; argv[j][iEPos] != '\0' &&
+                     argv[j][iEPos] != '='; iEPos++ ) { }
+
+                Bu::String sOpt;
+                int iCount = argc-j;
+                Bu::String sExtraParam;
+                if( argv[j][iEPos] == '=' )
+                {
+                    sOpt.set( argv[j]+2, iEPos-2 );
+                    iCount++;
+                    sExtraParam.set( argv[j]+iEPos+1 );
+                }
+                else
+                {
+                    sOpt.set( argv[j]+2 );
+                }
+                if( !hlOption.has( sOpt ) )
+                {
+                    optionError( "--" + sOpt );
+                }
+                else
+                {
+                    // Long param, cool, that's easy, first search for =
+                    Option *pOpt = hlOption.get( sOpt );
+                    if( pOpt->sUsed )
+                    {
+                        Bu::StrArray aParams( iCount );
+                        aParams.append( sOpt );
+                        if( sExtraParam.isSet() )
+                        {
+                            aParams.append( argv[j]+iEPos+1 );
+                        }
+                        for( int k = j+1; k < argc; k++ )
+                        {
+                            aParams.append( argv[k] );
+                        }
+                        j += pOpt->sUsed( aParams );
+                    }
+                    else if( pOpt->pProxy )
+                    {
+                        if( pOpt->sOverride.isSet() )
+                        {
+                            pOpt->pProxy->setValue( pOpt->sOverride );
+                        }
+                        else if( sExtraParam.isSet() )
+                        {
+                            pOpt->pProxy->setValueFromStr( sExtraParam );
+                        }
+                        else if( argv[j+1] != '\0' )
+                        {
+                            pOpt->pProxy->setValueFromStr( argv[j+1] );
+                            j++;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                int iCPos;
+                for( iCPos = 1; argv[j][iCPos] != '\0'; iCPos++ )
+                {
+                    if( !hsOption.has( argv[j][iCPos] ) )
+                    {
+                        Bu::String sOpt("-");
+                        sOpt += argv[j][iCPos];
+                        optionError( sOpt );
+                    }
+                    else
+                    {
+                        Option *pOpt = hsOption.get( argv[j][iCPos] );
+                        char buf[2] = {argv[j][iCPos], '\0'};
+                        if( pOpt->sUsed )
+                        {
+                            Bu::StrArray aParams( argc-j+1 );
+                            aParams.append( buf );
+                            int iMod = 0;
+                            if( argv[j][iCPos+1] != '\0' )
+                            {
+                                aParams.append( argv[j]+iCPos+1 );
+                                iMod = -1;
+                            }
+                            for( int k = j+1; k < argc; k++ )
+                            {
+                                aParams.append( argv[k] );
+                            }
+                            int iUsed = pOpt->sUsed( aParams );
+                            if( iUsed > 0 )
+                            {
+                                j += iUsed + iMod;
+                                break;
+                            }
+                        }
+                        else if( pOpt->pProxy )
+                        {
+                            if( pOpt->sOverride.isSet() )
+                            {
+                                pOpt->pProxy->setValue( pOpt->sOverride );
+                            }
+                            else if( argv[j][iCPos+1] != '\0' )
+                            {
+                                pOpt->pProxy->setValueFromStr(
+                                    argv[j]+iCPos+1
+                                    );
+                                break;
+                            }
+                            else if( argv[j+1] )
+                            {
+                                pOpt->pProxy->setValueFromStr(
+                                    argv[j+1]
+                                    );
+                                j++;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+            if( !sNonOption )
+            {
+                optionError( argv[j] );
+            }
+            else
+            {
+                int iCount = argc-j;
+                Bu::StrArray aParams( iCount );
+                for( int k = j; k < argc; k++ )
+                {
+                    aParams.append( argv[k] );
+                }
+                j += sNonOption( aParams );
+            }
+        }
+    }
 }
 
 void Bu::OptParser::parse( const Bu::String &sLine )
 {
-        Bu::String sCmd = sLine.clone();
-        int iParams = 0;
-        bool bInGap = true;
-        bool bInQuote = false;
-        for( Bu::String::iterator i = sCmd.begin(); i; i++ )
-        {
-                if( bInQuote == false && (*i == ' ' || *i == '\t') )
-                {
-                        if( bInGap == false )
-                        {
-                                bInGap = true;
-                        }
-                }
-                else if( *i == '"' )
+    Bu::String sCmd = sLine.clone();
+    int iParams = 0;
+    bool bInGap = true;
+    bool bInQuote = false;
+    for( Bu::String::iterator i = sCmd.begin(); i; i++ )
+    {
+        if( bInQuote == false && (*i == ' ' || *i == '\t') )
+        {
+            if( bInGap == false )
+            {
+                bInGap = true;
+            }
+        }
+        else if( *i == '"' )
                 {
                         bInQuote = !bInQuote;
                 }
@@ -211,242 +211,242 @@ void Bu::OptParser::parse( const Bu::String &sLine )
                         }
                 }
                 else if( *i == '"' )
-                {
-                        bInQuote = !bInQuote;
-                }
-                else
-                {
-                        if( bInGap )
-                        {
-                                asParam[iParams++] = i;
-                                bInGap = false;
-                        }
-                }
-        }
-
-        parse( iParams, asParam );
-
-        delete[] asParam;
+        {
+            bInQuote = !bInQuote;
+        }
+        else
+        {
+            if( bInGap )
+            {
+                asParam[iParams++] = i;
+                bInGap = false;
+            }
+        }
+    }
+
+    parse( iParams, asParam );
+
+    delete[] asParam;
 }
 
 void Bu::OptParser::addOption( const Option &opt )
 {
-        lOption.append( opt );
-        if( opt.cOpt != '\0' )
-                hsOption.insert( opt.cOpt, &lOption.last() );
-        if( opt.sOpt.isSet() )
-                hlOption.insert( opt.sOpt, &lOption.last() );
+    lOption.append( opt );
+    if( opt.cOpt != '\0' )
+        hsOption.insert( opt.cOpt, &lOption.last() );
+    if( opt.sOpt.isSet() )
+        hlOption.insert( opt.sOpt, &lOption.last() );
 }
 
 void Bu::OptParser::setOverride( char cOpt, const Bu::Variant &sOverride )
 {
-        hsOption.get( cOpt )->sOverride = sOverride;
+    hsOption.get( cOpt )->sOverride = sOverride;
 }
 
 void Bu::OptParser::setOverride( const Bu::String &sOpt, const Bu::Variant &sOverride )
 {
-        hlOption.get( sOpt )->sOverride = sOverride;
+    hlOption.get( sOpt )->sOverride = sOverride;
 }
 
 void Bu::OptParser::setHelpDefault( const Bu::String &sOpt, const Bu::String &sTxt )
 {
-        hlOption.get( sOpt )->sHelpDefault = sTxt;
+    hlOption.get( sOpt )->sHelpDefault = sTxt;
 }
 
 void Bu::OptParser::addHelpOption( char c, const Bu::String &s, const Bu::String &sHelp )
 {
-        Option o;
-        o.sUsed = slot( this, &OptParser::optHelp );
-        o.cOpt = c;
-        o.sOpt = s;
-        o.sHelp = sHelp;
-        addOption( o );
+    Option o;
+    o.sUsed = slot( this, &OptParser::optHelp );
+    o.cOpt = c;
+    o.sOpt = s;
+    o.sHelp = sHelp;
+    addOption( o );
 }
 
 void Bu::OptParser::addHelpBanner( const Bu::String &sText, bool bFormatted )
 {
-        Banner b;
-        b.sText = sText;
-        b.bFormatted = bFormatted;
-        if( lOption.getSize() > 0 )
-        {
-                for( b.iAfter = lOption.begin(); b.iAfter+1; b.iAfter++ ) { }
-        }
-        lBanner.append( b );
+    Banner b;
+    b.sText = sText;
+    b.bFormatted = bFormatted;
+    if( lOption.getSize() > 0 )
+    {
+        for( b.iAfter = lOption.begin(); b.iAfter+1; b.iAfter++ ) { }
+    }
+    lBanner.append( b );
 }
 
 int Bu::OptParser::optHelp( StrArray /*aParams*/ )
 {
-        bool bHasShort = false;
-        int iMaxWidth = 0;
-        int iScrWidth = 80;
-        char *env = getenv("COLUMNS");
-        if( env )
-                iScrWidth = strtol( env, NULL, 10 );
-        for( OptionList::iterator i = lOption.begin(); i; i++ )
-        {
-                if( (*i).cOpt != '\0' )
-                        bHasShort = true;
-                int lOptSize = (*i).sOpt.getSize() + (*i).sHelpDefault.getSize();
-                if( (*i).sOpt.isSet() && iMaxWidth < lOptSize )
-                        iMaxWidth = lOptSize;
-        }
-        int iIndent = 4;
-        if( bHasShort )
-                iIndent += 4;
-        if( iMaxWidth > 0 )
-                iIndent += 4 + iMaxWidth;
-
-        BannerList::iterator iBanner;
-        for( iBanner = lBanner.begin(); iBanner; iBanner++ )
-        {
-                if( (*iBanner).iAfter )
-                        break;
-
-                if( (*iBanner).bFormatted )
-                        sio << format( (*iBanner).sText, iScrWidth-1, 0 );
-                else
-                        sio << (*iBanner).sText;
-                sio << sio.nl;
-        }
-        for( OptionList::iterator i = lOption.begin(); i; i++ )
-        {
-                sio << "    ";
-                if( bHasShort )
-                {
-                        if( (*i).cOpt == '\0' )
-                                sio << "  ";
-                        else
-                                sio << "-" << (*i).cOpt;
-                        sio << "  ";
-                }
-                if( iMaxWidth > 0 )
-                {
-                        if( (*i).sOpt.isSet() )
-                        {
-                                sio << "--" << Fmt(iMaxWidth, Fmt::Left)
-                                        << (*i).sOpt + (*i).sHelpDefault;
-                        }
-                        else
-                        {
-                                sio << "  " << Fmt(iMaxWidth) << "";
-                        }
-                        sio << "  ";
-                }
-                sio << format( (*i).sHelp, iScrWidth-iIndent-1, iIndent );
-                sio << sio.nl;
-        
-                for( ; iBanner; iBanner++ )
-                {
-                        if( (*iBanner).iAfter != i )
-                                break;
-                        
-                        if( (*iBanner).bFormatted )
-                                sio << format( (*iBanner).sText, iScrWidth-1, 0 );
-                        else
-                                sio << (*iBanner).sText;
-                        sio << sio.nl;
-                }
-        }
-        exit( 0 );
-        return 0;
+    bool bHasShort = false;
+    int iMaxWidth = 0;
+    int iScrWidth = 80;
+    char *env = getenv("COLUMNS");
+    if( env )
+        iScrWidth = strtol( env, NULL, 10 );
+    for( OptionList::iterator i = lOption.begin(); i; i++ )
+    {
+        if( (*i).cOpt != '\0' )
+            bHasShort = true;
+        int lOptSize = (*i).sOpt.getSize() + (*i).sHelpDefault.getSize();
+        if( (*i).sOpt.isSet() && iMaxWidth < lOptSize )
+            iMaxWidth = lOptSize;
+    }
+    int iIndent = 4;
+    if( bHasShort )
+        iIndent += 4;
+    if( iMaxWidth > 0 )
+        iIndent += 4 + iMaxWidth;
+
+    BannerList::iterator iBanner;
+    for( iBanner = lBanner.begin(); iBanner; iBanner++ )
+    {
+        if( (*iBanner).iAfter )
+            break;
+
+        if( (*iBanner).bFormatted )
+            sio << format( (*iBanner).sText, iScrWidth-1, 0 );
+        else
+            sio << (*iBanner).sText;
+        sio << sio.nl;
+    }
+    for( OptionList::iterator i = lOption.begin(); i; i++ )
+    {
+        sio << "    ";
+        if( bHasShort )
+        {
+            if( (*i).cOpt == '\0' )
+                sio << "  ";
+            else
+                sio << "-" << (*i).cOpt;
+            sio << "  ";
+        }
+        if( iMaxWidth > 0 )
+        {
+            if( (*i).sOpt.isSet() )
+            {
+                sio << "--" << Fmt(iMaxWidth, Fmt::Left)
+                    << (*i).sOpt + (*i).sHelpDefault;
+            }
+            else
+            {
+                sio << "  " << Fmt(iMaxWidth) << "";
+            }
+            sio << "  ";
+        }
+        sio << format( (*i).sHelp, iScrWidth-iIndent-1, iIndent );
+        sio << sio.nl;
+    
+        for( ; iBanner; iBanner++ )
+        {
+            if( (*iBanner).iAfter != i )
+                break;
+            
+            if( (*iBanner).bFormatted )
+                sio << format( (*iBanner).sText, iScrWidth-1, 0 );
+            else
+                sio << (*iBanner).sText;
+            sio << sio.nl;
+        }
+    }
+    exit( 0 );
+    return 0;
 }
 
 void Bu::OptParser::optionError( const Bu::String &sOption )
 {
-        sio << "Unregcognized option discovered: " << sOption << sio.nl << sio.nl;
-        exit( 1 );
+    sio << "Unregcognized option discovered: " << sOption << sio.nl << sio.nl;
+    exit( 1 );
 }
 
 void Bu::OptParser::setNonOption( OptionSignal sSignal )
 {
-        sNonOption = sSignal;
+    sNonOption = sSignal;
 }
 
 Bu::String Bu::OptParser::format( const Bu::String &sIn, int iWidth,
-                int iIndent )
+        int iIndent )
 {
-        Bu::String sOut;
-        Bu::String sIndent;
-        for( int j = 0; j < iIndent; j++ )
-                sIndent.append(" ", 1);
-        bool bFirst = true;
-        int iSpaceCount = 0;
-        bool bSpace = false;
-        int iPrevLineLen;
-        int iLineLen = 0;
-        Bu::String::const_iterator iLastSpace, iStart;
-        for( Bu::String::const_iterator i = iLastSpace = iStart = sIn.begin(); i; i++ )
-        {
-                if( *i == ' ' )
-                {
-                        if( bSpace == false )
-                        {
-                                iLastSpace = i;
-                                iSpaceCount++;
-                                bSpace = true;
-                                iPrevLineLen = iLineLen;
-                        }
-                }
-                else
-                {
-                        bSpace = false;
-                }
-                iLineLen++;
-
-                if( iLineLen >= iWidth )
-                {
-                        iSpaceCount--;
-                        if( bFirst == true )
-                                bFirst = false;
-                        else
-                                sOut += sIndent;
-                        int iExtraSpaces = iWidth-iPrevLineLen;
-                        bSpace = false;
-                        float fFill = 0.0;
-                        int iSubSpaceCount = 0;
-                        float fAdd = ((float)iExtraSpaces/(float)iSpaceCount);
-                        for( Bu::String::const_iterator k = iStart; k != iLastSpace; k++ )
-                        {
-                                sOut += *k;
-                                if( *k == ' ' )
-                                {
-                                        if( bSpace == false && iExtraSpaces > 0 )
-                                        {
-                                                bSpace = true;
-                                                fFill += fAdd;
-                                                iSubSpaceCount++;
-                                                for( int sp = 0; sp < (int)(fFill); sp++ )
-                                                {
-                                                        sOut += ' ';
-                                                        iExtraSpaces--;
-                                                }
-                                                fFill -= (int)fFill;
-                                                if( iSubSpaceCount == iSpaceCount && iExtraSpaces > 0 )
-                                                {
-                                                        for(; iExtraSpaces > 0; iExtraSpaces-- )
-                                                        {
-                                                                sOut += ' ';
-                                                        }
-                                                }
-                                        }
-                                }
-                                else
-                                        bSpace = false;
-                        }
-                        //sOut.append( iStart, iLastSpace );
-                        sOut.append("\n");
-                        for(; iLastSpace && *iLastSpace == ' '; iLastSpace++ ) { }
-                        iStart = i = iLastSpace;
-                        bSpace = false;
-                        iLineLen = 1;
-                        iSpaceCount = 0;
-                }
-        }
-        if( !bFirst )
-                sOut += sIndent;
-        sOut.append( iStart );
-        return sOut;
+    Bu::String sOut;
+    Bu::String sIndent;
+    for( int j = 0; j < iIndent; j++ )
+        sIndent.append(" ", 1);
+    bool bFirst = true;
+    int iSpaceCount = 0;
+    bool bSpace = false;
+    int iPrevLineLen;
+    int iLineLen = 0;
+    Bu::String::const_iterator iLastSpace, iStart;
+    for( Bu::String::const_iterator i = iLastSpace = iStart = sIn.begin(); i; i++ )
+    {
+        if( *i == ' ' )
+        {
+            if( bSpace == false )
+            {
+                iLastSpace = i;
+                iSpaceCount++;
+                bSpace = true;
+                iPrevLineLen = iLineLen;
+            }
+        }
+        else
+        {
+            bSpace = false;
+        }
+        iLineLen++;
+
+        if( iLineLen >= iWidth )
+        {
+            iSpaceCount--;
+            if( bFirst == true )
+                bFirst = false;
+            else
+                sOut += sIndent;
+            int iExtraSpaces = iWidth-iPrevLineLen;
+            bSpace = false;
+            float fFill = 0.0;
+            int iSubSpaceCount = 0;
+            float fAdd = ((float)iExtraSpaces/(float)iSpaceCount);
+            for( Bu::String::const_iterator k = iStart; k != iLastSpace; k++ )
+            {
+                sOut += *k;
+                if( *k == ' ' )
+                {
+                    if( bSpace == false && iExtraSpaces > 0 )
+                    {
+                        bSpace = true;
+                        fFill += fAdd;
+                        iSubSpaceCount++;
+                        for( int sp = 0; sp < (int)(fFill); sp++ )
+                        {
+                            sOut += ' ';
+                            iExtraSpaces--;
+                        }
+                        fFill -= (int)fFill;
+                        if( iSubSpaceCount == iSpaceCount && iExtraSpaces > 0 )
+                        {
+                            for(; iExtraSpaces > 0; iExtraSpaces-- )
+                            {
+                                sOut += ' ';
+                            }
+                        }
+                    }
+                }
+                else
+                    bSpace = false;
+            }
+            //sOut.append( iStart, iLastSpace );
+            sOut.append("\n");
+            for(; iLastSpace && *iLastSpace == ' '; iLastSpace++ ) { }
+            iStart = i = iLastSpace;
+            bSpace = false;
+            iLineLen = 1;
+            iSpaceCount = 0;
+        }
+    }
+    if( !bFirst )
+        sOut += sIndent;
+    sOut.append( iStart );
+    return sOut;
 }
 
 
@@ -467,26 +467,26 @@ Bu::OptParser::_ValueProxy::~_ValueProxy()
 //
 
 Bu::OptParser::Option::Option() :
-        cOpt( '\0' ),
-        pProxy( NULL )
+    cOpt( '\0' ),
+    pProxy( NULL )
 {
 }
 
 Bu::OptParser::Option::Option( const Option &rSrc ) :
-        cOpt( rSrc.cOpt ),
-        sOpt( rSrc.sOpt ),
-        sHelp( rSrc.sHelp ),
-        sUsed( rSrc.sUsed ),
-        pProxy( NULL ),
-        sOverride( rSrc.sOverride )
+    cOpt( rSrc.cOpt ),
+    sOpt( rSrc.sOpt ),
+    sHelp( rSrc.sHelp ),
+    sUsed( rSrc.sUsed ),
+    pProxy( NULL ),
+    sOverride( rSrc.sOverride )
 {
-        if( rSrc.pProxy )
-                pProxy = rSrc.pProxy->clone();
+    if( rSrc.pProxy )
+        pProxy = rSrc.pProxy->clone();
 }
 
 Bu::OptParser::Option::~Option()
 {
-        delete pProxy;
-        pProxy = NULL;
+    delete pProxy;
+    pProxy = NULL;
 }
 
diff --git a/src/stable/optparser.h b/src/stable/optparser.h
index 2da93c9..412f262 100644
--- a/src/stable/optparser.h
+++ b/src/stable/optparser.h
@@ -19,205 +19,205 @@
 
 namespace Bu
 {
-        typedef Bu::Array<Bu::String> StrArray;
-
-        /**
-         * POSIX/Gnu style command line parser.  Handles long and short options in
-         * a variety of fun and useful ways, along with singal based callbacks and
-         * automatic variable setting.  It's pretty easy to use, and very flexible.
-         *
-         * OptParser supports it's own builtin help mechanism which automatically
-         * enumerates the available options and their help in a well formatted and
-         * easy to read way, automatically formatting your help text per option and
-         * allows for addition "help banners" which can be placed wherever you
-         * would like.
-         */
-        class OptParser
-        {
-        private:
-                class _ValueProxy
-                {
-                public:
-                        _ValueProxy();
-                        virtual ~_ValueProxy();
-
-                        virtual void setValueFromStr( const Bu::String & )=0;
-                        virtual void setValue( const Bu::Variant &vVar )=0;
-                        virtual _ValueProxy *clone()=0;
-                };
-
-                template<typename ptype>
-                class ValueProxy : public _ValueProxy
-                {
-                public:
-                        ValueProxy( ptype &v ) :
-                                v( v )
-                        {
-                        }
-
-                        virtual ~ValueProxy()
-                        {
-                        }
-
-                        virtual void setValueFromStr( const Bu::String &sVal )
-                        {
-                                Bu::MemBuf mb( sVal );
-                                Bu::Formatter f( mb );
-                                f << Bu::Fmt().tokenize( false );
-                                f >> v;
-                        }
-
-                        virtual void setValue( const Bu::Variant &vVar )
-                        {
-                                if( vVar.getType() == typeid(ptype) )
-                                {
-                                        v = vVar.get<ptype>();
-                                }
-                                else if( vVar.getType() == typeid(Bu::String) )
-                                {
-                                        setValueFromStr( vVar.get<Bu::String>() );
-                                }
-                                else
-                                {
-                                        Bu::MemBuf mb;
-                                        Bu::Formatter f( mb );
-//                                      f << vVar;
-                                        setValueFromStr( mb.getString() );
-                                }
-                        }
-                        
-                        virtual _ValueProxy *clone()
-                        {
-                                return new ValueProxy<ptype>( v );
-                        }
-
-                private:
-                        ptype &v;
-                };
-
-        public:
-                typedef Signal1<int, StrArray> OptionSignal;
-                class Option
-                {
-                public:
-                        Option();
-                        Option( const Option &rSrc );
-                        virtual ~Option();
-
-                        char cOpt;
-                        Bu::String sOpt;
-                        Bu::String sHelp;
-                        OptionSignal sUsed;
-                        _ValueProxy *pProxy;
-                        Bu::Variant sOverride;
-                        Bu::String sHelpDefault;
-                };
-        
-        private:
-                typedef Bu::List<Option> OptionList;
-                typedef Bu::Hash<char, Option *> ShortOptionHash;
-                typedef Bu::Hash<Bu::String, Option *> LongOptionHash;
-                
-                class Banner
-                {
-                public:
-                        Bu::String sText;
-                        bool bFormatted;
-                        OptionList::const_iterator iAfter;
-                };
-
-                typedef Bu::List<Banner> BannerList;
-
-        public:
-                OptParser();
-                virtual ~OptParser();
-
-                void parse( int argc, char **argv );
-                void parse( const Bu::String &sLine );
-
-                void addOption( const Option &opt );
-                
-                template<typename vtype>
-                void addOption( vtype &var, char cOpt, const Bu::String &sOpt,
-                                const Bu::String &sHelp )
-                {
-                        Option o;
-                        o.cOpt = cOpt;
-                        o.sOpt = sOpt;
-                        o.pProxy = new ValueProxy<vtype>( var );
-                        o.sHelp = sHelp;
-                        addOption( o );
-                }
-                
-                template<typename vtype>
-                void addOption( vtype &var, const Bu::String &sOpt,
-                                const Bu::String &sHelp )
-                {
-                        addOption( var, '\0', sOpt, sHelp );
-                }
-                
-                template<typename vtype>
-                void addOption( vtype &var, char cOpt, const Bu::String &sHelp )
-                {
-                        addOption( var, cOpt, "", sHelp );
-                }
-
-                void addOption( OptionSignal sUsed, char cOpt, const Bu::String &sOpt,
-                                const Bu::String &sHelp )
-                {
-                        Option o;
-                        o.cOpt = cOpt;
-                        o.sOpt = sOpt;
-                        o.sUsed = sUsed;
-                        o.sHelp = sHelp;
-                        addOption( o );
-                }
-                
-                void addOption( OptionSignal sUsed, const Bu::String &sOpt,
-                                const Bu::String &sHelp )
-                {
-                        addOption( sUsed, '\0', sOpt, sHelp );
-                }
-                
-                void addOption( OptionSignal sUsed, char cOpt,
-                                const Bu::String &sHelp )
-                {
-                        addOption( sUsed, cOpt, "", sHelp );
-                }
-
-                void setOverride( char cOpt, const Bu::Variant &sOverride );
-                void setOverride( const Bu::String &sOpt,
-                                const Bu::Variant &sOverride );
-
-                void setHelpDefault( const Bu::String &sOpt, const Bu::String &sTxt );
-                
-                void addHelpOption( char c='h', const Bu::String &s="help",
-                                const Bu::String &sHelp="This help." );
-                void addHelpBanner( const Bu::String &sText, bool bFormatted=true );
-
-                int optHelp( StrArray aParams );
-
-                /**
-                 * This function is called when an unrecognized option is found, the
-                 * default behaviour is to print an error to stdout and exit( 1 ), if
-                 * you want to do something different, just override this function.
-                 * This is also called by default when something is found that hasn't
-                 * been handled by an option, and isn't an option (starts with - or --).
-                 * To change this behaviour call 
-                 */
-                virtual void optionError( const Bu::String &sOption );
-
-                void setNonOption( OptionSignal sSignal );
-
-        private:
-                Bu::String format( const Bu::String &sIn, int iWidth, int iIndent );
-
-                OptionList lOption;
-                ShortOptionHash hsOption;
-                LongOptionHash hlOption;
-                BannerList lBanner;
-                OptionSignal sNonOption;
-        };
+    typedef Bu::Array<Bu::String> StrArray;
+
+    /**
+     * POSIX/Gnu style command line parser.  Handles long and short options in
+     * a variety of fun and useful ways, along with singal based callbacks and
+     * automatic variable setting.  It's pretty easy to use, and very flexible.
+     *
+     * OptParser supports it's own builtin help mechanism which automatically
+     * enumerates the available options and their help in a well formatted and
+     * easy to read way, automatically formatting your help text per option and
+     * allows for addition "help banners" which can be placed wherever you
+     * would like.
+     */
+    class OptParser
+    {
+    private:
+        class _ValueProxy
+        {
+        public:
+            _ValueProxy();
+            virtual ~_ValueProxy();
+
+            virtual void setValueFromStr( const Bu::String & )=0;
+            virtual void setValue( const Bu::Variant &vVar )=0;
+            virtual _ValueProxy *clone()=0;
+        };
+
+        template<typename ptype>
+        class ValueProxy : public _ValueProxy
+        {
+        public:
+            ValueProxy( ptype &v ) :
+                v( v )
+            {
+            }
+
+            virtual ~ValueProxy()
+            {
+            }
+
+            virtual void setValueFromStr( const Bu::String &sVal )
+            {
+                Bu::MemBuf mb( sVal );
+                Bu::Formatter f( mb );
+                f << Bu::Fmt().tokenize( false );
+                f >> v;
+            }
+
+            virtual void setValue( const Bu::Variant &vVar )
+            {
+                if( vVar.getType() == typeid(ptype) )
+                {
+                    v = vVar.get<ptype>();
+                }
+                else if( vVar.getType() == typeid(Bu::String) )
+                {
+                    setValueFromStr( vVar.get<Bu::String>() );
+                }
+                else
+                {
+                    Bu::MemBuf mb;
+                    Bu::Formatter f( mb );
+//                  f << vVar;
+                    setValueFromStr( mb.getString() );
+                }
+            }
+            
+            virtual _ValueProxy *clone()
+            {
+                return new ValueProxy<ptype>( v );
+            }
+
+        private:
+            ptype &v;
+        };
+
+    public:
+        typedef Signal1<int, StrArray> OptionSignal;
+        class Option
+        {
+        public:
+            Option();
+            Option( const Option &rSrc );
+            virtual ~Option();
+
+            char cOpt;
+            Bu::String sOpt;
+            Bu::String sHelp;
+            OptionSignal sUsed;
+            _ValueProxy *pProxy;
+            Bu::Variant sOverride;
+            Bu::String sHelpDefault;
+        };
+    
+    private:
+        typedef Bu::List<Option> OptionList;
+        typedef Bu::Hash<char, Option *> ShortOptionHash;
+        typedef Bu::Hash<Bu::String, Option *> LongOptionHash;
+        
+        class Banner
+        {
+        public:
+            Bu::String sText;
+            bool bFormatted;
+            OptionList::const_iterator iAfter;
+        };
+
+        typedef Bu::List<Banner> BannerList;
+
+    public:
+        OptParser();
+        virtual ~OptParser();
+
+        void parse( int argc, char **argv );
+        void parse( const Bu::String &sLine );
+
+        void addOption( const Option &opt );
+        
+        template<typename vtype>
+        void addOption( vtype &var, char cOpt, const Bu::String &sOpt,
+                const Bu::String &sHelp )
+        {
+            Option o;
+            o.cOpt = cOpt;
+            o.sOpt = sOpt;
+            o.pProxy = new ValueProxy<vtype>( var );
+            o.sHelp = sHelp;
+            addOption( o );
+        }
+        
+        template<typename vtype>
+        void addOption( vtype &var, const Bu::String &sOpt,
+                const Bu::String &sHelp )
+        {
+            addOption( var, '\0', sOpt, sHelp );
+        }
+        
+        template<typename vtype>
+        void addOption( vtype &var, char cOpt, const Bu::String &sHelp )
+        {
+            addOption( var, cOpt, "", sHelp );
+        }
+
+        void addOption( OptionSignal sUsed, char cOpt, const Bu::String &sOpt,
+                const Bu::String &sHelp )
+        {
+            Option o;
+            o.cOpt = cOpt;
+            o.sOpt = sOpt;
+            o.sUsed = sUsed;
+            o.sHelp = sHelp;
+            addOption( o );
+        }
+        
+        void addOption( OptionSignal sUsed, const Bu::String &sOpt,
+                const Bu::String &sHelp )
+        {
+            addOption( sUsed, '\0', sOpt, sHelp );
+        }
+        
+        void addOption( OptionSignal sUsed, char cOpt,
+                const Bu::String &sHelp )
+        {
+            addOption( sUsed, cOpt, "", sHelp );
+        }
+
+        void setOverride( char cOpt, const Bu::Variant &sOverride );
+        void setOverride( const Bu::String &sOpt,
+                const Bu::Variant &sOverride );
+
+        void setHelpDefault( const Bu::String &sOpt, const Bu::String &sTxt );
+        
+        void addHelpOption( char c='h', const Bu::String &s="help",
+                const Bu::String &sHelp="This help." );
+        void addHelpBanner( const Bu::String &sText, bool bFormatted=true );
+
+        int optHelp( StrArray aParams );
+
+        /**
+         * This function is called when an unrecognized option is found, the
+         * default behaviour is to print an error to stdout and exit( 1 ), if
+         * you want to do something different, just override this function.
+         * This is also called by default when something is found that hasn't
+         * been handled by an option, and isn't an option (starts with - or --).
+         * To change this behaviour call 
+         */
+        virtual void optionError( const Bu::String &sOption );
+
+        void setNonOption( OptionSignal sSignal );
+
+    private:
+        Bu::String format( const Bu::String &sIn, int iWidth, int iIndent );
+
+        OptionList lOption;
+        ShortOptionHash hsOption;
+        LongOptionHash hlOption;
+        BannerList lBanner;
+        OptionSignal sNonOption;
+    };
 };
 
 #endif
diff --git a/src/stable/pearsonhash.cpp b/src/stable/pearsonhash.cpp
index d4e82df..6f58470 100644
--- a/src/stable/pearsonhash.cpp
+++ b/src/stable/pearsonhash.cpp
@@ -9,28 +9,28 @@
 #include "bu/stream.h"
 
 uint8_t Bu::PearsonHash::aSBox[] = {
-        251, 175, 119, 215, 81, 14, 79, 191, 103, 49, 181, 143, 186, 157, 0,
-        232, 31, 32, 55, 60, 152, 58, 17, 237, 174, 70, 160, 144, 220, 90, 57,
-        223, 59, 3, 18, 140, 111, 166, 203, 196, 134, 243, 124, 95, 222, 179,
-        197, 65, 180, 48, 36, 15, 107, 46, 233, 130, 165, 30, 123, 161, 209, 23,
-        97, 16, 40, 91, 219, 61, 100, 10, 210, 109, 250, 127, 22, 138, 29, 108,
-        244, 67, 207, 9, 178, 204, 74, 98, 126, 249, 167, 116, 34, 77, 193,
-        200, 121, 5, 20, 113, 71, 35, 128, 13, 182, 94, 25, 226, 227, 199, 75,
-        27, 41, 245, 230, 224, 43, 225, 177, 26, 155, 150, 212, 142, 218, 115,
-        241, 73, 88, 105, 39, 114, 62, 255, 192, 201, 145, 214, 168, 158, 221,
-        148, 154, 122, 12, 84, 82, 163, 44, 139, 228, 236, 205, 242, 217, 11,
-        187, 146, 159, 64, 86, 239, 195, 42, 106, 198, 118, 112, 184, 172, 87,
-        2, 173, 117, 176, 229, 247, 253, 137, 185, 99, 164, 102, 147, 45, 66,
-        231, 52, 141, 211, 194, 206, 246, 238, 56, 110, 78, 248, 63, 240, 189,
-        93, 92, 51, 53, 183, 19, 171, 72, 50, 33, 104, 101, 69, 8, 252, 83, 120,
-        76, 135, 85, 54, 202, 125, 188, 213, 96, 235, 136, 208, 162, 129, 190,
-        132, 156, 38, 47, 1, 7, 254, 24, 4, 216, 131, 89, 21, 28, 133, 37, 153,
-        149, 80, 170, 68, 6, 169, 234, 151
+    251, 175, 119, 215, 81, 14, 79, 191, 103, 49, 181, 143, 186, 157, 0,
+    232, 31, 32, 55, 60, 152, 58, 17, 237, 174, 70, 160, 144, 220, 90, 57,
+    223, 59, 3, 18, 140, 111, 166, 203, 196, 134, 243, 124, 95, 222, 179,
+    197, 65, 180, 48, 36, 15, 107, 46, 233, 130, 165, 30, 123, 161, 209, 23,
+    97, 16, 40, 91, 219, 61, 100, 10, 210, 109, 250, 127, 22, 138, 29, 108,
+    244, 67, 207, 9, 178, 204, 74, 98, 126, 249, 167, 116, 34, 77, 193,
+    200, 121, 5, 20, 113, 71, 35, 128, 13, 182, 94, 25, 226, 227, 199, 75,
+    27, 41, 245, 230, 224, 43, 225, 177, 26, 155, 150, 212, 142, 218, 115,
+    241, 73, 88, 105, 39, 114, 62, 255, 192, 201, 145, 214, 168, 158, 221,
+    148, 154, 122, 12, 84, 82, 163, 44, 139, 228, 236, 205, 242, 217, 11,
+    187, 146, 159, 64, 86, 239, 195, 42, 106, 198, 118, 112, 184, 172, 87,
+    2, 173, 117, 176, 229, 247, 253, 137, 185, 99, 164, 102, 147, 45, 66,
+    231, 52, 141, 211, 194, 206, 246, 238, 56, 110, 78, 248, 63, 240, 189,
+    93, 92, 51, 53, 183, 19, 171, 72, 50, 33, 104, 101, 69, 8, 252, 83, 120,
+    76, 135, 85, 54, 202, 125, 188, 213, 96, 235, 136, 208, 162, 129, 190,
+    132, 156, 38, 47, 1, 7, 254, 24, 4, 216, 131, 89, 21, 28, 133, 37, 153,
+    149, 80, 170, 68, 6, 169, 234, 151
 };
 
 Bu::PearsonHash::PearsonHash()
 {
-        reset();
+    reset();
 }
 
 Bu::PearsonHash::~PearsonHash()
@@ -39,7 +39,7 @@ Bu::PearsonHash::~PearsonHash()
 
 void Bu::PearsonHash::reset()
 {
-        iValue = 0;
+    iValue = 0;
 }
 
 void Bu::PearsonHash::setSalt( const Bu::String & /*sSalt*/ )
@@ -48,19 +48,19 @@ void Bu::PearsonHash::setSalt( const Bu::String & /*sSalt*/ )
 
 void Bu::PearsonHash::addData( const void *sData, int iSize )
 {
-        for( int j = 0; j < iSize; j++ )
-        {
-                iValue = aSBox[ iValue^((unsigned char *)sData)[j] ];
-        }
+    for( int j = 0; j < iSize; j++ )
+    {
+        iValue = aSBox[ iValue^((unsigned char *)sData)[j] ];
+    }
 }
 
 Bu::String Bu::PearsonHash::getResult()
 {
-        return Bu::String((char)iValue);
+    return Bu::String((char)iValue);
 }
 
 void Bu::PearsonHash::writeResult( Stream &sOut )
 {
-        sOut.write( &iValue, 1 );
+    sOut.write( &iValue, 1 );
 }
 
diff --git a/src/stable/pearsonhash.h b/src/stable/pearsonhash.h
index ca377c1..ece1d40 100644
--- a/src/stable/pearsonhash.h
+++ b/src/stable/pearsonhash.h
@@ -12,35 +12,35 @@
 
 namespace Bu
 {
-        /**
-         * A pearson hash is a non-cryptographically secure hashing function that
-         * is very light on resources, very fast, and produces a single byte
-         * as it's output.  It is strongly dependant on every byte in the input,
-         * which means that it's a good choice for adding to short messages to
-         * ensure that the contents of the messages are unchanged.
-         *
-         * Pearson hash is named for it's inventor Peter K. Pearson who described
-         * it in his article "Fast hashing of variable-length text strings"
-         * published in 1990 by ACM.  I haven't read it, because you have to pay to
-         * get a copy :-P
-         */
-        class PearsonHash : public Bu::CryptoHash
-        {
-        public:
-                PearsonHash();
-                virtual ~PearsonHash();
+    /**
+     * A pearson hash is a non-cryptographically secure hashing function that
+     * is very light on resources, very fast, and produces a single byte
+     * as it's output.  It is strongly dependant on every byte in the input,
+     * which means that it's a good choice for adding to short messages to
+     * ensure that the contents of the messages are unchanged.
+     *
+     * Pearson hash is named for it's inventor Peter K. Pearson who described
+     * it in his article "Fast hashing of variable-length text strings"
+     * published in 1990 by ACM.  I haven't read it, because you have to pay to
+     * get a copy :-P
+     */
+    class PearsonHash : public Bu::CryptoHash
+    {
+    public:
+        PearsonHash();
+        virtual ~PearsonHash();
 
-                virtual void reset();
-                virtual void setSalt( const Bu::String &sSalt );
-                virtual void addData( const void *sData, int iSize );
-                using Bu::CryptoHash::addData;
-                virtual String getResult();
-                virtual void writeResult( Stream &sOut );
+        virtual void reset();
+        virtual void setSalt( const Bu::String &sSalt );
+        virtual void addData( const void *sData, int iSize );
+        using Bu::CryptoHash::addData;
+        virtual String getResult();
+        virtual void writeResult( Stream &sOut );
 
-        private:
-                static uint8_t aSBox[256];
-                uint8_t iValue;
-        };
+    private:
+        static uint8_t aSBox[256];
+        uint8_t iValue;
+    };
 };
 
 #endif
diff --git a/src/stable/plugger.h b/src/stable/plugger.h
index d9eaf34..424613f 100644
--- a/src/stable/plugger.h
+++ b/src/stable/plugger.h
@@ -24,59 +24,59 @@
 
 namespace Bu
 {
-        subExceptionDecl( PluginException );
+    subExceptionDecl( PluginException );
 
-        typedef struct PluginInfo
-        {
-                const char *sID;
-                const char *sAuthor;
-                unsigned short nVersion;
-                unsigned short nRevision;
-                void *(*createPlugin)();
-                void (*destroyPlugin)( void * );
-        } PluginInfo;
+    typedef struct PluginInfo
+    {
+        const char *sID;
+        const char *sAuthor;
+        unsigned short nVersion;
+        unsigned short nRevision;
+        void *(*createPlugin)();
+        void (*destroyPlugin)( void * );
+    } PluginInfo;
 
-        typedef struct PluginReg
-        {
-                bool bBuiltin;
+    typedef struct PluginReg
+    {
+        bool bBuiltin;
 #ifdef WIN32
-                HMODULE dlHandle;
+        HMODULE dlHandle;
 #else
-                void *dlHandle;
+        void *dlHandle;
 #endif
-                PluginInfo *pInfo;
-        } PluginReg;
+        PluginInfo *pInfo;
+    } PluginReg;
 
-#define PluginInterface( classname, baseclass, name, ver, rev )                 \
-        extern "C" {                                                                                                                    \
-                baseclass *create ##classname()                                                         \
-                {                                                                                                                                       \
-                        return new classname();                                                                                 \
-                }                                                                                                                                       \
-                void destroy ##classname( baseclass *pCls )                                     \
-                {                                                                                                                                       \
-                        delete pCls;                                                                                                    \
-                }                                                                                                                                       \
-                Bu::PluginInfo classname = {                                            \
-                        #classname, name, ver, rev,                                                                             \
-                        create ##classname, destroy ##classname };                                              \
-        }
+#define PluginInterface( classname, baseclass, name, ver, rev )         \
+    extern "C" {                                                            \
+        baseclass *create ##classname()                             \
+        {                                                                   \
+            return new classname();                                         \
+        }                                                                   \
+        void destroy ##classname( baseclass *pCls )                 \
+        {                                                                   \
+            delete pCls;                                                    \
+        }                                                                   \
+        Bu::PluginInfo classname = {                        \
+            #classname, name, ver, rev,                                     \
+            create ##classname, destroy ##classname };                      \
+    }
 
 #define PluginInterface2( pluginname, classname, baseclass, name, ver, rev ) \
-        extern "C" {                                                                                                                    \
-                baseclass *create ##classname()                                                                         \
-                {                                                                                                                                       \
-                        return new classname();                                                                                 \
-                }                                                                                                                                       \
-                void destroy ##classname( baseclass *pCls )                                                     \
-                {                                                                                                                                       \
-                        delete pCls;                                                                                                    \
-                }                                                                                                                                       \
-                Bu::PluginInfo pluginname = {                                                                                   \
-                        #pluginname, name, ver, rev,                                                                    \
-                        (void *(*)())(create ##classname),                                                              \
-                        (void (*)( void * ))(destroy ##classname) };                                    \
-        }
+    extern "C" {                                                            \
+        baseclass *create ##classname()                                     \
+        {                                                                   \
+            return new classname();                                         \
+        }                                                                   \
+        void destroy ##classname( baseclass *pCls )                         \
+        {                                                                   \
+            delete pCls;                                                    \
+        }                                                                   \
+        Bu::PluginInfo pluginname = {                                           \
+            #pluginname, name, ver, rev,                                    \
+            (void *(*)())(create ##classname),                              \
+            (void (*)( void * ))(destroy ##classname) };                    \
+    }
 
 //
 // This is probably the main interface to use, I'll describe it some here...
@@ -93,197 +93,197 @@ namespace Bu
 //   rev        - an integer revision number for the plugin
 //
 #define PluginInterface3( structname, pluginname, classname, baseclass, name, ver, rev ) \
-        extern "C" {                                                                                                                    \
-                baseclass *create ##classname()                                                                         \
-                {                                                                                                                                       \
-                        return new classname();                                                                                 \
-                }                                                                                                                                       \
-                void destroy ##classname( baseclass *pCls )                                                     \
-                {                                                                                                                                       \
-                        delete pCls;                                                                                                    \
-                }                                                                                                                                       \
-                Bu::PluginInfo structname = {                                                                                   \
-                        #pluginname, name, ver, rev,                                                                    \
-                        (void *(*)())(create ##classname),                                                              \
-                        (void (*)( void * ))(destroy ##classname) };                                    \
-        }
+    extern "C" {                                                            \
+        baseclass *create ##classname()                                     \
+        {                                                                   \
+            return new classname();                                         \
+        }                                                                   \
+        void destroy ##classname( baseclass *pCls )                         \
+        {                                                                   \
+            delete pCls;                                                    \
+        }                                                                   \
+        Bu::PluginInfo structname = {                                           \
+            #pluginname, name, ver, rev,                                    \
+            (void *(*)())(create ##classname),                              \
+            (void (*)( void * ))(destroy ##classname) };                    \
+    }
 
-        /**
-         * A complete dynamic plugin manager system.  This will allow you to design
-         * and use plugins that are compiled into your program and dynamically
-         * linked to your program interchangably.  It works on windows and on *nix
-         * and bsd type systems (anything that supports dlopen).  Basically you
-         * create a base class that will be the basic interface of your plugins.
-         * Then you create some classes that inherit from it, and use the
-         * PluginInterface3 macro to create the required data structures for it.
-         *
-         * Once you have plugins you can create a Plugger, by passing in the base
-         * class as it's template parameter.  Once it's created, you can register
-         * plugins.  To register a plugin that is builtin, you just need to pass
-         * a pointer to it's interface structure to the registerBuiltinPlugin
-         * function.  To register a plugin that is in a shared object or dll file
-         * you just pass the filename (with path, probably), and the name of the
-         * structure to load and you're all set.
-         *
-         * To instantiate an object from a plugin simply call instantiate with the
-         * name of the plugin as specified in the interface macro.  To destroy an
-         * object crated with the plugger do not delete it, instead pass it into
-         * Plugger's destroy function.
-         *
-         * Any objects not destroyed when the plugger is deleted will be destroyed
-         * automatically.
-         *
-         * It is important to note that some systems (linux at least) partition off
-         * the memory allocated by objects linked in at run time into a seperate
-         * segment that, while it can be accessed by the main program, cannot be
-         * safely or reliably freed by the main program.  With that in mind it is
-         * a good idea to free all memory allocated by a plugin object in the plugin
-         * object and not allow the calling program to delete it.
-         */
-        template<class T>
-        class Plugger
-        {
-        public:
-                typedef Bu::Hash<Bu::String, PluginReg *> PluginHash;
-                typedef Bu::Hash<ptrdiff_t, void *> InstHash;
+    /**
+     * A complete dynamic plugin manager system.  This will allow you to design
+     * and use plugins that are compiled into your program and dynamically
+     * linked to your program interchangably.  It works on windows and on *nix
+     * and bsd type systems (anything that supports dlopen).  Basically you
+     * create a base class that will be the basic interface of your plugins.
+     * Then you create some classes that inherit from it, and use the
+     * PluginInterface3 macro to create the required data structures for it.
+     *
+     * Once you have plugins you can create a Plugger, by passing in the base
+     * class as it's template parameter.  Once it's created, you can register
+     * plugins.  To register a plugin that is builtin, you just need to pass
+     * a pointer to it's interface structure to the registerBuiltinPlugin
+     * function.  To register a plugin that is in a shared object or dll file
+     * you just pass the filename (with path, probably), and the name of the
+     * structure to load and you're all set.
+     *
+     * To instantiate an object from a plugin simply call instantiate with the
+     * name of the plugin as specified in the interface macro.  To destroy an
+     * object crated with the plugger do not delete it, instead pass it into
+     * Plugger's destroy function.
+     *
+     * Any objects not destroyed when the plugger is deleted will be destroyed
+     * automatically.
+     *
+     * It is important to note that some systems (linux at least) partition off
+     * the memory allocated by objects linked in at run time into a seperate
+     * segment that, while it can be accessed by the main program, cannot be
+     * safely or reliably freed by the main program.  With that in mind it is
+     * a good idea to free all memory allocated by a plugin object in the plugin
+     * object and not allow the calling program to delete it.
+     */
+    template<class T>
+    class Plugger
+    {
+    public:
+        typedef Bu::Hash<Bu::String, PluginReg *> PluginHash;
+        typedef Bu::Hash<ptrdiff_t, void *> InstHash;
 
-        public:
-                Plugger()
-                {
-                }
+    public:
+        Plugger()
+        {
+        }
 
-                virtual ~Plugger()
-                {
-                        for( InstHash::iterator i = hObj.begin(); i != hObj.end(); i++ )
-                        {
-                                T *pPlug = (T *)i.getKey();
-                                PluginReg *pReg = (PluginReg *)*i;
-                                pReg->pInfo->destroyPlugin( pPlug );
-                        }
+        virtual ~Plugger()
+        {
+            for( InstHash::iterator i = hObj.begin(); i != hObj.end(); i++ )
+            {
+                T *pPlug = (T *)i.getKey();
+                PluginReg *pReg = (PluginReg *)*i;
+                pReg->pInfo->destroyPlugin( pPlug );
+            }
 
-                        for( PluginHash::iterator i = hPlugin.begin();
-                                 i != hPlugin.end(); i++ )
-                        {
-                                if( (*i)->bBuiltin == false )
-                                {
+            for( PluginHash::iterator i = hPlugin.begin();
+                 i != hPlugin.end(); i++ )
+            {
+                if( (*i)->bBuiltin == false )
+                {
 #ifdef WIN32
-                                        FreeLibrary( (*i)->dlHandle );
+                    FreeLibrary( (*i)->dlHandle );
 #else
-                                        dlclose( (*i)->dlHandle );
+                    dlclose( (*i)->dlHandle );
 #endif
-                                }
-                                delete (*i);
-                        }
-                }
+                }
+                delete (*i);
+            }
+        }
 
-                void registerBuiltinPlugin( PluginInfo *pInfo )
-                {
-                        PluginReg *pReg = new PluginReg;
-                        pReg->bBuiltin = true;
-                        pReg->pInfo = pInfo;
-                        hPlugin.insert( pInfo->sID, pReg );
-                }
+        void registerBuiltinPlugin( PluginInfo *pInfo )
+        {
+            PluginReg *pReg = new PluginReg;
+            pReg->bBuiltin = true;
+            pReg->pInfo = pInfo;
+            hPlugin.insert( pInfo->sID, pReg );
+        }
 
-                void registerExternalPlugin( const Bu::String &sFName,
-                                const Bu::String &sPluginName )
-                {
-                        PluginReg *pReg;
-                        if( hPlugin.has( sPluginName ) )
-                                throw Bu::ExceptionBase("A plugin with name '%s' is already "
-                                        "loaded.", sPluginName.getStr() );
+        void registerExternalPlugin( const Bu::String &sFName,
+                const Bu::String &sPluginName )
+        {
+            PluginReg *pReg;
+            if( hPlugin.has( sPluginName ) )
+                throw Bu::ExceptionBase("A plugin with name '%s' is already "
+                    "loaded.", sPluginName.getStr() );
 
-                        pReg = new PluginReg;
+            pReg = new PluginReg;
 
-                        pReg->bBuiltin = false;
+            pReg->bBuiltin = false;
 #ifdef WIN32
-                        pReg->dlHandle = LoadLibrary( sFName.getStr() );
-                        if( pReg->dlHandle == NULL )
-                        {
-                                throw PluginException( 1, "Error opening %s: %s",
-                                        sFName.getStr(), Bu::getLastWinError().getStr() );
-                        }
-                        pReg->pInfo = (PluginInfo *)GetProcAddress( pReg->dlHandle,
-                                        sPluginName.getStr() );
-                        if( pReg->pInfo == NULL )
-                        {
-                                throw PluginException( 2, "Error mapping %s: %s",
-                                        sFName.getStr(), Bu::getLastWinError().getStr() );
-                        }
+            pReg->dlHandle = LoadLibrary( sFName.getStr() );
+            if( pReg->dlHandle == NULL )
+            {
+                throw PluginException( 1, "Error opening %s: %s",
+                    sFName.getStr(), Bu::getLastWinError().getStr() );
+            }
+            pReg->pInfo = (PluginInfo *)GetProcAddress( pReg->dlHandle,
+                    sPluginName.getStr() );
+            if( pReg->pInfo == NULL )
+            {
+                throw PluginException( 2, "Error mapping %s: %s",
+                    sFName.getStr(), Bu::getLastWinError().getStr() );
+            }
 #else
-                        pReg->dlHandle = dlopen( sFName.getStr(), RTLD_NOW );
-                        if( pReg->dlHandle == NULL )
-                        {
-                                throw PluginException( 1, "Error opening %s: %s",
-                                        sFName.getStr(), dlerror() );
-                        }
-                        pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle,
-                                        sPluginName.getStr() );
-                        if( pReg->pInfo == NULL )
-                        {
-                                throw PluginException( 2, "Error mapping %s: %s",
-                                        sFName.getStr(), dlerror() );
-                        }
+            pReg->dlHandle = dlopen( sFName.getStr(), RTLD_NOW );
+            if( pReg->dlHandle == NULL )
+            {
+                throw PluginException( 1, "Error opening %s: %s",
+                    sFName.getStr(), dlerror() );
+            }
+            pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle,
+                    sPluginName.getStr() );
+            if( pReg->pInfo == NULL )
+            {
+                throw PluginException( 2, "Error mapping %s: %s",
+                    sFName.getStr(), dlerror() );
+            }
 #endif
-                        hPlugin.insert( pReg->pInfo->sID, pReg );
-                }
+            hPlugin.insert( pReg->pInfo->sID, pReg );
+        }
 
-                T *instantiate( const Bu::String &lpName )
-                {
-                        PluginReg *pReg = (PluginReg *)hPlugin[lpName];
-                        if( pReg == NULL )
-                                return NULL;
+        T *instantiate( const Bu::String &lpName )
+        {
+            PluginReg *pReg = (PluginReg *)hPlugin[lpName];
+            if( pReg == NULL )
+                return NULL;
 
-                        T *p = (T *)pReg->pInfo->createPlugin();
-                        hObj.insert( (ptrdiff_t)p, pReg );
-                        //printf("pReg:  %08X, pPlug: %08X\n", pReg, p );
-                
-                        return p;
-                }
+            T *p = (T *)pReg->pInfo->createPlugin();
+            hObj.insert( (ptrdiff_t)p, pReg );
+            //printf("pReg:  %08X, pPlug: %08X\n", pReg, p );
+        
+            return p;
+        }
 
-                bool hasPlugin( const Bu::String &lpName )
-                {
-                        return hPlugin.has( lpName );
-                }
+        bool hasPlugin( const Bu::String &lpName )
+        {
+            return hPlugin.has( lpName );
+        }
 
-                void destroy( T *pPlug )
-                {
-                        PluginReg *pReg = (PluginReg *)hObj.get((ptrdiff_t)pPlug);
-                        //printf("pReg:  %08X, pPlug: %08X\n", pReg, pPlug );
-                        if( pReg == NULL )
-                                return;
+        void destroy( T *pPlug )
+        {
+            PluginReg *pReg = (PluginReg *)hObj.get((ptrdiff_t)pPlug);
+            //printf("pReg:  %08X, pPlug: %08X\n", pReg, pPlug );
+            if( pReg == NULL )
+                return;
 
-                        pReg->pInfo->destroyPlugin( pPlug );
+            pReg->pInfo->destroyPlugin( pPlug );
 
-                        hObj.erase( (ptrdiff_t)pPlug );
-                }
+            hObj.erase( (ptrdiff_t)pPlug );
+        }
 
-                void unloadAll()
-                {
-                        for( PluginHash::iterator i = hPlugin.begin();
-                                 i != hPlugin.end(); i++ )
-                        {
-                                if( (*i)->bBuiltin == false )
-                                {
+        void unloadAll()
+        {
+            for( PluginHash::iterator i = hPlugin.begin();
+                 i != hPlugin.end(); i++ )
+            {
+                if( (*i)->bBuiltin == false )
+                {
 #ifdef WIN32
-                                        FreeLibrary( (*i)->dlHandle );
+                    FreeLibrary( (*i)->dlHandle );
 #else
-                                        dlclose( (*i)->dlHandle );
+                    dlclose( (*i)->dlHandle );
 #endif
-                                }
-                                delete (*i);
-                        }
-                        hPlugin.clear();
-                }
+                }
+                delete (*i);
+            }
+            hPlugin.clear();
+        }
 
-                Bu::List<Bu::String> getPluginList()
-                {
-                        return hPlugin.getKeys();
-                }
+        Bu::List<Bu::String> getPluginList()
+        {
+            return hPlugin.getKeys();
+        }
 
-        private:
-                PluginHash hPlugin;
-                InstHash hObj;
-        };
+    private:
+        PluginHash hPlugin;
+        InstHash hObj;
+    };
 }
 
 #endif
diff --git a/src/stable/process.cpp b/src/stable/process.cpp
index a1adb23..a88ee7c 100644
--- a/src/stable/process.cpp
+++ b/src/stable/process.cpp
@@ -27,422 +27,422 @@
 
 Bu::Process::ProcData::ProcData() :
 #ifdef WIN32
-        hStdIn( NULL ),
-        hStdOut( NULL ),
-        hStdErr( NULL )
+    hStdIn( NULL ),
+    hStdOut( NULL ),
+    hStdErr( NULL )
 #else
-        iStdIn( -1 ),
-        iStdOut( -1 ),
-        iStdErr( -1 )
+    iStdIn( -1 ),
+    iStdOut( -1 ),
+    iStdErr( -1 )
 #endif
 {
 }
 
 
 Bu::Process::Process( Flags eFlags, const char *sName, char *const argv[] ) :
-        iProcStatus( 0 ),
-        bBlocking( true ),
-        bStdOutEos( true ),
-        bStdErrEos( true )
+    iProcStatus( 0 ),
+    bBlocking( true ),
+    bStdOutEos( true ),
+    bStdErrEos( true )
 {
-        gexec( eFlags, sName, argv );
+    gexec( eFlags, sName, argv );
 }
 
 Bu::Process::Process( Flags eFlags, const char *sName, const char *argv, ...) :
-        iProcStatus( 0 ),
-        bBlocking( true ),
-        bStdOutEos( true ),
-        bStdErrEos( true )
-{
-        int iCnt = 0;
-        va_list ap;
-        va_start( ap, argv );
-        for(; va_arg( ap, const char *); iCnt++ ) { }
-        va_end( ap );
-
-        char const **list = new char const *[iCnt+2];
-        va_start( ap, argv );
-        list[0] = argv;
-        for( int j = 1; j <= iCnt; j++ )
-        {
-                list[j] = va_arg( ap, const char *);
-        }
-        list[iCnt+1] = NULL;
-        va_end( ap );
-
-        gexec( eFlags, sName, (char *const *)list );
-        delete[] list;
+    iProcStatus( 0 ),
+    bBlocking( true ),
+    bStdOutEos( true ),
+    bStdErrEos( true )
+{
+    int iCnt = 0;
+    va_list ap;
+    va_start( ap, argv );
+    for(; va_arg( ap, const char *); iCnt++ ) { }
+    va_end( ap );
+
+    char const **list = new char const *[iCnt+2];
+    va_start( ap, argv );
+    list[0] = argv;
+    for( int j = 1; j <= iCnt; j++ )
+    {
+        list[j] = va_arg( ap, const char *);
+    }
+    list[iCnt+1] = NULL;
+    va_end( ap );
+
+    gexec( eFlags, sName, (char *const *)list );
+    delete[] list;
 }
 
 Bu::Process::Process( Flags eFlags, const Bu::Process::Options &opt, const char *sName, char *const argv[] ) :
-        iProcStatus( 0 ),
-        bBlocking( true ),
-        bStdOutEos( true ),
-        bStdErrEos( true ),
-        opt( opt )
+    iProcStatus( 0 ),
+    bBlocking( true ),
+    bStdOutEos( true ),
+    bStdErrEos( true ),
+    opt( opt )
 {
-        gexec( eFlags, sName, argv );
+    gexec( eFlags, sName, argv );
 }
 
 Bu::Process::Process( Flags eFlags, const Bu::Process::Options &opt, const char *sName, const char *argv, ...) :
-        iProcStatus( 0 ),
-        bBlocking( true ),
-        bStdOutEos( true ),
-        bStdErrEos( true ),
-        opt( opt )
-{
-        int iCnt = 0;
-        va_list ap;
-        va_start( ap, argv );
-        for(; va_arg( ap, const char *); iCnt++ ) { }
-        va_end( ap );
-
-        char const **list = new char const *[iCnt+2];
-        va_start( ap, argv );
-        list[0] = argv;
-        for( int j = 1; j <= iCnt; j++ )
-        {
-                list[j] = va_arg( ap, const char *);
-        }
-        list[iCnt+1] = NULL;
-        va_end( ap );
-
-        gexec( eFlags, sName, (char *const *)list );
-        delete[] list;
+    iProcStatus( 0 ),
+    bBlocking( true ),
+    bStdOutEos( true ),
+    bStdErrEos( true ),
+    opt( opt )
+{
+    int iCnt = 0;
+    va_list ap;
+    va_start( ap, argv );
+    for(; va_arg( ap, const char *); iCnt++ ) { }
+    va_end( ap );
+
+    char const **list = new char const *[iCnt+2];
+    va_start( ap, argv );
+    list[0] = argv;
+    for( int j = 1; j <= iCnt; j++ )
+    {
+        list[j] = va_arg( ap, const char *);
+    }
+    list[iCnt+1] = NULL;
+    va_end( ap );
+
+    gexec( eFlags, sName, (char *const *)list );
+    delete[] list;
 }
 
 Bu::Process::~Process()
 {
-        close();
+    close();
 }
 
 void Bu::Process::wait()
 {
-        close();
+    close();
 }
 
 void Bu::Process::gexec( Flags eFlags, const char *sName, char *const argv[] )
 {
 #ifdef WIN32
-        bStdErrEos = true;
-        SECURITY_ATTRIBUTES saAttr;
-        HANDLE hChildStd_IN_Rd;
-        HANDLE hChildStd_IN_Wr;
-        HANDLE hChildStd_OUT_Rd;
-        HANDLE hChildStd_OUT_Wr;
-        PROCESS_INFORMATION piProcInfo;
-
-        saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
-        saAttr.bInheritHandle = TRUE;
-        saAttr.lpSecurityDescriptor = NULL;
-
-        // Create a pipe for the child process's STDOUT. 
-        if ( ! CreatePipe(
-                                &hChildStd_OUT_Rd,
-                                &hChildStd_OUT_Wr,
-                                &saAttr, 0) ) 
-                throw "StdoutRd CreatePipe"; 
-
-        // Ensure the read handle to the pipe for STDOUT is not inherited.
-        if ( ! SetHandleInformation(
-                                hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) )
-                throw "Stdout SetHandleInformation"; 
-
-        // Create a pipe for the child process's STDIN. 
-        if (! CreatePipe(
-                                &hChildStd_IN_Rd,
-                                &hChildStd_IN_Wr,
-                                &saAttr, 0)) 
-                throw "Stdin CreatePipe"; 
-
-        // Ensure the write handle to the pipe for STDIN is not inherited. 
-        if ( ! SetHandleInformation(
-                                hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) )
-                throw "Stdin SetHandleInformation"; 
-
-        //TCHAR szCmdline[] = TEXT( sName );
-        //PROCESS_INFORMATION pd.piProcInfo; 
-        STARTUPINFO siStartInfo;
-        BOOL bSuccess = FALSE; 
-
-        // Set up members of the PROCESS_INFORMATION structure. 
-        ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
-
-        // Set up members of the STARTUPINFO structure. 
-        // This structure specifies the STDIN and STDOUT handles for redirection.
-        ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
-        siStartInfo.cb = sizeof(STARTUPINFO); 
-        siStartInfo.hStdError = hChildStd_OUT_Wr;
-        siStartInfo.hStdOutput = hChildStd_OUT_Wr;
-        siStartInfo.hStdInput = hChildStd_IN_Rd;
-        siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
-
-        Bu::String sCmd;
-        for( char *const *arg = argv; *arg; arg++ )
-        {
-                if( arg != argv )
-                        sCmd += " ";
-                sCmd += *arg;
-        }
-
-        // Create the child process. 
-        bSuccess = CreateProcessA(
-                sName, //sName,                         //module name
-                sCmd.getStr(), //(TCHAR *) sName, //szCmdline,     // command line 
-                NULL,          // process security attributes 
-                NULL,          // primary thread security attributes 
-                TRUE,          // handles are inherited 
-                CREATE_NO_WINDOW,             // creation flags 
-                NULL,          // use parent's environment 
-                NULL,          // use parent's current directory 
-                &siStartInfo,  // STARTUPINFO pointer 
-                &piProcInfo );  // receives PROCESS_INFORMATION 
-
-        // If an error occurs, exit the application. 
-        if ( ! bSuccess ) 
-        {
-                throw Bu::ExceptionBase("Error spawning child process.");
-                return;
-        }
-        else 
-        {
-                // Close handles to the child process and its primary thread.
-                // Some applications might keep these handles to monitor the status
-                // of the child process, for example. 
-                
-                //CloseHandle(pData->pd.piProcInfo.hProcess);
-                CloseHandle(piProcInfo.hThread);
-                pd.hProcess = piProcInfo.hProcess;
-
-                // Close the ends we can't use
-                CloseHandle( hChildStd_OUT_Wr );
-                CloseHandle( hChildStd_IN_Rd );
-                pd.hStdIn = hChildStd_IN_Wr;
-                pd.hStdOut = hChildStd_OUT_Rd;
-        }
+    bStdErrEos = true;
+    SECURITY_ATTRIBUTES saAttr;
+    HANDLE hChildStd_IN_Rd;
+    HANDLE hChildStd_IN_Wr;
+    HANDLE hChildStd_OUT_Rd;
+    HANDLE hChildStd_OUT_Wr;
+    PROCESS_INFORMATION piProcInfo;
+
+    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
+    saAttr.bInheritHandle = TRUE;
+    saAttr.lpSecurityDescriptor = NULL;
+
+    // Create a pipe for the child process's STDOUT. 
+    if ( ! CreatePipe(
+                &hChildStd_OUT_Rd,
+                &hChildStd_OUT_Wr,
+                &saAttr, 0) ) 
+        throw "StdoutRd CreatePipe"; 
+
+    // Ensure the read handle to the pipe for STDOUT is not inherited.
+    if ( ! SetHandleInformation(
+                hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) )
+        throw "Stdout SetHandleInformation"; 
+
+    // Create a pipe for the child process's STDIN. 
+    if (! CreatePipe(
+                &hChildStd_IN_Rd,
+                &hChildStd_IN_Wr,
+                &saAttr, 0)) 
+        throw "Stdin CreatePipe"; 
+
+    // Ensure the write handle to the pipe for STDIN is not inherited. 
+    if ( ! SetHandleInformation(
+                hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) )
+        throw "Stdin SetHandleInformation"; 
+
+    //TCHAR szCmdline[] = TEXT( sName );
+    //PROCESS_INFORMATION pd.piProcInfo; 
+    STARTUPINFO siStartInfo;
+    BOOL bSuccess = FALSE; 
+
+    // Set up members of the PROCESS_INFORMATION structure. 
+    ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
+
+    // Set up members of the STARTUPINFO structure. 
+    // This structure specifies the STDIN and STDOUT handles for redirection.
+    ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
+    siStartInfo.cb = sizeof(STARTUPINFO); 
+    siStartInfo.hStdError = hChildStd_OUT_Wr;
+    siStartInfo.hStdOutput = hChildStd_OUT_Wr;
+    siStartInfo.hStdInput = hChildStd_IN_Rd;
+    siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
+
+    Bu::String sCmd;
+    for( char *const *arg = argv; *arg; arg++ )
+    {
+        if( arg != argv )
+            sCmd += " ";
+        sCmd += *arg;
+    }
+
+    // Create the child process. 
+    bSuccess = CreateProcessA(
+        sName, //sName,             //module name
+        sCmd.getStr(), //(TCHAR *) sName, //szCmdline,     // command line 
+        NULL,          // process security attributes 
+        NULL,          // primary thread security attributes 
+        TRUE,          // handles are inherited 
+        CREATE_NO_WINDOW,             // creation flags 
+        NULL,          // use parent's environment 
+        NULL,          // use parent's current directory 
+        &siStartInfo,  // STARTUPINFO pointer 
+        &piProcInfo );  // receives PROCESS_INFORMATION 
+
+    // If an error occurs, exit the application. 
+    if ( ! bSuccess ) 
+    {
+        throw Bu::ExceptionBase("Error spawning child process.");
+        return;
+    }
+    else 
+    {
+        // Close handles to the child process and its primary thread.
+        // Some applications might keep these handles to monitor the status
+        // of the child process, for example. 
+        
+        //CloseHandle(pData->pd.piProcInfo.hProcess);
+        CloseHandle(piProcInfo.hThread);
+        pd.hProcess = piProcInfo.hProcess;
+
+        // Close the ends we can't use
+        CloseHandle( hChildStd_OUT_Wr );
+        CloseHandle( hChildStd_IN_Rd );
+        pd.hStdIn = hChildStd_IN_Wr;
+        pd.hStdOut = hChildStd_OUT_Rd;
+    }
 #else
-        int iaStdIn[2];
-        int iaStdOut[2];
-        int iaStdErr[2];
-        pipe( iaStdIn );
-        if( eFlags & StdOut )
-        {
-                pipe( iaStdOut );
-                pd.iStdOut = iaStdOut[0];
-                bStdOutEos = false;
-        }
-        if( eFlags & StdErr )
-        {
-                pipe( iaStdErr );
-                pd.iStdErr = iaStdErr[0];
-                bStdErrEos = false;
-        }
-
-        pd.iStdIn = iaStdIn[1];
-
-//      fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK );
-
-        pd.iPid = fork();
-        if( pd.iPid == 0 )
-        {
-                ::close( iaStdIn[1] );
-                dup2( iaStdIn[0], 0 );
-                if( eFlags & StdOut )
-                {
-                        ::close( iaStdOut[0] );
-                        dup2( iaStdOut[1], 1 );
-                }
-                if( eFlags & StdErr )
-                {
-                        ::close( iaStdErr[0] );
-                        dup2( iaStdErr[1], 2 );
-                }
-                if( (opt.eFlags&Options::SetGid) )
-                {
-                        setgid( opt.iGid );
-                }
-                if( (opt.eFlags&Options::SetUid) )
-                {
-                        setuid( opt.iUid );
-                }
-                execvp( sName, argv );
-                throw Bu::ExceptionBase("Hey, execvp failed!");
-        }
-        ::close( iaStdIn[0] );
-        if( eFlags & StdOut )
-                ::close( iaStdOut[1] );
-        if( eFlags & StdErr )
-                ::close( iaStdErr[1] );
+    int iaStdIn[2];
+    int iaStdOut[2];
+    int iaStdErr[2];
+    pipe( iaStdIn );
+    if( eFlags & StdOut )
+    {
+        pipe( iaStdOut );
+        pd.iStdOut = iaStdOut[0];
+        bStdOutEos = false;
+    }
+    if( eFlags & StdErr )
+    {
+        pipe( iaStdErr );
+        pd.iStdErr = iaStdErr[0];
+        bStdErrEos = false;
+    }
+
+    pd.iStdIn = iaStdIn[1];
+
+//  fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK );
+
+    pd.iPid = fork();
+    if( pd.iPid == 0 )
+    {
+        ::close( iaStdIn[1] );
+        dup2( iaStdIn[0], 0 );
+        if( eFlags & StdOut )
+        {
+            ::close( iaStdOut[0] );
+            dup2( iaStdOut[1], 1 );
+        }
+        if( eFlags & StdErr )
+        {
+            ::close( iaStdErr[0] );
+            dup2( iaStdErr[1], 2 );
+        }
+        if( (opt.eFlags&Options::SetGid) )
+        {
+            setgid( opt.iGid );
+        }
+        if( (opt.eFlags&Options::SetUid) )
+        {
+            setuid( opt.iUid );
+        }
+        execvp( sName, argv );
+        throw Bu::ExceptionBase("Hey, execvp failed!");
+    }
+    ::close( iaStdIn[0] );
+    if( eFlags & StdOut )
+        ::close( iaStdOut[1] );
+    if( eFlags & StdErr )
+        ::close( iaStdErr[1] );
 #endif
 }
 
 void Bu::Process::close()
 {
 #ifdef WIN32
-        if( pd.hStdIn )
-        {
-                CloseHandle( pd.hStdIn );
-                CloseHandle( pd.hStdOut );
-
-                pd.hStdIn = pd.hStdOut = pd.hStdErr = NULL;
-
-                if( !TerminateProcess(pd.hProcess, 1) )
-                {
-                        throw Bu::ExceptionBase("Error closing process.");
-                }
-                
-                GetExitCodeProcess( pd.hProcess, (PDWORD)&iProcStatus );
-
-                CloseHandle( pd.hProcess );
-                pd.hProcess = NULL;
-        }
+    if( pd.hStdIn )
+    {
+        CloseHandle( pd.hStdIn );
+        CloseHandle( pd.hStdOut );
+
+        pd.hStdIn = pd.hStdOut = pd.hStdErr = NULL;
+
+        if( !TerminateProcess(pd.hProcess, 1) )
+        {
+            throw Bu::ExceptionBase("Error closing process.");
+        }
+        
+        GetExitCodeProcess( pd.hProcess, (PDWORD)&iProcStatus );
+
+        CloseHandle( pd.hProcess );
+        pd.hProcess = NULL;
+    }
 #else
-        if( pd.iPid )
-        {
-                if( pd.iStdIn > -1 )
-                        ::close( pd.iStdIn );
-                if( pd.iStdOut > -1 )
-                        ::close( pd.iStdOut );
-                if( pd.iStdErr > -1 )
-                        ::close( pd.iStdErr );
-                waitpid( pd.iPid, &iProcStatus, 0 );
-                pd.iPid = 0;
-        }
+    if( pd.iPid )
+    {
+        if( pd.iStdIn > -1 )
+            ::close( pd.iStdIn );
+        if( pd.iStdOut > -1 )
+            ::close( pd.iStdOut );
+        if( pd.iStdErr > -1 )
+            ::close( pd.iStdErr );
+        waitpid( pd.iPid, &iProcStatus, 0 );
+        pd.iPid = 0;
+    }
 #endif
 }
 
 void Bu::Process::closeStdIn()
 {
 #ifdef WIN32
-        CloseHandle( pd.hStdIn );
-        pd.hStdIn = NULL;
+    CloseHandle( pd.hStdIn );
+    pd.hStdIn = NULL;
 #else
-        ::close( pd.iStdIn );
-        pd.iStdIn = -1;
+    ::close( pd.iStdIn );
+    pd.iStdIn = -1;
 #endif
 }
 
 void Bu::Process::closeStdOut()
 {
 #ifdef WIN32
-        CloseHandle( pd.hStdOut );
-        pd.hStdOut = NULL;
+    CloseHandle( pd.hStdOut );
+    pd.hStdOut = NULL;
 #else
-        ::close( pd.iStdOut );
-        pd.iStdOut = -1;
+    ::close( pd.iStdOut );
+    pd.iStdOut = -1;
 #endif
 }
 
 Bu::size Bu::Process::read( void *pBuf, Bu::size nBytes )
 {
 #ifdef WIN32
-        DWORD dwRead;
-        DWORD lExitCode;
-        BOOL bSuccess = FALSE;
-        DWORD dwLen = (DWORD) nBytes;
-        bSuccess = ReadFile(
-                        pd.hStdOut, (char *) pBuf,
-                        dwLen, &dwRead, NULL);
-//      if( dwRead < dwLen )
-        {
-                bSuccess = GetExitCodeProcess( pd.hProcess, &lExitCode );
-                if( lExitCode != STILL_ACTIVE )
-                {
-                        bStdOutEos = true;
-                }
-        }
-        return (int32_t) dwRead;
+    DWORD dwRead;
+    DWORD lExitCode;
+    BOOL bSuccess = FALSE;
+    DWORD dwLen = (DWORD) nBytes;
+    bSuccess = ReadFile(
+            pd.hStdOut, (char *) pBuf,
+            dwLen, &dwRead, NULL);
+//  if( dwRead < dwLen )
+    {
+        bSuccess = GetExitCodeProcess( pd.hProcess, &lExitCode );
+        if( lExitCode != STILL_ACTIVE )
+        {
+            bStdOutEos = true;
+        }
+    }
+    return (int32_t) dwRead;
 #else
-        if( bStdOutEos )
-                return 0;
-        fd_set rfds;
-        FD_ZERO( &rfds );
-        FD_SET( pd.iStdOut, &rfds );
-        struct timeval tv = {0, 0};
-        if( ::bu_select( pd.iStdOut+1, &rfds, NULL, NULL, &tv ) < 0 )
-                throw Bu::ExceptionBase( strerror( errno ) );
-        if( FD_ISSET( pd.iStdOut, &rfds ) || bBlocking )
-        {
-                Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdOut, pBuf, nBytes ) );
-                if( nRead == 0 )
-                {
-                        bStdOutEos = true;
-                        checkClose();
-                        return 0;
-                }
-                if( nRead < 0 )
-                {
-                        if( errno == EAGAIN )
-                                return 0;
-                        throw Bu::ExceptionBase( strerror( errno ) );
-                }
-                return nRead;
-        }
-        return 0;
+    if( bStdOutEos )
+        return 0;
+    fd_set rfds;
+    FD_ZERO( &rfds );
+    FD_SET( pd.iStdOut, &rfds );
+    struct timeval tv = {0, 0};
+    if( ::bu_select( pd.iStdOut+1, &rfds, NULL, NULL, &tv ) < 0 )
+        throw Bu::ExceptionBase( strerror( errno ) );
+    if( FD_ISSET( pd.iStdOut, &rfds ) || bBlocking )
+    {
+        Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdOut, pBuf, nBytes ) );
+        if( nRead == 0 )
+        {
+            bStdOutEos = true;
+            checkClose();
+            return 0;
+        }
+        if( nRead < 0 )
+        {
+            if( errno == EAGAIN )
+                return 0;
+            throw Bu::ExceptionBase( strerror( errno ) );
+        }
+        return nRead;
+    }
+    return 0;
 #endif
 }
 
 Bu::size Bu::Process::readErr( void *pBuf, Bu::size nBytes )
 {
 #ifdef WIN32
-        if( !pd.hStdErr )
-                return 0;
-        DWORD dwRead;
-        BOOL bSuccess = FALSE;
-        DWORD dwLen = (DWORD) nBytes;
-        bSuccess = ReadFile(
-                        pd.hStdErr, (char *) pBuf,
-                        dwLen, &dwRead, NULL);
-        return (int32_t) dwRead;
+    if( !pd.hStdErr )
+        return 0;
+    DWORD dwRead;
+    BOOL bSuccess = FALSE;
+    DWORD dwLen = (DWORD) nBytes;
+    bSuccess = ReadFile(
+            pd.hStdErr, (char *) pBuf,
+            dwLen, &dwRead, NULL);
+    return (int32_t) dwRead;
 #else
-        if( bStdErrEos )
-                return 0;
-        fd_set rfds;
-        FD_ZERO( &rfds );
-        FD_SET( pd.iStdErr, &rfds );
-        struct timeval tv = {0, 0};
-        if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, &tv ) < 0 )
-                throw Bu::ExceptionBase( strerror( errno ) );
-        if( FD_ISSET( pd.iStdErr, &rfds ) || bBlocking )
-        {
-                Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdErr, pBuf, nBytes ) );
-                if( nRead == 0 )
-                {
-                        bStdErrEos = true;
-                        checkClose();
-                        return 0;
-                }
-                if( nRead < 0 )
-                {
-                        if( errno == EAGAIN )
-                                return 0;
-                        throw Bu::ExceptionBase( strerror( errno ) );
-                }
-                return nRead;
-        }
-        return 0;
+    if( bStdErrEos )
+        return 0;
+    fd_set rfds;
+    FD_ZERO( &rfds );
+    FD_SET( pd.iStdErr, &rfds );
+    struct timeval tv = {0, 0};
+    if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, &tv ) < 0 )
+        throw Bu::ExceptionBase( strerror( errno ) );
+    if( FD_ISSET( pd.iStdErr, &rfds ) || bBlocking )
+    {
+        Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdErr, pBuf, nBytes ) );
+        if( nRead == 0 )
+        {
+            bStdErrEos = true;
+            checkClose();
+            return 0;
+        }
+        if( nRead < 0 )
+        {
+            if( errno == EAGAIN )
+                return 0;
+            throw Bu::ExceptionBase( strerror( errno ) );
+        }
+        return nRead;
+    }
+    return 0;
 #endif
 }
 
 Bu::size Bu::Process::write( const void *pBuf, Bu::size nBytes )
 {
 #ifdef WIN32
-        DWORD dwWritten;
-        BOOL bSuccess = FALSE;
-        DWORD dwLen = (DWORD) nBytes;
-        bSuccess = WriteFile( 
-                        pd.hStdIn, (const char *) pBuf,
-                        dwLen, &dwWritten, NULL );
-        FlushFileBuffers( pd.hStdIn );
-        return (int32_t) dwWritten;
+    DWORD dwWritten;
+    BOOL bSuccess = FALSE;
+    DWORD dwLen = (DWORD) nBytes;
+    bSuccess = WriteFile( 
+            pd.hStdIn, (const char *) pBuf,
+            dwLen, &dwWritten, NULL );
+    FlushFileBuffers( pd.hStdIn );
+    return (int32_t) dwWritten;
 #else
-        return TEMP_FAILURE_RETRY( ::write( pd.iStdIn, pBuf, nBytes ) );
+    return TEMP_FAILURE_RETRY( ::write( pd.iStdIn, pBuf, nBytes ) );
 #endif
 }
 
 Bu::size Bu::Process::tell()
 {
-        return 0;
+    return 0;
 }
 
 void Bu::Process::seek( Bu::size )
@@ -460,15 +460,15 @@ void Bu::Process::setPosEnd( Bu::size )
 bool Bu::Process::isEos()
 {
 #ifdef WIN32
-        return (pd.hProcess == NULL);
+    return (pd.hProcess == NULL);
 #else
-        return (pd.iPid == 0);
+    return (pd.iPid == 0);
 #endif
 }
 
 bool Bu::Process::isOpen()
 {
-        return !isEos();
+    return !isEos();
 }
 
 void Bu::Process::flush()
@@ -477,53 +477,53 @@ void Bu::Process::flush()
 
 bool Bu::Process::canRead()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Process::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Process::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Process::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Process::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::Process::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::Process::setBlocking( bool bBlocking )
 {
 #ifdef WIN32
 #else
-        if( bBlocking )
-        {
-                if( !bStdOutEos )
-                        fcntl( pd.iStdOut, F_SETFL, fcntl(pd.iStdOut,F_GETFL,0 )&(~O_NONBLOCK) );
-                if( !bStdErrEos )
-                        fcntl( pd.iStdErr, F_SETFL, fcntl(pd.iStdErr,F_GETFL,0 )&(~O_NONBLOCK) );
-        }
-        else
-        {
-                if( !bStdOutEos )
-                        fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK );
-                if( !bStdErrEos )
-                        fcntl( pd.iStdErr, F_SETFL, fcntl( pd.iStdErr, F_GETFL, 0 )|O_NONBLOCK );
-        }
-        this->bBlocking = bBlocking;
+    if( bBlocking )
+    {
+        if( !bStdOutEos )
+            fcntl( pd.iStdOut, F_SETFL, fcntl(pd.iStdOut,F_GETFL,0 )&(~O_NONBLOCK) );
+        if( !bStdErrEos )
+            fcntl( pd.iStdErr, F_SETFL, fcntl(pd.iStdErr,F_GETFL,0 )&(~O_NONBLOCK) );
+    }
+    else
+    {
+        if( !bStdOutEos )
+            fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK );
+        if( !bStdErrEos )
+            fcntl( pd.iStdErr, F_SETFL, fcntl( pd.iStdErr, F_GETFL, 0 )|O_NONBLOCK );
+    }
+    this->bBlocking = bBlocking;
 #endif
 }
 
@@ -533,128 +533,128 @@ void Bu::Process::setSize( Bu::size )
 
 Bu::size Bu::Process::getBlockSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::Process::getSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::String Bu::Process::getLocation() const
 {
-        return "";
+    return "";
 }
 
 void Bu::Process::select( bool &bStdOut, bool &bStdErr )
 {
 #ifdef WIN32
 #else
-        fd_set rfds;
-        FD_ZERO( &rfds );
-        if( !bStdOutEos )
-                FD_SET( pd.iStdOut, &rfds );
-        if( !bStdErrEos )
-                FD_SET( pd.iStdErr, &rfds );
-        if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, NULL ) < 0 )  
-                throw Bu::ExceptionBase( strerror( errno ) );
-
-        if( FD_ISSET( pd.iStdOut, &rfds ) )
-                bStdOut = true;
-        else
-                bStdOut = false;
-
-        if( FD_ISSET( pd.iStdErr, &rfds ) )
-                bStdErr = true;
-        else
-                bStdErr = false;
+    fd_set rfds;
+    FD_ZERO( &rfds );
+    if( !bStdOutEos )
+        FD_SET( pd.iStdOut, &rfds );
+    if( !bStdErrEos )
+        FD_SET( pd.iStdErr, &rfds );
+    if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, NULL ) < 0 )  
+        throw Bu::ExceptionBase( strerror( errno ) );
+
+    if( FD_ISSET( pd.iStdOut, &rfds ) )
+        bStdOut = true;
+    else
+        bStdOut = false;
+
+    if( FD_ISSET( pd.iStdErr, &rfds ) )
+        bStdErr = true;
+    else
+        bStdErr = false;
 #endif
 }
 
 bool Bu::Process::isRunning()
 {
 #ifdef WIN32
-        DWORD lExitCode;
-        GetExitCodeProcess( pd.hProcess, &lExitCode );
-        if( lExitCode != STILL_ACTIVE )
-                checkClose();
+    DWORD lExitCode;
+    GetExitCodeProcess( pd.hProcess, &lExitCode );
+    if( lExitCode != STILL_ACTIVE )
+        checkClose();
 #else
-        if( waitpid( pd.iPid, NULL, WNOHANG ) == pd.iPid )
-                checkClose();
+    if( waitpid( pd.iPid, NULL, WNOHANG ) == pd.iPid )
+        checkClose();
 #endif
-        return isOpen();
+    return isOpen();
 }
 
 void Bu::Process::ignoreStdErr()
 {
 #ifdef WIN32
 #else
-        if( pd.iStdErr == -1 )
-                return;
-        ::close( pd.iStdErr );
-        pd.iStdErr = -1;
-        bStdErrEos = true;
+    if( pd.iStdErr == -1 )
+        return;
+    ::close( pd.iStdErr );
+    pd.iStdErr = -1;
+    bStdErrEos = true;
 #endif
 }
 
 pid_t Bu::Process::getPid()
 {
 #ifdef WIN32
-        return 0;
+    return 0;
 #else
-        return pd.iPid;
+    return pd.iPid;
 #endif
 }
 
 bool Bu::Process::childExited()
 {
 #ifdef WIN32
-        return pd.hProcess != NULL;
+    return pd.hProcess != NULL;
 #else
-        return WIFEXITED( iProcStatus );
+    return WIFEXITED( iProcStatus );
 #endif
 }
 
 int Bu::Process::childExitStatus()
 {
 #ifdef WIN32
-        return iProcStatus;
+    return iProcStatus;
 #else
-        return WEXITSTATUS( iProcStatus );
+    return WEXITSTATUS( iProcStatus );
 #endif
 }
 
 bool Bu::Process::childSignaled()
 {
 #ifdef WIN32
-        return false;
+    return false;
 #else
-        return WIFSIGNALED( iProcStatus );
+    return WIFSIGNALED( iProcStatus );
 #endif
 }
 
 int Bu::Process::childSignal()
 {
 #ifdef WIN32
-        return 0;
+    return 0;
 #else
-        return WTERMSIG( iProcStatus );
+    return WTERMSIG( iProcStatus );
 #endif
 }
 
 bool Bu::Process::childCoreDumped()
 {
 #ifdef WIN32
-        return false;
+    return false;
 #else
-        return WCOREDUMP( iProcStatus );
+    return WCOREDUMP( iProcStatus );
 #endif
 }
 
 void Bu::Process::checkClose()
 {
-        if( bStdOutEos && bStdErrEos )
-        {
-                close();
-        }
+    if( bStdOutEos && bStdErrEos )
+    {
+        close();
+    }
 }
diff --git a/src/stable/process.h b/src/stable/process.h
index 904606a..72b686a 100644
--- a/src/stable/process.h
+++ b/src/stable/process.h
@@ -16,151 +16,151 @@
 
 namespace Bu
 {
-        /**
-         * Runs a program and attaches streams to it's stdin, stdout, and stderr.
-         * Reading from a Bu::Process will read from the program's standard output,
-         * writing to a Bu::Process will write to the program's standard input.
-         */
-        class Process : public Bu::Stream
-        {
-        public:
-                enum Flags
-                {
-                        None    =       0x00,
-                        StdOut  =       0x01,
-                        StdErr  =       0x02,
-                        Both    =       0x03
-                };
-
-        public:
-                class Options
-                {
-                public:
-                        enum OptFlags
-                        {
-                                None    = 0x00,
-                                SetUid  = 0x01,
-                                SetGid  = 0x02,
-                        };
-
-                        Options() : eFlags( None ) {}
-
-                        int eFlags;
-                        int iUid;
-                        int iGid;
-                };
-
-                Process( Flags eFlags, const char *sName, char *const argv[] );
-                Process( Flags eFlags, const char *sName, const char *argv, ...);
-                Process( Flags eFlags, const Options &opt, const char *sName, char *const argv[] );
-                Process( Flags eFlags, const Options &opt, const char *sName, const char *argv, ...);
-                virtual ~Process();
-
-                /**
-                 * Waits until the process exits.  This blocks the caller until the
-                 * child process terminates.
-                 */
-                void wait();
-
-                virtual void close();
-                virtual void closeStdIn();
-                virtual void closeStdOut();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size readErr( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
-
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-
-                virtual void flush();
-
-                virtual bool canRead();
-                virtual bool canWrite();
-
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-
-                virtual void setSize( Bu::size iSize );
-
-                virtual size getBlockSize() const;
-                virtual size getSize() const;
-                virtual Bu::String getLocation() const;
-
-                void select( bool &bStdOut, bool &bStdErr );
-
-                bool isRunning();
-                void ignoreStdErr();
-
-                /**
-                 * Returns the pid of the child process, or zero if there is no
-                 * currently running child.  Note that a read operation must be
-                 * performed in order to discover that the child has ended.
-                 */
-                pid_t getPid();
-
-                /**
-                 * Returns true if the child exited normally (by calling exit or
-                 * returning from main).
-                 */
-                bool childExited();
-
-                /**
-                 * Returns the 8 bit integer value returned from the child program if
-                 * childExited returned true.
-                 */
-                int childExitStatus();
-
-                /**
-                 * Returns true if the child exited because of a signal.
-                 */
-                bool childSignaled();
-
-                /**
-                 * Returns the signal ID if the childSignaled return true.
-                 */
-                int childSignal();
-
-                /**
-                 * Returns true if the child left a core dump behind when it exited.
-                 */
-                bool childCoreDumped();
-
-        private:
-                class ProcData
-                {
-                public:
-                        ProcData();
+    /**
+     * Runs a program and attaches streams to it's stdin, stdout, and stderr.
+     * Reading from a Bu::Process will read from the program's standard output,
+     * writing to a Bu::Process will write to the program's standard input.
+     */
+    class Process : public Bu::Stream
+    {
+    public:
+        enum Flags
+        {
+            None    =   0x00,
+            StdOut  =   0x01,
+            StdErr  =   0x02,
+            Both    =   0x03
+        };
+
+    public:
+        class Options
+        {
+        public:
+            enum OptFlags
+            {
+                None    = 0x00,
+                SetUid  = 0x01,
+                SetGid  = 0x02,
+            };
+
+            Options() : eFlags( None ) {}
+
+            int eFlags;
+            int iUid;
+            int iGid;
+        };
+
+        Process( Flags eFlags, const char *sName, char *const argv[] );
+        Process( Flags eFlags, const char *sName, const char *argv, ...);
+        Process( Flags eFlags, const Options &opt, const char *sName, char *const argv[] );
+        Process( Flags eFlags, const Options &opt, const char *sName, const char *argv, ...);
+        virtual ~Process();
+
+        /**
+         * Waits until the process exits.  This blocks the caller until the
+         * child process terminates.
+         */
+        void wait();
+
+        virtual void close();
+        virtual void closeStdIn();
+        virtual void closeStdOut();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size readErr( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
+
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+
+        virtual void flush();
+
+        virtual bool canRead();
+        virtual bool canWrite();
+
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+
+        virtual void setSize( Bu::size iSize );
+
+        virtual size getBlockSize() const;
+        virtual size getSize() const;
+        virtual Bu::String getLocation() const;
+
+        void select( bool &bStdOut, bool &bStdErr );
+
+        bool isRunning();
+        void ignoreStdErr();
+
+        /**
+         * Returns the pid of the child process, or zero if there is no
+         * currently running child.  Note that a read operation must be
+         * performed in order to discover that the child has ended.
+         */
+        pid_t getPid();
+
+        /**
+         * Returns true if the child exited normally (by calling exit or
+         * returning from main).
+         */
+        bool childExited();
+
+        /**
+         * Returns the 8 bit integer value returned from the child program if
+         * childExited returned true.
+         */
+        int childExitStatus();
+
+        /**
+         * Returns true if the child exited because of a signal.
+         */
+        bool childSignaled();
+
+        /**
+         * Returns the signal ID if the childSignaled return true.
+         */
+        int childSignal();
+
+        /**
+         * Returns true if the child left a core dump behind when it exited.
+         */
+        bool childCoreDumped();
+
+    private:
+        class ProcData
+        {
+        public:
+            ProcData();
 #ifdef WIN32
-                        void *hStdIn;
-                        void *hStdOut;
-                        void *hStdErr;
-                        void *hProcess;
+            void *hStdIn;
+            void *hStdOut;
+            void *hStdErr;
+            void *hProcess;
 #else
-                        int iStdIn;
-                        int iStdOut;
-                        int iStdErr;
-                        pid_t iPid;
+            int iStdIn;
+            int iStdOut;
+            int iStdErr;
+            pid_t iPid;
 #endif
-                };
-                ProcData pd;
-                int iProcStatus;
-                bool bBlocking;
-                bool bStdOutEos;
-                bool bStdErrEos;
-
-                void gexec( Flags eFlags, const char *sName, char *const argv[] );
-                void checkClose();
-                Options opt;
-        };
+        };
+        ProcData pd;
+        int iProcStatus;
+        bool bBlocking;
+        bool bStdOutEos;
+        bool bStdErrEos;
+
+        void gexec( Flags eFlags, const char *sName, char *const argv[] );
+        void checkClose();
+        Options opt;
+    };
 }
 
 #endif
diff --git a/src/stable/protocol.h b/src/stable/protocol.h
index 1a02143..4e121d9 100644
--- a/src/stable/protocol.h
+++ b/src/stable/protocol.h
@@ -14,25 +14,25 @@
 
 namespace Bu
 {
-        class Client;
+    class Client;
 
-        /**
-         *@ingroup Serving
-         */
-        class Protocol
-        {
-        public:
-                Protocol();
-                virtual ~Protocol();
+    /**
+     *@ingroup Serving
+     */
+    class Protocol
+    {
+    public:
+        Protocol();
+        virtual ~Protocol();
 
-                virtual void onNewConnection( Bu::Client *pClient );
-                virtual void onNewData( Bu::Client *pClient );
-                virtual void onMessage( Bu::Client *pClient, const Bu::String &sMsg );
-                virtual void onTick( Bu::Client *pClient );
+        virtual void onNewConnection( Bu::Client *pClient );
+        virtual void onNewData( Bu::Client *pClient );
+        virtual void onMessage( Bu::Client *pClient, const Bu::String &sMsg );
+        virtual void onTick( Bu::Client *pClient );
 
-        private:
+    private:
 
-        };
+    };
 }
 
 #endif
diff --git a/src/stable/protocolhttp.cpp b/src/stable/protocolhttp.cpp
index ea1a86e..352f7c7 100644
--- a/src/stable/protocolhttp.cpp
+++ b/src/stable/protocolhttp.cpp
@@ -8,7 +8,7 @@
 #include <dirent.h>
 
 #ifndef WIN32
-        #include <sys/wait.h>
+    #include <sys/wait.h>
 #endif 
 
 #include <errno.h>
@@ -32,9 +32,9 @@ Bu::ProtocolHttp::~ProtocolHttp()
 
 void Bu::ProtocolHttp::onNewConnection( Bu::Client *pClient )
 {
-        this->pClient = pClient;
+    this->pClient = pClient;
 
-        iState = 0;
+    iState = 0;
 }
 
 #define SDB( i ) (void)0
@@ -42,196 +42,196 @@ void Bu::ProtocolHttp::onNewConnection( Bu::Client *pClient )
 
 void Bu::ProtocolHttp::onNewData( Bu::Client *pClient )
 {
-/*      logHexDump(
-                1,
-                pClient->getInput().getStr(),
-                pClient->getInput().getSize(),
-                "input"
-                );*/
-
-        for(;;)
-        {
-                Bu::String sToken;
-                TokenType tt = getToken( sToken );
-
-                if( tt == ttOutOfData )
-                        return;
-
-                switch( iState )
-                {
-                        case 0:         // Start token, should be "method" (get, put, etc)
-                                SDB( 0 );
-                                sMethod = sToken;
-                                iState = 1;
-                                break;
-
-                        case 1:         // The path requested
-                                SDB( 1 );
-                                sPath = sToken;
-                                iState = 2;
-                                break;
-
-                        case 2:         // The protocol name and version
-                                SDB( 2 );
-                                if( strncmp( sToken.getStr(), "HTTP/", 5 ) )
-                                {
-                                        pClient->disconnect();
-                                        return;
-                                }
-                                else
-                                {
-                                        char *s, *s2;
-                                        s = sToken.getStr()+5;
-                                        iMajor = strtol( s, &s2, 10 );
-                                        iMinor = strtol( s2+1, NULL, 10 );
-                                        iState = 3;
-                                }
-                                break;
-
-                        case 3:         // End of initial header, now comes mime-style blocks.
-                                SDB( 3 );
-                                if( tt == ttNewline )
-                                {
-                                        iState = 10;
-                                }
-                                else if( tt == ttDoubleNewline )
-                                {
-                                        earlyResponse();
-                                }
-                                else
-                                {
-                                        pClient->disconnect();
-                                        return;
-                                }
-                                break;
-
-                        case 10:                // HTTP-Message (skipped for now...)
-                                SDB( 10 );
-                                if( tt == ttString )
-                                {
-                                        iState = 11;
-                                }
-                                else
-                                {
-                                        pClient->disconnect();
-                                }
-                                break;
-
-                        case 11:                // Should be a colon...
-                                SDB( 11 );
-                                if( tt == ttSeperator && sToken == ":" )
-                                {
-                                        iState = 12;
-                                }
-                                else
-                                {
-                                        pClient->disconnect();
-                                }
-                                break;
-
-                        case 12:
-                                SDB( 12 );
-                                if( tt == ttNewline )
-                                {
-                                        iState = 10;
-                                }
-                                if( tt == ttDoubleNewline )
-                                {
-                                        earlyResponse();
-                                }
-                                break;
-
-                        case 20:
-                                SDB( 20 );
-                                break;
-                }
-        }
+/*  logHexDump(
+        1,
+        pClient->getInput().getStr(),
+        pClient->getInput().getSize(),
+        "input"
+        );*/
+
+    for(;;)
+    {
+        Bu::String sToken;
+        TokenType tt = getToken( sToken );
+
+        if( tt == ttOutOfData )
+            return;
+
+        switch( iState )
+        {
+            case 0:     // Start token, should be "method" (get, put, etc)
+                SDB( 0 );
+                sMethod = sToken;
+                iState = 1;
+                break;
+
+            case 1:     // The path requested
+                SDB( 1 );
+                sPath = sToken;
+                iState = 2;
+                break;
+
+            case 2:     // The protocol name and version
+                SDB( 2 );
+                if( strncmp( sToken.getStr(), "HTTP/", 5 ) )
+                {
+                    pClient->disconnect();
+                    return;
+                }
+                else
+                {
+                    char *s, *s2;
+                    s = sToken.getStr()+5;
+                    iMajor = strtol( s, &s2, 10 );
+                    iMinor = strtol( s2+1, NULL, 10 );
+                    iState = 3;
+                }
+                break;
+
+            case 3:     // End of initial header, now comes mime-style blocks.
+                SDB( 3 );
+                if( tt == ttNewline )
+                {
+                    iState = 10;
+                }
+                else if( tt == ttDoubleNewline )
+                {
+                    earlyResponse();
+                }
+                else
+                {
+                    pClient->disconnect();
+                    return;
+                }
+                break;
+
+            case 10:        // HTTP-Message (skipped for now...)
+                SDB( 10 );
+                if( tt == ttString )
+                {
+                    iState = 11;
+                }
+                else
+                {
+                    pClient->disconnect();
+                }
+                break;
+
+            case 11:        // Should be a colon...
+                SDB( 11 );
+                if( tt == ttSeperator && sToken == ":" )
+                {
+                    iState = 12;
+                }
+                else
+                {
+                    pClient->disconnect();
+                }
+                break;
+
+            case 12:
+                SDB( 12 );
+                if( tt == ttNewline )
+                {
+                    iState = 10;
+                }
+                if( tt == ttDoubleNewline )
+                {
+                    earlyResponse();
+                }
+                break;
+
+            case 20:
+                SDB( 20 );
+                break;
+        }
+    }
 }
 
 Bu::ProtocolHttp::TokenType Bu::ProtocolHttp::getToken( Bu::String &line )
 {
-        char s;
-        int jmax = pClient->getInputSize();
-        bool bNonWS = false;
-        
-        for( int j = 0; j < jmax; j++ )
-        {
-                pClient->peek( &s, 1, j );
-                if( iState > 2 && isSeperator( s ) )
-                {
-                        if( j == 0 )
-                        {
-                                line += s;
-                                pClient->seek( 1 );
-                                return ttSeperator;
-                        }
-                        else
-                        {
-                                pClient->seek( j );
-                                return ttString;
-                        }
-                }
-                else if( isWS( s ) )
-                {
-                        if( bNonWS )
-                        {
-                                pClient->seek( j );
-                                return ttString;
-                        }
-                }
-                else if( s == CR )
-                {
-                        if( pClient->getInputSize() < 4 )
-                                return ttOutOfData;
-                        
-                        char ss[3];
-                        pClient->peek( ss, 3, j+1 );
-                        if( ss[0] == LF && ss[1] != ' ' && ss[1] != '\t' )
-                        {
-                                if( bNonWS )
-                                {
-                                        pClient->seek( j );
-                                        return ttString;
-                                }
-                                else if( ss[1] == CR && ss[2] == LF )
-                                {
-                                        pClient->seek( 4 );
-                                        return ttDoubleNewline;
-                                }
-                                else
-                                {
-                                        pClient->seek( 2 );
-                                        return ttNewline;
-                                }
-                        }
-                        
-                        j += 2;
-                        if( bNonWS )
-                        {
-                                pClient->seek( j );
-                                return ttString;
-                        }
-                }
-                else
-                {
-                        line += s;
-                        bNonWS = true;
-                }
-        }
-
-        return ttOutOfData;
+    char s;
+    int jmax = pClient->getInputSize();
+    bool bNonWS = false;
+    
+    for( int j = 0; j < jmax; j++ )
+    {
+        pClient->peek( &s, 1, j );
+        if( iState > 2 && isSeperator( s ) )
+        {
+            if( j == 0 )
+            {
+                line += s;
+                pClient->seek( 1 );
+                return ttSeperator;
+            }
+            else
+            {
+                pClient->seek( j );
+                return ttString;
+            }
+        }
+        else if( isWS( s ) )
+        {
+            if( bNonWS )
+            {
+                pClient->seek( j );
+                return ttString;
+            }
+        }
+        else if( s == CR )
+        {
+            if( pClient->getInputSize() < 4 )
+                return ttOutOfData;
+            
+            char ss[3];
+            pClient->peek( ss, 3, j+1 );
+            if( ss[0] == LF && ss[1] != ' ' && ss[1] != '\t' )
+            {
+                if( bNonWS )
+                {
+                    pClient->seek( j );
+                    return ttString;
+                }
+                else if( ss[1] == CR && ss[2] == LF )
+                {
+                    pClient->seek( 4 );
+                    return ttDoubleNewline;
+                }
+                else
+                {
+                    pClient->seek( 2 );
+                    return ttNewline;
+                }
+            }
+            
+            j += 2;
+            if( bNonWS )
+            {
+                pClient->seek( j );
+                return ttString;
+            }
+        }
+        else
+        {
+            line += s;
+            bNonWS = true;
+        }
+    }
+
+    return ttOutOfData;
 }
 
 bool Bu::ProtocolHttp::isWS( char buf )
 {
-        return (buf == ' ' || buf == '\t');
+    return (buf == ' ' || buf == '\t');
 }
 
 bool Bu::ProtocolHttp::isSeperator( char buf )
 {
-        return (buf == '(' || buf == ')' || buf == '<' || buf == '>' ||
-                        buf == '@' || buf == ',' || buf == ';' || buf == ':' ||
-                        buf == '\\' || buf == '\"' || buf == '/' || buf == '[' ||
+    return (buf == '(' || buf == ')' || buf == '<' || buf == '>' ||
+            buf == '@' || buf == ',' || buf == ';' || buf == ':' ||
+            buf == '\\' || buf == '\"' || buf == '/' || buf == '[' ||
                         buf == ']' || buf == '?' || buf == '=' || buf == '{' ||
                         buf == '}' );
 }
diff --git a/src/stable/protocolhttp.h b/src/stable/protocolhttp.h
index 87dc49b..51ca58c 100644
--- a/src/stable/protocolhttp.h
+++ b/src/stable/protocolhttp.h
@@ -18,89 +18,89 @@
 
 namespace Bu
 {
-        /**
-         * An HTTP Protocol handler.  Yes, I know that HTTP stands for Hyper Text
-         * Transfer Protocol, and that the Protocol part is redundant, but in this
-         * case the word Protocol is refering to the Libbu++ construct Bu::Protocol,
-         * and not a means of encoding conversations.  Anyway, this class represents
-         * a general HTTP server processor.  Every time a request comes in it calls
-         * the onRequest function in a subclass with the method and URI that were
-         * requested.  The sub-class can then do whatever it needs to to send back
-         * a response.
-         *@ingroup Serving
-         */
-        class ProtocolHttp : public Protocol
-        {
-        public: /* Types */
-                typedef Bu::List<Bu::String> TokenList;
+    /**
+     * An HTTP Protocol handler.  Yes, I know that HTTP stands for Hyper Text
+     * Transfer Protocol, and that the Protocol part is redundant, but in this
+     * case the word Protocol is refering to the Libbu++ construct Bu::Protocol,
+     * and not a means of encoding conversations.  Anyway, this class represents
+     * a general HTTP server processor.  Every time a request comes in it calls
+     * the onRequest function in a subclass with the method and URI that were
+     * requested.  The sub-class can then do whatever it needs to to send back
+     * a response.
+     *@ingroup Serving
+     */
+    class ProtocolHttp : public Protocol
+    {
+    public: /* Types */
+        typedef Bu::List<Bu::String> TokenList;
 
-        public: /* Interface */
-                ProtocolHttp();
-                virtual ~ProtocolHttp();
+    public: /* Interface */
+        ProtocolHttp();
+        virtual ~ProtocolHttp();
 
-                virtual void onNewConnection( Bu::Client *pClient );
-                virtual void onNewData( Bu::Client *pClient );
+        virtual void onNewConnection( Bu::Client *pClient );
+        virtual void onNewData( Bu::Client *pClient );
 
-                virtual void onRequest(
-                        const Bu::String &sMethod, const Bu::String &sPath )=0;
+        virtual void onRequest(
+            const Bu::String &sMethod, const Bu::String &sPath )=0;
 
-                class Response
-                {
-                        friend class Bu::ProtocolHttp;
-                public:
-                        Response( int iCode );
-                        Response( int iCode, const Bu::String &sReason );
-                        virtual ~Response();
+        class Response
+        {
+            friend class Bu::ProtocolHttp;
+        public:
+            Response( int iCode );
+            Response( int iCode, const Bu::String &sReason );
+            virtual ~Response();
 
-                        void setHeader( const Bu::String &sKey, const Bu::String &sVal );
-                        void setContent( const Bu::String &sCont );
+            void setHeader( const Bu::String &sKey, const Bu::String &sVal );
+            void setContent( const Bu::String &sCont );
 
-                private:
-                        int iCode;
-                        Bu::String sReason;
-                        typedef Bu::Hash<Bu::String,Bu::String> StringHash;
-                        StringHash hHeaders;
-                        Bu::String sContent;
-                };
-                
-                void sendResponse( const Response &rRes );
-        
-        private:
-                enum TokenType
-                {
-                        ttOutOfData,
-                        ttString,
-                        ttNewline,
-                        ttDoubleNewline,
-                        ttSeperator
-                };
-                /**
-                 * Read an HTTP line, this is up to the first CRLF that isn't followed
-                 * by a continuation character, converting it to one line as it reads.
-                 *@param line All data read will be appended to line, even if no
-                 * end-of-line is read.
-                 *@returns True if an end-of-line is read and the line should be
-                 * processed, false if the end-of-line has not been reached, and more
-                 * data needs to be read before this operation can continue.
-                 */
-                TokenType getToken( Bu::String &line );
-                bool isWS( char buf );
-                bool isSeperator( char buf );
+        private:
+            int iCode;
+            Bu::String sReason;
+            typedef Bu::Hash<Bu::String,Bu::String> StringHash;
+            StringHash hHeaders;
+            Bu::String sContent;
+        };
+        
+        void sendResponse( const Response &rRes );
+    
+    private:
+        enum TokenType
+        {
+            ttOutOfData,
+            ttString,
+            ttNewline,
+            ttDoubleNewline,
+            ttSeperator
+        };
+        /**
+         * Read an HTTP line, this is up to the first CRLF that isn't followed
+         * by a continuation character, converting it to one line as it reads.
+         *@param line All data read will be appended to line, even if no
+         * end-of-line is read.
+         *@returns True if an end-of-line is read and the line should be
+         * processed, false if the end-of-line has not been reached, and more
+         * data needs to be read before this operation can continue.
+         */
+        TokenType getToken( Bu::String &line );
+        bool isWS( char buf );
+        bool isSeperator( char buf );
 
-                void earlyResponse();
-                void lateResponse();
+        void earlyResponse();
+        void lateResponse();
 
-        private: /* state */
-                Bu::Client *pClient;
-                TokenList lTokens;
+    private: /* state */
+        Bu::Client *pClient;
+        TokenList lTokens;
 
-                int iState;
+        int iState;
 
-                Bu::String sMethod;
-                Bu::String sPath;
-                int iMajor;
-                int iMinor;
-        };
+        Bu::String sMethod;
+        Bu::String sPath;
+        int iMajor;
+        int iMinor;
+    };
 }
 
 #endif
diff --git a/src/stable/protocoltelnet.cpp b/src/stable/protocoltelnet.cpp
index aed23be..d5465d1 100644
--- a/src/stable/protocoltelnet.cpp
+++ b/src/stable/protocoltelnet.cpp
@@ -11,53 +11,53 @@
 /* We apparently at least want defs for the lower 13, not sure we care about
  * the rest of the chars, maybe escape.
  */
-#define CH_NUL          '\x00'  /* NUL */
-#define CH_SOH          '\x01'  /* Start Of Heading */
-#define CH_STX          '\x02'  /* Start of Text */
-#define CH_ETX          '\x03'  /* End of Text */
-#define CH_EOT          '\x04'  /* End of transmission */
-#define CH_ENQ          '\x05'  /* Enquiery */
-#define CH_ACK          '\x06'  /* Acknowledge */
-#define CH_BEL          '\x07'  /* Bell */
-#define CH_BS           '\x08'  /* Backspace */
-#define CH_TAB          '\x09'  /* Horizontal Tab */
-#define CH_LF           '\x0A'  /* NL Line feed, new line */
-#define CH_VT           '\x0B'  /* Vertical Tab */
-#define CH_FF           '\x0C'  /* Form feed, new page */
-#define CH_CR           '\x0D'  /* Carriage return */
-#define CH_ESC          '\x1B'  /* Escape */
-#define CH_DEL          '\x7F'  /* Delete */
-
-#define CODE_SE         '\xf0'  /* End of subnegotiation params. */
-#define CODE_NOP        '\xf1'  /* No operation (keep-alive). */
-#define CODE_DM         '\xf2'  /* Datastream side of a Synch. */
-#define CODE_BRK        '\xf3'  /* Break character. */
-#define CODE_IP         '\xf4'  /* Interrupt Process character. */
-#define CODE_AO         '\xf5'  /* Abort Output character. */
-#define CODE_AYT        '\xf6'  /* Are You There? character. */
-#define CODE_EC         '\xf7'  /* Erase Character character. */
-#define CODE_EL         '\xf8'  /* Erase Line character. */
-#define CODE_GA         '\xf9'  /* Go Ahead signal. */
-#define CODE_SB         '\xfa'  /* Begin subnegotiation options. */
-#define CODE_WILL       '\xfb'  /* Desire to do something. */
-#define CODE_WONT       '\xfc'  /* Refuse to perform. */
-#define CODE_DO         '\xfd'  /* Request option. */
-#define CODE_DONT       '\xfe'  /* Demand a stop. */
-
-#define CODE_IAC        '\xff'  /* Interpret-As-Command. */
-
-#define OPT_BINARY      '\x00'  /* Binary mode (file transfers?). */
-#define OPT_ECHO        '\x01'  /* (local) Echo mode. */
-#define OPT_SUPGA       '\x03'  /* Suppress Go Ahead signals. */
-#define OPT_STATUS      '\x05'  /* Allow status messages. */
-#define OPT_TIMING      '\x06'  /* Place a timing mark in the code. */
-#define OPT_EXASCII     '\x11'  /* Extended ASCII. */
-#define OPT_LOGOUT      '\x12'  /* Logout. */
-#define OPT_TTYPE       '\x18'  /* Terminal Type. */
-#define OPT_NAWS        '\x1f'  /* Negotiate about window size. */
-#define OPT_TSPEED      '\x20'  /* Terminal Speed. */
-#define OPT_NEWENV      '\x27'  /* New Environment Option. */
-#define OPT_EXOPL       '\xff'  /* Can we, will we, handle extended options. */
+#define CH_NUL      '\x00'  /* NUL */
+#define CH_SOH      '\x01'  /* Start Of Heading */
+#define CH_STX      '\x02'  /* Start of Text */
+#define CH_ETX      '\x03'  /* End of Text */
+#define CH_EOT      '\x04'  /* End of transmission */
+#define CH_ENQ      '\x05'  /* Enquiery */
+#define CH_ACK      '\x06'  /* Acknowledge */
+#define CH_BEL      '\x07'  /* Bell */
+#define CH_BS       '\x08'  /* Backspace */
+#define CH_TAB      '\x09'  /* Horizontal Tab */
+#define CH_LF       '\x0A'  /* NL Line feed, new line */
+#define CH_VT       '\x0B'  /* Vertical Tab */
+#define CH_FF       '\x0C'  /* Form feed, new page */
+#define CH_CR       '\x0D'  /* Carriage return */
+#define CH_ESC      '\x1B'  /* Escape */
+#define CH_DEL      '\x7F'  /* Delete */
+
+#define CODE_SE     '\xf0'  /* End of subnegotiation params. */
+#define CODE_NOP    '\xf1'  /* No operation (keep-alive). */
+#define CODE_DM     '\xf2'  /* Datastream side of a Synch. */
+#define CODE_BRK    '\xf3'  /* Break character. */
+#define CODE_IP     '\xf4'  /* Interrupt Process character. */
+#define CODE_AO     '\xf5'  /* Abort Output character. */
+#define CODE_AYT    '\xf6'  /* Are You There? character. */
+#define CODE_EC     '\xf7'  /* Erase Character character. */
+#define CODE_EL     '\xf8'  /* Erase Line character. */
+#define CODE_GA     '\xf9'  /* Go Ahead signal. */
+#define CODE_SB     '\xfa'  /* Begin subnegotiation options. */
+#define CODE_WILL   '\xfb'  /* Desire to do something. */
+#define CODE_WONT   '\xfc'  /* Refuse to perform. */
+#define CODE_DO     '\xfd'  /* Request option. */
+#define CODE_DONT   '\xfe'  /* Demand a stop. */
+
+#define CODE_IAC    '\xff'  /* Interpret-As-Command. */
+
+#define OPT_BINARY  '\x00'  /* Binary mode (file transfers?). */
+#define OPT_ECHO    '\x01'  /* (local) Echo mode. */
+#define OPT_SUPGA   '\x03'  /* Suppress Go Ahead signals. */
+#define OPT_STATUS  '\x05'  /* Allow status messages. */
+#define OPT_TIMING  '\x06'  /* Place a timing mark in the code. */
+#define OPT_EXASCII '\x11'  /* Extended ASCII. */
+#define OPT_LOGOUT  '\x12'  /* Logout. */
+#define OPT_TTYPE   '\x18'  /* Terminal Type. */
+#define OPT_NAWS    '\x1f'  /* Negotiate about window size. */
+#define OPT_TSPEED  '\x20'  /* Terminal Speed. */
+#define OPT_NEWENV  '\x27'  /* New Environment Option. */
+#define OPT_EXOPL   '\xff'  /* Can we, will we, handle extended options. */
 
 #ifndef __TELNET_DEBUG
 # define printCode( a ) (void)0
@@ -65,12 +65,12 @@
 #endif
 
 Bu::ProtocolTelnet::ProtocolTelnet() :
-        oBinary(        *this, OPT_BINARY ),
-        oEcho(          *this, OPT_ECHO ),
-        oNAWS(          *this, OPT_NAWS ),
-        oSuppressGA(*this, OPT_SUPGA ),
-        bCanonical( true ),
-        bSubOpt( false )
+    oBinary(    *this, OPT_BINARY ),
+    oEcho(      *this, OPT_ECHO ),
+    oNAWS(      *this, OPT_NAWS ),
+    oSuppressGA(*this, OPT_SUPGA ),
+    bCanonical( true ),
+    bSubOpt( false )
 {
 }
 
@@ -80,439 +80,439 @@ Bu::ProtocolTelnet::~ProtocolTelnet()
 
 void Bu::ProtocolTelnet::onNewConnection( Bu::Client *pClient )
 {
-        this->pClient = pClient;
+    this->pClient = pClient;
 }
 
 void Bu::ProtocolTelnet::onNewData( Bu::Client *pClient )
 {
-        char bc;
-        int iLeft;
-        while( (iLeft = pClient->getInputSize()) )
-        {
-                if( bSubOpt )
-                {
-                        pClient->peek( &bc, 1 );
-                        if( bc == CODE_IAC )
-                        {
-                                if( iLeft <= 1 ) return;
-                                char bc2;
-                                printCode( CODE_IAC );
-                                pClient->peek( &bc2, 1, 1 );
-                                printCode( bc2 );
-                                if( bc2 == CODE_SE )
-                                {
-                                        bSubOpt = false;
-                                        onSubOpt();
-                                }
-                                else if( bc2 == CODE_IAC )
-                                {
-                                        sSubBuf += CODE_IAC;
-                                }
-                                else
-                                {
-                                        // Error of some sort.
-                                }
-                                pClient->seek( 1 );
-                        }
-                        else
-                        {
-                                sSubBuf += bc;
-                        }
-                        pClient->seek( 1 );
-                }
-                else
-                {
-                        pClient->peek( &bc, 1 );
-                        if( bc == CODE_IAC )
-                        {
-                                if( iLeft <= 1 ) return;
-                                char bc2;
-                                pClient->peek( &bc2, 1, 1 );
-                                printCode( bc );
-                                printCode( bc2 );
-
-                                switch( bc2 )
-                                {
-                                        case CODE_WILL:
-                                                if( iLeft <= 2 ) return;
-                                                {
-                                                        char bc3;
-                                                        pClient->peek( &bc3, 1, 2 );
-                                                        pClient->seek( 1 );
-                                                        printOpt( bc3 );
-                                                        onWill( bc3 );
-                                                }
-                                                break;
-
-                                        case CODE_WONT:
-                                                if( iLeft <= 2 ) return;
-                                                {
-                                                        char bc3;
-                                                        pClient->peek( &bc3, 1, 2 );
-                                                        pClient->seek( 1 );
-                                                        printOpt( bc3 );
-                                                        onWont( bc3 );
-                                                }
-                                                break;
-
-                                        case CODE_DO:
-                                                if( iLeft <= 2 ) return;
-                                                {
-                                                        char bc3;
-                                                        pClient->peek( &bc3, 1, 2 );
-                                                        pClient->seek( 1 );
-                                                        printOpt( bc3 );
-                                                        onDo( bc3 );
-                                                }
-                                                break;
-
-                                        case CODE_DONT:
-                                                if( iLeft <= 2 ) return;
-                                                {
-                                                        char bc3;
-                                                        pClient->peek( &bc3, 1, 2 );
-                                                        pClient->seek( 1 );
-                                                        printOpt( bc3 );
-                                                        onDont( bc3 );
-                                                }
-                                                break;
-
-                                        case CODE_SB:
-                                                if( iLeft <= 2 ) return;
-                                                {
-                                                        pClient->peek( &cSubOpt, 1, 2 );
-                                                        pClient->seek( 1 );
-                                                        printOpt( cSubOpt );
-                                                        bSubOpt = true;
-                                                }
-                                                break;
-
-                                        case CODE_IAC:
-                                                sDataBuf += CODE_IAC;
-                                                printCode( CODE_IAC );
-                                                break;
-                                }
-                                pClient->seek( 1 );
+    char bc;
+    int iLeft;
+    while( (iLeft = pClient->getInputSize()) )
+    {
+        if( bSubOpt )
+        {
+            pClient->peek( &bc, 1 );
+            if( bc == CODE_IAC )
+            {
+                if( iLeft <= 1 ) return;
+                char bc2;
+                printCode( CODE_IAC );
+                pClient->peek( &bc2, 1, 1 );
+                printCode( bc2 );
+                if( bc2 == CODE_SE )
+                {
+                    bSubOpt = false;
+                    onSubOpt();
+                }
+                else if( bc2 == CODE_IAC )
+                {
+                    sSubBuf += CODE_IAC;
+                }
+                else
+                {
+                    // Error of some sort.
+                }
+                pClient->seek( 1 );
+            }
+            else
+            {
+                sSubBuf += bc;
+            }
+            pClient->seek( 1 );
+        }
+        else
+        {
+            pClient->peek( &bc, 1 );
+            if( bc == CODE_IAC )
+            {
+                if( iLeft <= 1 ) return;
+                char bc2;
+                pClient->peek( &bc2, 1, 1 );
+                printCode( bc );
+                printCode( bc2 );
+
+                switch( bc2 )
+                {
+                    case CODE_WILL:
+                        if( iLeft <= 2 ) return;
+                        {
+                            char bc3;
+                            pClient->peek( &bc3, 1, 2 );
+                            pClient->seek( 1 );
+                            printOpt( bc3 );
+                            onWill( bc3 );
+                        }
+                        break;
+
+                    case CODE_WONT:
+                        if( iLeft <= 2 ) return;
+                        {
+                            char bc3;
+                            pClient->peek( &bc3, 1, 2 );
+                            pClient->seek( 1 );
+                            printOpt( bc3 );
+                            onWont( bc3 );
+                        }
+                        break;
+
+                    case CODE_DO:
+                        if( iLeft <= 2 ) return;
+                        {
+                            char bc3;
+                            pClient->peek( &bc3, 1, 2 );
+                            pClient->seek( 1 );
+                            printOpt( bc3 );
+                            onDo( bc3 );
+                        }
+                        break;
+
+                    case CODE_DONT:
+                        if( iLeft <= 2 ) return;
+                        {
+                            char bc3;
+                            pClient->peek( &bc3, 1, 2 );
+                            pClient->seek( 1 );
+                            printOpt( bc3 );
+                            onDont( bc3 );
+                        }
+                        break;
+
+                    case CODE_SB:
+                        if( iLeft <= 2 ) return;
+                        {
+                            pClient->peek( &cSubOpt, 1, 2 );
+                            pClient->seek( 1 );
+                            printOpt( cSubOpt );
+                            bSubOpt = true;
+                        }
+                        break;
+
+                    case CODE_IAC:
+                        sDataBuf += CODE_IAC;
+                        printCode( CODE_IAC );
+                        break;
+                }
+                pClient->seek( 1 );
 #ifdef __TELNET_DEBUG
-                                printf("\n");
+                printf("\n");
 #endif
-                        }
-                        else if( bc == CODE_SB )
-                        {
-                        }
-                        else
-                        {
-                                // This is where control code handling goes
-                                // Also, possibly, character code conversion, although I'm not
-                                // sure that really matters anymore, go ASCII/UTF-8
-                                if( bCanonical )
-                                {
-                                        if( bc < 0x20 || bc >= CH_DEL )
-                                        {
-                                                if( bc == CH_CR )
-                                                {
-                                                        if( iLeft <= 1 ) return;
-                                                        char bc2;
-                                                        pClient->peek( &bc2, 1, 1 );
-                                                        if( bc2 == CH_NUL || bc2 == CH_LF )
-                                                        {
-                                                                onCtlChar( bc );
-                                                                gotLine( sDataBuf );
-                                                                sDataBuf.clear();
-                                                        }
-                                                        pClient->seek( 1 );
-                                                }
-                                                else
-                                                {
-                                                        onCtlChar( bc );
-                                                }
-                                        }
-                                        else
-                                        {
-                                                sDataBuf += bc;
-                                                if( oEcho.isLocalSet() )
-                                                {
-                                                        pClient->write( &bc, 1 );
+            }
+            else if( bc == CODE_SB )
+            {
+            }
+            else
+            {
+                // This is where control code handling goes
+                // Also, possibly, character code conversion, although I'm not
+                // sure that really matters anymore, go ASCII/UTF-8
+                if( bCanonical )
+                {
+                    if( bc < 0x20 || bc >= CH_DEL )
+                    {
+                        if( bc == CH_CR )
+                        {
+                            if( iLeft <= 1 ) return;
+                            char bc2;
+                            pClient->peek( &bc2, 1, 1 );
+                            if( bc2 == CH_NUL || bc2 == CH_LF )
+                            {
+                                onCtlChar( bc );
+                                gotLine( sDataBuf );
+                                sDataBuf.clear();
+                            }
+                            pClient->seek( 1 );
+                        }
+                        else
+                        {
+                            onCtlChar( bc );
+                        }
+                    }
+                    else
+                    {
+                        sDataBuf += bc;
+                        if( oEcho.isLocalSet() )
+                        {
+                            pClient->write( &bc, 1 );
 #ifdef __TELNET_DEBUG
-                                                        printf("%c", bc );
-                                                        fflush( stdout );
+                            printf("%c", bc );
+                            fflush( stdout );
 #endif
-                                                }
-                                        }
-                                }
-                                else
-                                {
-                                        sDataBuf += bc;
-                                        if( oEcho.isLocalSet() )
-                                        {
-                                                pClient->write( &bc, 1 );
-                                        }
-                                }
-                        }
-                        pClient->seek( 1 );
-                }
-        }
-
-        // It's true, this code will not be executed if we only have half of an
-        // IAC code or multibyte escape sequence or something, but then again, it
-        // shouldn't be called then, and really, shouldn't be, it'll be called soon
-        // enough, when we get the rest of that code.
-        if( !bCanonical )
-        {
-                gotData( sDataBuf );
-        }
+                        }
+                    }
+                }
+                else
+                {
+                    sDataBuf += bc;
+                    if( oEcho.isLocalSet() )
+                    {
+                        pClient->write( &bc, 1 );
+                    }
+                }
+            }
+            pClient->seek( 1 );
+        }
+    }
+
+    // It's true, this code will not be executed if we only have half of an
+    // IAC code or multibyte escape sequence or something, but then again, it
+    // shouldn't be called then, and really, shouldn't be, it'll be called soon
+    // enough, when we get the rest of that code.
+    if( !bCanonical )
+    {
+        gotData( sDataBuf );
+    }
 }
 
 void Bu::ProtocolTelnet::setCanonical( bool bCon )
 {
-        bCanonical = bCon;
+    bCanonical = bCon;
 }
 
 bool Bu::ProtocolTelnet::isCanonical()
 {
-        return bCanonical;
+    return bCanonical;
 }
 
 void Bu::ProtocolTelnet::write( const Bu::String &sData )
 {
-        write( sData.getStr(), sData.getSize() );
+    write( sData.getStr(), sData.getSize() );
 }
 
 void Bu::ProtocolTelnet::write( const char *pData, int iSize )
 {
-        int iLast = 0, j;
-        for( j = iLast; j < iSize; j++ )
-        {
-                if( pData[j] == '\n' )
-                {
-                        if( j+1 >= iSize ||
-                                (pData[j+1] != '\r' && pData[j+1] != '\0') )
-                        {
-                                pClient->write( pData+iLast, j-iLast );
-                                pClient->write( "\n\r", 2 );
-                                iLast = j+1;
-                        }
-                        else
-                        {
-                                j++;
-                        }
-                }
-        }
-        if( j > iLast )
-        {
-                pClient->write( pData+iLast, iSize-iLast );
-        }
-        //pClient->write( pData, iSize );
+    int iLast = 0, j;
+    for( j = iLast; j < iSize; j++ )
+    {
+        if( pData[j] == '\n' )
+        {
+            if( j+1 >= iSize ||
+                (pData[j+1] != '\r' && pData[j+1] != '\0') )
+            {
+                pClient->write( pData+iLast, j-iLast );
+                pClient->write( "\n\r", 2 );
+                iLast = j+1;
+            }
+            else
+            {
+                j++;
+            }
+        }
+    }
+    if( j > iLast )
+    {
+        pClient->write( pData+iLast, iSize-iLast );
+    }
+    //pClient->write( pData, iSize );
 }
 
 void Bu::ProtocolTelnet::write( char cData )
 {
-        write( &cData, 1 );
+    write( &cData, 1 );
 }
 
 void Bu::ProtocolTelnet::onWill( char cCode )
 {
-        try
-        {
-                Option *pOpt = hOpts[cCode];
-                if( pOpt->isRemoteEnabled() )
-                {
-                        pOpt->fOpts |= Option::fRemoteIs;
-                        char buf[3] = { CODE_IAC, CODE_DO, cCode };
-                        pClient->write( buf, 3 );
-                }
-                else
-                {
-                        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                        pClient->write( buf, 3 );
-                }
-
-        }
-        catch( Bu::HashException &e )
-        {
-                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                pClient->write( buf, 3 );
-        }
+    try
+    {
+        Option *pOpt = hOpts[cCode];
+        if( pOpt->isRemoteEnabled() )
+        {
+            pOpt->fOpts |= Option::fRemoteIs;
+            char buf[3] = { CODE_IAC, CODE_DO, cCode };
+            pClient->write( buf, 3 );
+        }
+        else
+        {
+            char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+            pClient->write( buf, 3 );
+        }
+
+    }
+    catch( Bu::HashException &e )
+    {
+        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+        pClient->write( buf, 3 );
+    }
 }
 
 void Bu::ProtocolTelnet::onWont( char cCode )
 {
-        try
-        {
-                Option *pOpt = hOpts[cCode];
-
-                pOpt->fOpts &= ~Option::fRemoteIs;
-                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                pClient->write( buf, 3 );
-        }
-        catch( Bu::HashException &e )
-        {
-                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                pClient->write( buf, 3 );
-        }
+    try
+    {
+        Option *pOpt = hOpts[cCode];
+
+        pOpt->fOpts &= ~Option::fRemoteIs;
+        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+        pClient->write( buf, 3 );
+    }
+    catch( Bu::HashException &e )
+    {
+        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+        pClient->write( buf, 3 );
+    }
 }
 
 void Bu::ProtocolTelnet::onDo( char cCode )
 {
-        try
-        {
-                Option *pOpt = hOpts[cCode];
-                if( pOpt->isLocalEnabled() )
-                {
-                        pOpt->fOpts |= Option::fLocalIs;
-                        char buf[3] = { CODE_IAC, CODE_WILL, cCode };
-                        pClient->write( buf, 3 );
-                }
-                else
-                {
-                        char buf[3] = { CODE_IAC, CODE_WONT, cCode };
-                        pClient->write( buf, 3 );
-                }
-
-        }
-        catch( Bu::HashException &e )
-        {
-                char buf[3] = { CODE_IAC, CODE_WONT, cCode };
-                pClient->write( buf, 3 );
-        }
+    try
+    {
+        Option *pOpt = hOpts[cCode];
+        if( pOpt->isLocalEnabled() )
+        {
+            pOpt->fOpts |= Option::fLocalIs;
+            char buf[3] = { CODE_IAC, CODE_WILL, cCode };
+            pClient->write( buf, 3 );
+        }
+        else
+        {
+            char buf[3] = { CODE_IAC, CODE_WONT, cCode };
+            pClient->write( buf, 3 );
+        }
+
+    }
+    catch( Bu::HashException &e )
+    {
+        char buf[3] = { CODE_IAC, CODE_WONT, cCode };
+        pClient->write( buf, 3 );
+    }
 }
 
 void Bu::ProtocolTelnet::onDont( char cCode )
 {
-        try
-        {
-                Option *pOpt = hOpts[cCode];
-
-                pOpt->fOpts &= ~Option::fLocalIs;
-                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                pClient->write( buf, 3 );
-        }
-        catch( Bu::HashException &e )
-        {
-                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                pClient->write( buf, 3 );
-        }
+    try
+    {
+        Option *pOpt = hOpts[cCode];
+
+        pOpt->fOpts &= ~Option::fLocalIs;
+        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+        pClient->write( buf, 3 );
+    }
+    catch( Bu::HashException &e )
+    {
+        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+        pClient->write( buf, 3 );
+    }
 }
 
 void Bu::ProtocolTelnet::onSubOpt()
 {
-        switch( cSubOpt )
-        {
-                case OPT_NAWS:
-                        {
-                                uint16_t iWidth, iHeight;
-                                ((char *)&iWidth)[1] = sSubBuf[0];
-                                ((char *)&iWidth)[0] = sSubBuf[1];
-                                ((char *)&iHeight)[1] = sSubBuf[2];
-                                ((char *)&iHeight)[0] = sSubBuf[3];
-                                onSubNAWS( iWidth, iHeight );
-                        }
-                        break;
-
-                default:
-                        onSubUnknown( cSubOpt, sSubBuf );
-                        break;
-        }
-
-        sSubBuf.clear();
+    switch( cSubOpt )
+    {
+        case OPT_NAWS:
+            {
+                uint16_t iWidth, iHeight;
+                ((char *)&iWidth)[1] = sSubBuf[0];
+                ((char *)&iWidth)[0] = sSubBuf[1];
+                ((char *)&iHeight)[1] = sSubBuf[2];
+                ((char *)&iHeight)[0] = sSubBuf[3];
+                onSubNAWS( iWidth, iHeight );
+            }
+            break;
+
+        default:
+            onSubUnknown( cSubOpt, sSubBuf );
+            break;
+    }
+
+    sSubBuf.clear();
 }
 
 void Bu::ProtocolTelnet::onCtlChar( char cChr )
 {
 #ifdef __TELNET_DEBUG 
-        switch( cChr )
-        {
-                case CH_NUL:    printf("NUL "); break;
-                case CH_SOH:    printf("SOH "); break;
-                case CH_STX:    printf("STX "); break;
-                case CH_ETX:    printf("ETX "); break;
-                case CH_EOT:    printf("EOT "); break;
-                case CH_ENQ:    printf("ENQ "); break;
-                case CH_ACK:    printf("ACK "); break;
-                case CH_BEL:    printf("BEL "); break;
-                case CH_BS:             printf("BS ");  break;
-                case CH_TAB:    printf("TAB "); break;
-                case CH_LF:             printf("LF ");  break;
-                case CH_VT:             printf("VT ");  break;
-                case CH_FF:             printf("FF ");  break;
-                case CH_CR:             printf("CR ");  break;
-                case CH_ESC:    printf("ESC "); break;
-                case CH_DEL:    printf("DEL "); break;
-                default:                printf("!![%02x] ", cChr );     break;
-        }
-        fflush( stdout );
+    switch( cChr )
+    {
+        case CH_NUL:    printf("NUL "); break;
+        case CH_SOH:    printf("SOH "); break;
+        case CH_STX:    printf("STX "); break;
+        case CH_ETX:    printf("ETX "); break;
+        case CH_EOT:    printf("EOT "); break;
+        case CH_ENQ:    printf("ENQ "); break;
+        case CH_ACK:    printf("ACK "); break;
+        case CH_BEL:    printf("BEL "); break;
+        case CH_BS:     printf("BS ");  break;
+        case CH_TAB:    printf("TAB "); break;
+        case CH_LF:     printf("LF ");  break;
+        case CH_VT:     printf("VT ");  break;
+        case CH_FF:     printf("FF ");  break;
+        case CH_CR:     printf("CR ");  break;
+        case CH_ESC:    printf("ESC "); break;
+        case CH_DEL:    printf("DEL "); break;
+        default:        printf("!![%02x] ", cChr ); break;
+    }
+    fflush( stdout );
 #endif
 
-        switch( cChr )
-        {
-                case CH_DEL:
-                        {
-                                if( sDataBuf.getSize() > 0 )
-                                {
-                                        sDataBuf.resize( sDataBuf.getSize()-1 );
-                                        char buf[3] = { CH_BS, ' ', CH_BS };
-                                        pClient->write( buf, 3 );
-                                }
-                        }
-                        break;
-
-        }
+    switch( cChr )
+    {
+        case CH_DEL:
+            {
+                if( sDataBuf.getSize() > 0 )
+                {
+                    sDataBuf.resize( sDataBuf.getSize()-1 );
+                    char buf[3] = { CH_BS, ' ', CH_BS };
+                    pClient->write( buf, 3 );
+                }
+            }
+            break;
+
+    }
 }
 
 #ifdef __TELNET_DEBUG
 void Bu::ProtocolTelnet::printCode( char cCode )
 {
-        switch( cCode )
-        {
-                case CODE_SE:           printf("SE ");          break;
-                case CODE_NOP:          printf("NOP ");         break;
-                case CODE_DM:           printf("DM ");          break;
-                case CODE_BRK:          printf("BRK ");         break;
-                case CODE_IP:           printf("IP ");          break;
-                case CODE_AO:           printf("AO ");          break;
-                case CODE_AYT:          printf("AYT ");         break;
-                case CODE_EC:           printf("EC ");          break;
-                case CODE_EL:           printf("EL ");          break;
-                case CODE_GA:           printf("GA ");          break;
-                case CODE_SB:           printf("SB ");          break;
-                case CODE_WILL:         printf("WILL ");        break;
-                case CODE_WONT:         printf("WONT ");        break;
-                case CODE_DO:           printf("DO ");          break;
-                case CODE_DONT:         printf("DONT ");        break;
-                case CODE_IAC:          printf("IAC ");         break;
-                default:                        printf("??%02x ", cCode );      break;
-        }
-        fflush( stdout );
+    switch( cCode )
+    {
+        case CODE_SE:       printf("SE ");      break;
+        case CODE_NOP:      printf("NOP ");     break;
+        case CODE_DM:       printf("DM ");      break;
+        case CODE_BRK:      printf("BRK ");     break;
+        case CODE_IP:       printf("IP ");      break;
+        case CODE_AO:       printf("AO ");      break;
+        case CODE_AYT:      printf("AYT ");     break;
+        case CODE_EC:       printf("EC ");      break;
+        case CODE_EL:       printf("EL ");      break;
+        case CODE_GA:       printf("GA ");      break;
+        case CODE_SB:       printf("SB ");      break;
+        case CODE_WILL:     printf("WILL ");    break;
+        case CODE_WONT:     printf("WONT ");    break;
+        case CODE_DO:       printf("DO ");      break;
+        case CODE_DONT:     printf("DONT ");    break;
+        case CODE_IAC:      printf("IAC ");     break;
+        default:            printf("??%02x ", cCode );  break;
+    }
+    fflush( stdout );
 }
 
 void Bu::ProtocolTelnet::printOpt( char cOpt )
 {
-        switch( cOpt )
-        {
-                case OPT_BINARY:        printf("BINARY ");      break;
-                case OPT_ECHO:          printf("ECHO ");        break;
-                case OPT_SUPGA:         printf("SUPGA ");       break;
-                case OPT_STATUS:        printf("STATUS ");      break;
-                case OPT_TIMING:        printf("TIMING ");      break;
-                case OPT_EXASCII:       printf("EXASCII ");     break;
-                case OPT_LOGOUT:        printf("LOGOUT ");      break;
-                case OPT_TTYPE:         printf("TTYPE ");       break;
-                case OPT_NAWS:          printf("NAWS ");        break;
-                case OPT_TSPEED:        printf("TSPEED ");      break;
-                case OPT_NEWENV:        printf("NEWENV ");      break;
-                case OPT_EXOPL:         printf("EXOPL ");       break;
-                default:                        printf("??%02x ", cOpt);        break;
-        }
-        fflush( stdout );
+    switch( cOpt )
+    {
+        case OPT_BINARY:    printf("BINARY ");  break;
+        case OPT_ECHO:      printf("ECHO ");    break;
+        case OPT_SUPGA:     printf("SUPGA ");   break;
+        case OPT_STATUS:    printf("STATUS ");  break;
+        case OPT_TIMING:    printf("TIMING ");  break;
+        case OPT_EXASCII:   printf("EXASCII "); break;
+        case OPT_LOGOUT:    printf("LOGOUT ");  break;
+        case OPT_TTYPE:     printf("TTYPE ");   break;
+        case OPT_NAWS:      printf("NAWS ");    break;
+        case OPT_TSPEED:    printf("TSPEED ");  break;
+        case OPT_NEWENV:    printf("NEWENV ");  break;
+        case OPT_EXOPL:     printf("EXOPL ");   break;
+        default:            printf("??%02x ", cOpt);    break;
+    }
+    fflush( stdout );
 }
 #endif
 
 Bu::ProtocolTelnet::Option::Option( Bu::ProtocolTelnet &rPT, char cCode ) :
-        rPT( rPT ),
-        fOpts( 0 ),
-        cCode( cCode )
+    rPT( rPT ),
+    fOpts( 0 ),
+    cCode( cCode )
 {
-        rPT.hOpts.insert( cCode, this );
+    rPT.hOpts.insert( cCode, this );
 }
 
 Bu::ProtocolTelnet::Option::~Option()
@@ -521,100 +521,100 @@ Bu::ProtocolTelnet::Option::~Option()
 
 void Bu::ProtocolTelnet::Option::localEnable( bool bSet )
 {
-        if( bSet == (bool)(!(fOpts&fLocalCant)) ) return;
+    if( bSet == (bool)(!(fOpts&fLocalCant)) ) return;
 
-        if( bSet )
-                fOpts &= ~fLocalCant;
-        else
-                fOpts |= fLocalCant;
+    if( bSet )
+        fOpts &= ~fLocalCant;
+    else
+        fOpts |= fLocalCant;
 }
 
 void Bu::ProtocolTelnet::Option::localSet( bool bSet )
 {
-        if( bSet == (bool)(fOpts&fLocalIs) ) return;
+    if( bSet == (bool)(fOpts&fLocalIs) ) return;
 
-        char buf[3] = { CODE_IAC, 0, cCode };
+    char buf[3] = { CODE_IAC, 0, cCode };
 
-        if( bSet )
-        {
-                buf[1] = CODE_WILL;
-                rPT.pClient->write( buf, 3 );
+    if( bSet )
+    {
+        buf[1] = CODE_WILL;
+        rPT.pClient->write( buf, 3 );
 #ifdef __TELNET_DEBUG
-                printf("<= ");
-                rPT.printCode( buf[0] );
-                rPT.printCode( buf[1] );
-                rPT.printOpt( buf[2] );
-                printf("\n");
+        printf("<= ");
+        rPT.printCode( buf[0] );
+        rPT.printCode( buf[1] );
+        rPT.printOpt( buf[2] );
+        printf("\n");
 #endif
-        }
-        else
-        {
-                buf[1] = CODE_WONT;
-                rPT.pClient->write( buf, 3 );
+    }
+    else
+    {
+        buf[1] = CODE_WONT;
+        rPT.pClient->write( buf, 3 );
 #ifdef __TELNET_DEBUG
-                printf("<= ");
-                rPT.printCode( buf[0] );
-                rPT.printCode( buf[1] );
-                rPT.printOpt( buf[2] );
-                printf("\n");
+        printf("<= ");
+        rPT.printCode( buf[0] );
+        rPT.printCode( buf[1] );
+        rPT.printOpt( buf[2] );
+        printf("\n");
 #endif
-        }
+    }
 }
 
 bool Bu::ProtocolTelnet::Option::isLocalEnabled()
 {
-        return (bool)(!(fOpts&fLocalCant));
+    return (bool)(!(fOpts&fLocalCant));
 }
 
 bool Bu::ProtocolTelnet::Option::isLocalSet()
 {
-        return (bool)(fOpts&fLocalIs);
+    return (bool)(fOpts&fLocalIs);
 }
 
 void Bu::ProtocolTelnet::Option::remoteEnable( bool /*bSet*/ )
 {
-        return;
+    return;
 }
 
 void Bu::ProtocolTelnet::Option::remoteSet( bool bSet )
 {
-        //if( bSet == (bool)(fOpts&fRemoteIs) ) return;
+    //if( bSet == (bool)(fOpts&fRemoteIs) ) return;
 
-        char buf[3] = { CODE_IAC, 0, cCode };
+    char buf[3] = { CODE_IAC, 0, cCode };
 
-        if( bSet )
-        {
-                buf[1] = CODE_DO;
-                rPT.pClient->write( buf, 3 );
+    if( bSet )
+    {
+        buf[1] = CODE_DO;
+        rPT.pClient->write( buf, 3 );
 #ifdef __TELNET_DEBUG
-                printf("<= ");
-                rPT.printCode( buf[0] );
-                rPT.printCode( buf[1] );
-                rPT.printOpt( buf[2] );
-                printf("\n");
+        printf("<= ");
+        rPT.printCode( buf[0] );
+        rPT.printCode( buf[1] );
+        rPT.printOpt( buf[2] );
+        printf("\n");
 #endif
-        }
-        else
-        {
-                buf[1] = CODE_DONT;
-                rPT.pClient->write( buf, 3 );
+    }
+    else
+    {
+        buf[1] = CODE_DONT;
+        rPT.pClient->write( buf, 3 );
 #ifdef __TELNET_DEBUG
-                printf("<= ");
-                rPT.printCode( buf[0] );
-                rPT.printCode( buf[1] );
-                rPT.printOpt( buf[2] );
-                printf("\n");
+        printf("<= ");
+        rPT.printCode( buf[0] );
+        rPT.printCode( buf[1] );
+        rPT.printOpt( buf[2] );
+        printf("\n");
 #endif
-        }
+    }
 }
 
 bool Bu::ProtocolTelnet::Option::isRemoteEnabled()
 {
-        return (bool)(!(fOpts&fRemoteCant));
+    return (bool)(!(fOpts&fRemoteCant));
 }
 
 bool Bu::ProtocolTelnet::Option::isRemoteSet()
 {
-        return (bool)(fOpts&fRemoteIs);
+    return (bool)(fOpts&fRemoteIs);
 }
 
diff --git a/src/stable/protocoltelnet.h b/src/stable/protocoltelnet.h
index 9a13496..b212303 100644
--- a/src/stable/protocoltelnet.h
+++ b/src/stable/protocoltelnet.h
@@ -16,205 +16,205 @@
 
 namespace Bu
 {
-        /**
-         * Telnet Protocol handler.  This attempts to provide useful and general
-         * support for most of the most commonly used Telnet extensions in a simple
-         * and easy to use way.  The Option variables control the settings that can
-         * be used on the line, and control which virtual "callbacks" will be called
-         * when different events happen.
-         *
-         * To setup initial values and to disable any options you wish override the
-         * onNewConnection function in your own class, like this:
-         *@code
-         class MyTelnet : public Bu::ProtocolTelnet
-         {
-         public:
-                ...
-
-                virtual void onNewConnection( class Bu::Client *pClient )
-                {
-                        // Call the parent class' onNewConnection to get everything all
-                        // set up.
-                        Bu::ProtocolTelnet::onNewConnection( pClient );
-
-                        // These functions disable the option to send files via telnet,
-                        // disabling the remote option means that we won't accept this
-                        // option (binary data being sent to us) from the client.
-                        //
-                        // Disabling the local option means that the client cannot ask us
-                        // to send them binary data.
-                        oBinary.enableRemote( false );
-                        oBinary.enableLocal( false );
-
-                        // This requests that the client send us window size updates
-                        // whenever the size of their window changes, and an initial set to
-                        // boot.
-                        //
-                        // To see if this option is set later, try oNAWS.isRemoteSet(), but
-                        // wait a little while, asking immediatly will always return false,
-                        // since the remote side has yet to receive our request.
-                        oNAWS.remoteSet();
-                }
-        }
-         @endcode
-         *
-         *@ingroup Serving
-         */
-        class ProtocolTelnet : public Protocol
-        {
-        public:
-                ProtocolTelnet();
-                virtual ~ProtocolTelnet();
-
-                /**
-                 * If you override this function in a child class, make sure to call
-                 * this version of it as the very first thing that you do, before you
-                 * set any options.  See the example in the class docs.
-                 */
-                virtual void onNewConnection( class Bu::Client *pClient );
-
-                /**
-                 * You should never override this function unless you really, really
-                 * know what you're doing.  If you want to get data after each line
-                 * entered (in canonical mode) or after any data arrives (non canonical
-                 * mode) then override the gotLine and gotData functions, respectively.
-                 */
-                virtual void onNewData( class Bu::Client *pClient );
-
-                /**
-                 * Override this function to be notified of lines being submitted by
-                 * the client.  This function is only called in canonical mode, after
-                 * all edits are performed on the data.  In this mode weather you use
-                 * the line or not, the data will be cleared from the buffer when this
-                 * function returns, any changes made to the buffer will be destroyed.
-                 */
-                virtual void gotLine( Bu::String & /*sLine*/ ){};
-
-                /**
-                 * Override this function to be notified of any new data that comes in
-                 * from the client.  This function is only called in non-canonical mode,
-                 * and includes all raw data minus telnet control codes and ansi
-                 * escape sequences.  In this mode control of the buffer is up to the
-                 * child class in this function, the buffer will never be cleared unless
-                 * it happens in this function's override.
-                 */
-                virtual void gotData( Bu::String & /*sData*/ ){};
-
-                /**
-                 * Using this function to enable or disable canonical mode only affects
-                 * the way the data is processed and which virtual functions are called
-                 * during processing.  It does not affect options set locally or
-                 * remotely.  Setting this to false will enable char-at-a-time mode,
-                 * effectively disabling internal line-editing code.  Characters
-                 * such as backspace that are detected will not be handled and will be
-                 * sent to the user override.  The subclass will also be notified every
-                 * time new data is available, not just whole lines.
-                 *
-                 * When set to true (the default), line editing control codes will be
-                 * interpreted and used, and the subclass will only be notified when
-                 * complete lines are available in the buffer.
-                 */
-                void setCanonical( bool bCon=true );
-                bool isCanonical();
-
-                void write( const Bu::String &sData );
-                void write( const char *pData, int iSize );
-                void write( char cData );
-
-                const Bu::String &getBuffer() { return sDataBuf; }
-
-        public:
-                /**
-                 * If you wish to know the current dimensions of the client window,
-                 * override this function, it will be called whenever the size changes.
-                 */
-                virtual void onSubNAWS( uint16_t /*iWidth*/, uint16_t /*iHeight*/ ){};
-
-                /**
-                 * This function is called whenever an unknown sub negotiation option is
-                 * sent over the line.  This doesn't mean that it's malformatted, it
-                 * just means that this class doesn't support that option yet, but you
-                 * can handle it yourself if you'd like.  Feel free to change the
-                 * sSubBuf, it will be cleared as soon as this function returns anyway.
-                 */
-                virtual void onSubUnknown( char /*cSubOpt*/,
-                        Bu::String & /*sSubBuf*/ ){};
-
-        private:
-                /**
-                 * Represents a basic telnet option, either on or off, no parameters.
-                 * Each Option can negotiate effectively on it's own, and has two
-                 * parameters in each of two classes.  Both local and remote can be
-                 * enabled/disabled and set/unset.  Enabled represents the ability to
-                 * set the option, disabling an option should also unset it.  Set or
-                 * unset represent wether the option is being used, if it is allowed.
-                 */
-                class Option
-                {
-                        friend class Bu::ProtocolTelnet;
-                private:
-                        Option( ProtocolTelnet &rPT, char cCode );
-                        virtual ~Option();
-
-                public:
-                        void localEnable( bool bSet=true );
-                        void localSet( bool bSet=true );
-                        
-                        bool isLocalEnabled();
-                        bool isLocalSet();
-                        
-                        void remoteEnable( bool bSet=true );
-                        void remoteSet( bool bSet=true );
-
-                        bool isRemoteEnabled();
-                        bool isRemoteSet();
-
-                private:
-                        enum
-                        {
-                                fLocalCant      = 0x01, /**< Local can't/won't allow option. */
-                                fLocalIs        = 0x02, /**< Local is using option. */
-                                fRemoteCant     = 0x04, /**< Remote can't/won't allow option. */
-                                fRemoteIs       = 0x08  /**< Remote is using option. */
-                        };
-
-                        ProtocolTelnet &rPT;
-                        char fOpts;
-                        char cCode;
-                };
-                friend class Bu::ProtocolTelnet::Option;
-
-                Hash<char, Option *> hOpts;
-
-        public:
-                Option oBinary;
-                Option oEcho;
-                Option oNAWS;
-                Option oSuppressGA;
-
-        private:
-                void onWill( char cCode );
-                void onWont( char cCode );
-                void onDo( char cCode );
-                void onDont( char cCode );
-                void onSubOpt();
-                void onCtlChar( char cChr );
+    /**
+     * Telnet Protocol handler.  This attempts to provide useful and general
+     * support for most of the most commonly used Telnet extensions in a simple
+     * and easy to use way.  The Option variables control the settings that can
+     * be used on the line, and control which virtual "callbacks" will be called
+     * when different events happen.
+     *
+     * To setup initial values and to disable any options you wish override the
+     * onNewConnection function in your own class, like this:
+     *@code
+     class MyTelnet : public Bu::ProtocolTelnet
+     {
+     public:
+        ...
+
+        virtual void onNewConnection( class Bu::Client *pClient )
+        {
+            // Call the parent class' onNewConnection to get everything all
+            // set up.
+            Bu::ProtocolTelnet::onNewConnection( pClient );
+
+            // These functions disable the option to send files via telnet,
+            // disabling the remote option means that we won't accept this
+            // option (binary data being sent to us) from the client.
+            //
+            // Disabling the local option means that the client cannot ask us
+            // to send them binary data.
+            oBinary.enableRemote( false );
+            oBinary.enableLocal( false );
+
+            // This requests that the client send us window size updates
+            // whenever the size of their window changes, and an initial set to
+            // boot.
+            //
+            // To see if this option is set later, try oNAWS.isRemoteSet(), but
+            // wait a little while, asking immediatly will always return false,
+            // since the remote side has yet to receive our request.
+            oNAWS.remoteSet();
+        }
+    }
+     @endcode
+     *
+     *@ingroup Serving
+     */
+    class ProtocolTelnet : public Protocol
+    {
+    public:
+        ProtocolTelnet();
+        virtual ~ProtocolTelnet();
+
+        /**
+         * If you override this function in a child class, make sure to call
+         * this version of it as the very first thing that you do, before you
+         * set any options.  See the example in the class docs.
+         */
+        virtual void onNewConnection( class Bu::Client *pClient );
+
+        /**
+         * You should never override this function unless you really, really
+         * know what you're doing.  If you want to get data after each line
+         * entered (in canonical mode) or after any data arrives (non canonical
+         * mode) then override the gotLine and gotData functions, respectively.
+         */
+        virtual void onNewData( class Bu::Client *pClient );
+
+        /**
+         * Override this function to be notified of lines being submitted by
+         * the client.  This function is only called in canonical mode, after
+         * all edits are performed on the data.  In this mode weather you use
+         * the line or not, the data will be cleared from the buffer when this
+         * function returns, any changes made to the buffer will be destroyed.
+         */
+        virtual void gotLine( Bu::String & /*sLine*/ ){};
+
+        /**
+         * Override this function to be notified of any new data that comes in
+         * from the client.  This function is only called in non-canonical mode,
+         * and includes all raw data minus telnet control codes and ansi
+         * escape sequences.  In this mode control of the buffer is up to the
+         * child class in this function, the buffer will never be cleared unless
+         * it happens in this function's override.
+         */
+        virtual void gotData( Bu::String & /*sData*/ ){};
+
+        /**
+         * Using this function to enable or disable canonical mode only affects
+         * the way the data is processed and which virtual functions are called
+         * during processing.  It does not affect options set locally or
+         * remotely.  Setting this to false will enable char-at-a-time mode,
+         * effectively disabling internal line-editing code.  Characters
+         * such as backspace that are detected will not be handled and will be
+         * sent to the user override.  The subclass will also be notified every
+         * time new data is available, not just whole lines.
+         *
+         * When set to true (the default), line editing control codes will be
+         * interpreted and used, and the subclass will only be notified when
+         * complete lines are available in the buffer.
+         */
+        void setCanonical( bool bCon=true );
+        bool isCanonical();
+
+        void write( const Bu::String &sData );
+        void write( const char *pData, int iSize );
+        void write( char cData );
+
+        const Bu::String &getBuffer() { return sDataBuf; }
+
+    public:
+        /**
+         * If you wish to know the current dimensions of the client window,
+         * override this function, it will be called whenever the size changes.
+         */
+        virtual void onSubNAWS( uint16_t /*iWidth*/, uint16_t /*iHeight*/ ){};
+
+        /**
+         * This function is called whenever an unknown sub negotiation option is
+         * sent over the line.  This doesn't mean that it's malformatted, it
+         * just means that this class doesn't support that option yet, but you
+         * can handle it yourself if you'd like.  Feel free to change the
+         * sSubBuf, it will be cleared as soon as this function returns anyway.
+         */
+        virtual void onSubUnknown( char /*cSubOpt*/,
+            Bu::String & /*sSubBuf*/ ){};
+
+    private:
+        /**
+         * Represents a basic telnet option, either on or off, no parameters.
+         * Each Option can negotiate effectively on it's own, and has two
+         * parameters in each of two classes.  Both local and remote can be
+         * enabled/disabled and set/unset.  Enabled represents the ability to
+         * set the option, disabling an option should also unset it.  Set or
+         * unset represent wether the option is being used, if it is allowed.
+         */
+        class Option
+        {
+            friend class Bu::ProtocolTelnet;
+        private:
+            Option( ProtocolTelnet &rPT, char cCode );
+            virtual ~Option();
+
+        public:
+            void localEnable( bool bSet=true );
+            void localSet( bool bSet=true );
+            
+            bool isLocalEnabled();
+            bool isLocalSet();
+            
+            void remoteEnable( bool bSet=true );
+            void remoteSet( bool bSet=true );
+
+            bool isRemoteEnabled();
+            bool isRemoteSet();
+
+        private:
+            enum
+            {
+                fLocalCant  = 0x01, /**< Local can't/won't allow option. */
+                fLocalIs    = 0x02, /**< Local is using option. */
+                fRemoteCant = 0x04, /**< Remote can't/won't allow option. */
+                fRemoteIs   = 0x08  /**< Remote is using option. */
+            };
+
+            ProtocolTelnet &rPT;
+            char fOpts;
+            char cCode;
+        };
+        friend class Bu::ProtocolTelnet::Option;
+
+        Hash<char, Option *> hOpts;
+
+    public:
+        Option oBinary;
+        Option oEcho;
+        Option oNAWS;
+        Option oSuppressGA;
+
+    private:
+        void onWill( char cCode );
+        void onWont( char cCode );
+        void onDo( char cCode );
+        void onDont( char cCode );
+        void onSubOpt();
+        void onCtlChar( char cChr );
 
 #ifdef __TELNET_DEBUG
-                void printCode( char cCode );
-                void printOpt( char cOpt );
+        void printCode( char cCode );
+        void printOpt( char cOpt );
 #endif
 
-        private:
-                Client *pClient;
+    private:
+        Client *pClient;
 
-                Bu::String sDataBuf;    /**< Buffer for regular line data. */
-                Bu::String sSubBuf;     /**< Buffer for subnegotiation data. */
-                char cSubOpt;   /**< Which suboption are we processing. */
+        Bu::String sDataBuf;    /**< Buffer for regular line data. */
+        Bu::String sSubBuf; /**< Buffer for subnegotiation data. */
+        char cSubOpt;   /**< Which suboption are we processing. */
 
-                bool bCanonical;        /**< Are we canonicalizing incoming data? */
-                bool bSubOpt;           /**< Are we processing a suboption right now? */
-        };
+        bool bCanonical;    /**< Are we canonicalizing incoming data? */
+        bool bSubOpt;       /**< Are we processing a suboption right now? */
+    };
 }
 
 #endif
diff --git a/src/stable/queue.h b/src/stable/queue.h
index a5f41e9..213d508 100644
--- a/src/stable/queue.h
+++ b/src/stable/queue.h
@@ -10,31 +10,31 @@
 
 namespace Bu
 {
-        /**
-         * Queue abstract baseclass
-         */
-        template<typename value>
-        class Queue
-        {
-        public:
-                Queue()
-                {
-                }
+    /**
+     * Queue abstract baseclass
+     */
+    template<typename value>
+    class Queue
+    {
+    public:
+        Queue()
+        {
+        }
 
-                virtual ~Queue()
-                {
-                }
+        virtual ~Queue()
+        {
+        }
 
-                virtual void enqueue( const value &i )=0;
-                virtual value dequeue()=0;
-                virtual value &peek()=0;
-                virtual const value &peek() const=0;
-                virtual bool isEmpty() const=0;
-                virtual int getSize() const=0;
+        virtual void enqueue( const value &i )=0;
+        virtual value dequeue()=0;
+        virtual value &peek()=0;
+        virtual const value &peek() const=0;
+        virtual bool isEmpty() const=0;
+        virtual int getSize() const=0;
 
-        private:
+    private:
 
-        };
+    };
 }
 
 #endif
diff --git a/src/stable/queuebuf.cpp b/src/stable/queuebuf.cpp
index 8a3397f..2d49684 100644
--- a/src/stable/queuebuf.cpp
+++ b/src/stable/queuebuf.cpp
@@ -11,181 +11,181 @@
 using Bu::sio;
 
 Bu::QueueBuf::QueueBuf( int iBlockSize /*=256*/ ) :
-        iBlockSize( iBlockSize ),
-        iReadOffset( 0 ),
-        iWriteOffset( 0 ),
-        iTotalSize( 0 )
+    iBlockSize( iBlockSize ),
+    iReadOffset( 0 ),
+    iWriteOffset( 0 ),
+    iTotalSize( 0 )
 {
 }
 
 Bu::QueueBuf::~QueueBuf()
 {
-        for( BlockList::iterator i = lBlocks.begin(); i; i++ )
-                delete[] *i;
+    for( BlockList::iterator i = lBlocks.begin(); i; i++ )
+        delete[] *i;
 }
 
 void Bu::QueueBuf::close()
 {
-        for( BlockList::iterator i = lBlocks.begin(); i; i++ )
-                delete[] *i;
-        lBlocks.clear();
-        iReadOffset = iWriteOffset = iTotalSize = 0;
+    for( BlockList::iterator i = lBlocks.begin(); i; i++ )
+        delete[] *i;
+    lBlocks.clear();
+    iReadOffset = iWriteOffset = iTotalSize = 0;
 }
 
 Bu::size Bu::QueueBuf::read( void *pRawBuf, Bu::size nBytes )
 {
-        if( nBytes <= 0 )
-                return 0;
-
-        if( lBlocks.isEmpty() )
-                return 0;
-
-        Bu::size iLeft = nBytes;
-        char *pBuf = (char *)pRawBuf;
-
-        while( iLeft > 0 && iTotalSize > 0 )
-        {
-                if( iReadOffset == iBlockSize )
-                {
-                        removeBlock();
-                        if( lBlocks.isEmpty() )
-                        {
-                                return nBytes-iLeft;
-                        }
-                        iReadOffset = 0;
-                }
-                char *pBlock = lBlocks.first();
-                Bu::size iCopy = iBlockSize-iReadOffset;
-                if( iLeft < iCopy )
-                        iCopy = iLeft;
-                if( iTotalSize < iCopy )
-                        iCopy = iTotalSize;
-                memcpy( pBuf, pBlock+iReadOffset, iCopy );
-                iReadOffset += iCopy;
-                iLeft -= iCopy;
-                pBuf += iCopy;
-                iTotalSize -= iCopy;
-//              sio << "Read " << iCopy << " bytes, new size: " << iTotalSize << sio.nl;
-        }
-
-        return nBytes - iLeft;
+    if( nBytes <= 0 )
+        return 0;
+
+    if( lBlocks.isEmpty() )
+        return 0;
+
+    Bu::size iLeft = nBytes;
+    char *pBuf = (char *)pRawBuf;
+
+    while( iLeft > 0 && iTotalSize > 0 )
+    {
+        if( iReadOffset == iBlockSize )
+        {
+            removeBlock();
+            if( lBlocks.isEmpty() )
+            {
+                return nBytes-iLeft;
+            }
+            iReadOffset = 0;
+        }
+        char *pBlock = lBlocks.first();
+        Bu::size iCopy = iBlockSize-iReadOffset;
+        if( iLeft < iCopy )
+            iCopy = iLeft;
+        if( iTotalSize < iCopy )
+            iCopy = iTotalSize;
+        memcpy( pBuf, pBlock+iReadOffset, iCopy );
+        iReadOffset += iCopy;
+        iLeft -= iCopy;
+        pBuf += iCopy;
+        iTotalSize -= iCopy;
+//      sio << "Read " << iCopy << " bytes, new size: " << iTotalSize << sio.nl;
+    }
+
+    return nBytes - iLeft;
 }
 
 Bu::size Bu::QueueBuf::peek( void *pBuf, Bu::size nBytes )
 {
-        return peek( pBuf, nBytes, 0 );
+    return peek( pBuf, nBytes, 0 );
 }
 
 Bu::size Bu::QueueBuf::peek( void *pRawBuf, Bu::size nBytes, Bu::size nSkip )
 {
-        if( nBytes <= 0 )
-                return 0;
-
-        if( lBlocks.isEmpty() )
-                return 0;
-
-        Bu::size iLeft = nBytes;
-        char *pBuf = (char *)pRawBuf;
-
-        int iTmpReadOffset = iReadOffset + nSkip;
-        Bu::size iTmpRemSize = iTotalSize;
-        BlockList::iterator iBlock = lBlocks.begin();
-        while( iTmpReadOffset > iBlockSize )
-        {
-                iTmpReadOffset -= iBlockSize;
-                iBlock++;
-        }
-        while( iLeft > 0 && iTmpRemSize > 0 )
-        {
-                if( iTmpReadOffset == iBlockSize )
-                {
-                        iBlock++;
-                        if( iBlock == lBlocks.end() )
-                        {
-                                return nBytes-iLeft;
-                        }
-                        iTmpReadOffset = 0;
-                }
-                char *pBlock = *iBlock;
-                Bu::size iCopy = iBlockSize-iTmpReadOffset;
-                if( iLeft < iCopy )
-                        iCopy = iLeft;
-                if( iTmpRemSize < iCopy )
-                        iCopy = iTmpRemSize;
-                memcpy( pBuf, pBlock+iTmpReadOffset, iCopy );
-                iTmpReadOffset += iCopy;
-                iLeft -= iCopy;
-                pBuf += iCopy;
-                iTmpRemSize -= iCopy;
-//              sio << "Read (peek) " << iCopy << " bytes, new temp size: "
-//                      << iTmpRemSize << sio.nl;
-        }
-
-        return nBytes - iLeft;
+    if( nBytes <= 0 )
+        return 0;
+
+    if( lBlocks.isEmpty() )
+        return 0;
+
+    Bu::size iLeft = nBytes;
+    char *pBuf = (char *)pRawBuf;
+
+    int iTmpReadOffset = iReadOffset + nSkip;
+    Bu::size iTmpRemSize = iTotalSize;
+    BlockList::iterator iBlock = lBlocks.begin();
+    while( iTmpReadOffset > iBlockSize )
+    {
+        iTmpReadOffset -= iBlockSize;
+        iBlock++;
+    }
+    while( iLeft > 0 && iTmpRemSize > 0 )
+    {
+        if( iTmpReadOffset == iBlockSize )
+        {
+            iBlock++;
+            if( iBlock == lBlocks.end() )
+            {
+                return nBytes-iLeft;
+            }
+            iTmpReadOffset = 0;
+        }
+        char *pBlock = *iBlock;
+        Bu::size iCopy = iBlockSize-iTmpReadOffset;
+        if( iLeft < iCopy )
+            iCopy = iLeft;
+        if( iTmpRemSize < iCopy )
+            iCopy = iTmpRemSize;
+        memcpy( pBuf, pBlock+iTmpReadOffset, iCopy );
+        iTmpReadOffset += iCopy;
+        iLeft -= iCopy;
+        pBuf += iCopy;
+        iTmpRemSize -= iCopy;
+//      sio << "Read (peek) " << iCopy << " bytes, new temp size: "
+//          << iTmpRemSize << sio.nl;
+    }
+
+    return nBytes - iLeft;
 }
 
 Bu::size Bu::QueueBuf::write( const void *pRawBuf, Bu::size nBytes )
 {
-        if( nBytes <= 0 )
-                return 0;
-
-        if( lBlocks.isEmpty() )
-        {
-                addBlock();
-                iWriteOffset = 0;
-        }
-        Bu::size iLeft = nBytes;
-        const char *pBuf = (const char *)pRawBuf;
-
-        while( iLeft > 0 )
-        {
-                if( iWriteOffset == iBlockSize )
-                {
-                        addBlock();
-                        iWriteOffset = 0;
-                }
-                char *pBlock = lBlocks.last();
-                Bu::size iCopy = iBlockSize-iWriteOffset;
-                if( iLeft < iCopy )
-                        iCopy = iLeft;
-                memcpy( pBlock+iWriteOffset, pBuf, iCopy );
-                iWriteOffset += iCopy;
-                iLeft -= iCopy;
-                pBuf += iCopy;
-                iTotalSize += iCopy;
-//              sio << "Wrote " << iCopy << " bytes, new size: " << iTotalSize
-//                      << sio.nl;
-        }
-
-        return nBytes;
+    if( nBytes <= 0 )
+        return 0;
+
+    if( lBlocks.isEmpty() )
+    {
+        addBlock();
+        iWriteOffset = 0;
+    }
+    Bu::size iLeft = nBytes;
+    const char *pBuf = (const char *)pRawBuf;
+
+    while( iLeft > 0 )
+    {
+        if( iWriteOffset == iBlockSize )
+        {
+            addBlock();
+            iWriteOffset = 0;
+        }
+        char *pBlock = lBlocks.last();
+        Bu::size iCopy = iBlockSize-iWriteOffset;
+        if( iLeft < iCopy )
+            iCopy = iLeft;
+        memcpy( pBlock+iWriteOffset, pBuf, iCopy );
+        iWriteOffset += iCopy;
+        iLeft -= iCopy;
+        pBuf += iCopy;
+        iTotalSize += iCopy;
+//      sio << "Wrote " << iCopy << " bytes, new size: " << iTotalSize
+//          << sio.nl;
+    }
+
+    return nBytes;
 }
 
 Bu::size Bu::QueueBuf::tell()
 {
-        return -1;
+    return -1;
 }
 
 void Bu::QueueBuf::seek( Bu::size iAmnt )
 {
-        if( iAmnt <= 0 )
-                return;
-
-        if( (Bu::size)iAmnt >= iTotalSize )
-        {
-//              sio << "seek: clear all data (" << iAmnt << ">=" << iTotalSize
-//                      << ")." << sio.nl;
-                close();
-                return;
-        }
-
-        iReadOffset += iAmnt;
-        iTotalSize -= iAmnt;
-        while( iReadOffset >= iBlockSize )
-        {
-                removeBlock();
-                iReadOffset -= iBlockSize;
-//              sio << "seek: removal step (" << iReadOffset << ")" << sio.nl;
-        }
+    if( iAmnt <= 0 )
+        return;
+
+    if( (Bu::size)iAmnt >= iTotalSize )
+    {
+//      sio << "seek: clear all data (" << iAmnt << ">=" << iTotalSize
+//          << ")." << sio.nl;
+        close();
+        return;
+    }
+
+    iReadOffset += iAmnt;
+    iTotalSize -= iAmnt;
+    while( iReadOffset >= iBlockSize )
+    {
+        removeBlock();
+        iReadOffset -= iBlockSize;
+//      sio << "seek: removal step (" << iReadOffset << ")" << sio.nl;
+    }
 }
 
 void Bu::QueueBuf::setPos( Bu::size )
@@ -198,12 +198,12 @@ void Bu::QueueBuf::setPosEnd( Bu::size )
 
 bool Bu::QueueBuf::isEos()
 {
-        return iTotalSize == 0;
+    return iTotalSize == 0;
 }
 
 bool Bu::QueueBuf::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::QueueBuf::flush()
@@ -212,32 +212,32 @@ void Bu::QueueBuf::flush()
 
 bool Bu::QueueBuf::canRead()
 {
-        return iTotalSize > 0;
+    return iTotalSize > 0;
 }
 
 bool Bu::QueueBuf::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::QueueBuf::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::QueueBuf::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::QueueBuf::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::QueueBuf::isBlocking()
 {
-        return false;
+    return false;
 }
 
 void Bu::QueueBuf::setBlocking( bool )
@@ -250,29 +250,29 @@ void Bu::QueueBuf::setSize( Bu::size )
 
 Bu::size Bu::QueueBuf::getSize() const
 {
-        return iTotalSize;
+    return iTotalSize;
 }
 
 Bu::size Bu::QueueBuf::getBlockSize() const
 {
-        return iBlockSize;
+    return iBlockSize;
 }
 
 Bu::String Bu::QueueBuf::getLocation() const
 {
-        return "";
+    return "";
 }
 
 void Bu::QueueBuf::addBlock()
 {
-        lBlocks.append( new char[iBlockSize] );
-//      sio << "Added new block." << sio.nl;
+    lBlocks.append( new char[iBlockSize] );
+//  sio << "Added new block." << sio.nl;
 }
 
 void Bu::QueueBuf::removeBlock()
 {
-        delete[] lBlocks.first();
-        lBlocks.erase( lBlocks.begin() );
-//      sio << "Removed block." << sio.nl;
+    delete[] lBlocks.first();
+    lBlocks.erase( lBlocks.begin() );
+//  sio << "Removed block." << sio.nl;
 }
 
diff --git a/src/stable/queuebuf.h b/src/stable/queuebuf.h
index 6e2a075..60aa115 100644
--- a/src/stable/queuebuf.h
+++ b/src/stable/queuebuf.h
@@ -12,55 +12,55 @@
 
 namespace Bu
 {
-        /**
-         * A queuing buffer stream class.  All data written to this class is
-         * appended to it, there is no stored position.  All data read is read
-         * from the begining and then thrown away.  It operates by using a linked
-         * list of small buffers, and deallocating or reusing them when it can.
-         */
-        class QueueBuf : public Bu::Stream
-        {
-        public:
-                QueueBuf( int iBlockSize=256 );
-                virtual ~QueueBuf();
+    /**
+     * A queuing buffer stream class.  All data written to this class is
+     * appended to it, there is no stored position.  All data read is read
+     * from the begining and then thrown away.  It operates by using a linked
+     * list of small buffers, and deallocating or reusing them when it can.
+     */
+    class QueueBuf : public Bu::Stream
+    {
+    public:
+        QueueBuf( int iBlockSize=256 );
+        virtual ~QueueBuf();
 
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size peek( void *pBuf, Bu::size nBytes );
-                virtual Bu::size peek( void *pBuf, Bu::size nBytes, Bu::size nSkip );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size peek( void *pBuf, Bu::size nBytes );
+        virtual Bu::size peek( void *pBuf, Bu::size nBytes, Bu::size nSkip );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-        private:
-                void addBlock();
-                void removeBlock();
+    private:
+        void addBlock();
+        void removeBlock();
 
-        private:
-                int iBlockSize;
-                int iReadOffset;
-                int iWriteOffset;
-                Bu::size iTotalSize;
-                typedef Bu::List<char *> BlockList;
-                BlockList lBlocks;
-        };
+    private:
+        int iBlockSize;
+        int iReadOffset;
+        int iWriteOffset;
+        Bu::size iTotalSize;
+        typedef Bu::List<char *> BlockList;
+        BlockList lBlocks;
+    };
 };
 
 #endif
diff --git a/src/stable/random.cpp b/src/stable/random.cpp
index 63416bf..6dca782 100644
--- a/src/stable/random.cpp
+++ b/src/stable/random.cpp
@@ -9,39 +9,39 @@
 #include "bu/randombasic.h"
 
 Bu::Random::Random() :
-        pGen( NULL )
+    pGen( NULL )
 {
-        pGen = new RandomBasic();
+    pGen = new RandomBasic();
 }
 
 Bu::Random::~Random()
 {
-        delete pGen;
-        pGen = NULL;
+    delete pGen;
+    pGen = NULL;
 }
 
 void Bu::Random::seed( int32_t iSeed )
 {
-        getInstance().pGen->seed( iSeed );
+    getInstance().pGen->seed( iSeed );
 }
 
 int32_t Bu::Random::rand()
 {
-        return getInstance().pGen->rand();
+    return getInstance().pGen->rand();
 }
 
 int32_t Bu::Random::rand( int32_t iMax )
 {
-        return getInstance().pGen->rand( iMax );
+    return getInstance().pGen->rand( iMax );
 }
 
 int32_t Bu::Random::rand( int32_t iMin, int32_t iMax )
 {
-        return getInstance().pGen->rand( iMin, iMax );
+    return getInstance().pGen->rand( iMin, iMax );
 }
 
 double Bu::Random::randNorm()
 {
-        return getInstance().pGen->randNorm();
+    return getInstance().pGen->randNorm();
 }
 
diff --git a/src/stable/random.h b/src/stable/random.h
index 43b8917..7989188 100644
--- a/src/stable/random.h
+++ b/src/stable/random.h
@@ -12,50 +12,50 @@
 
 namespace Bu
 {
-        class RandomBase;
-        class Random : public Bu::Singleton<Bu::Random>
-        {
-        friend class Bu::Singleton<Bu::Random>;
-        private:
-                Random();
-                virtual ~Random();
-
-        public:
-                template<typename cl>
-                static void setGenerator()
-                {
-                        delete getInstance().pGen;
-                        getInstance().pGen = new cl();
-                }
-                
-                template<typename cl, typename t1>
-                static void setGenerator( t1 p1 )
-                {
-                        delete getInstance().pGen;
-                        getInstance().pGen = new cl( p1 );
-                }
-                
-                template<typename cl, typename t1, typename t2>
-                static void setGenerator( t1 p1, t2 p2 )
-                {
-                        delete getInstance().pGen;
-                        getInstance().pGen = new cl( p1, p2 );
-                }
-                
-                RandomBase &getGenerator() { return *pGen; }
-
-                static void seed( int32_t iSeed );
-                static int32_t rand();
-                static int32_t rand( int32_t iMax );
-                static int32_t rand( int32_t iMin, int32_t iMax );
-                static double randNorm();
-
-        private:
-                void checkInit();
-
-        private:
-                Bu::RandomBase *pGen;
-        };
+    class RandomBase;
+    class Random : public Bu::Singleton<Bu::Random>
+    {
+    friend class Bu::Singleton<Bu::Random>;
+    private:
+        Random();
+        virtual ~Random();
+
+    public:
+        template<typename cl>
+        static void setGenerator()
+        {
+            delete getInstance().pGen;
+            getInstance().pGen = new cl();
+        }
+        
+        template<typename cl, typename t1>
+        static void setGenerator( t1 p1 )
+        {
+            delete getInstance().pGen;
+            getInstance().pGen = new cl( p1 );
+        }
+        
+        template<typename cl, typename t1, typename t2>
+        static void setGenerator( t1 p1, t2 p2 )
+        {
+            delete getInstance().pGen;
+            getInstance().pGen = new cl( p1, p2 );
+        }
+        
+        RandomBase &getGenerator() { return *pGen; }
+
+        static void seed( int32_t iSeed );
+        static int32_t rand();
+        static int32_t rand( int32_t iMax );
+        static int32_t rand( int32_t iMin, int32_t iMax );
+        static double randNorm();
+
+    private:
+        void checkInit();
+
+    private:
+        Bu::RandomBase *pGen;
+    };
 };
 
 #endif
diff --git a/src/stable/randombase.h b/src/stable/randombase.h
index d33bb99..946284f 100644
--- a/src/stable/randombase.h
+++ b/src/stable/randombase.h
@@ -11,25 +11,25 @@
 
 namespace Bu
 {
-        class RandomBase
-        {
-        public:
-                RandomBase();
-                virtual ~RandomBase();
+    class RandomBase
+    {
+    public:
+        RandomBase();
+        virtual ~RandomBase();
 
-                virtual void seed( int32_t iSeed )=0;
-                virtual int32_t rand()=0;
-                virtual inline int32_t rand( int32_t iMax ) {
-                        return rand( 0, iMax );
-                }
-                virtual inline int32_t rand( int32_t iMin, int32_t iMax ) {
-                        return iMin+(randNorm()*(iMax-iMin));
-                }
-                virtual inline double randNorm() {
-                        return (((uint32_t)rand())&0xfffffffeul)*0x1.00000001p-32;
-//                      return (((uint32_t)rand())&0xfffffffeul)/(double)(0xfffffffful);
-                }
-        };
+        virtual void seed( int32_t iSeed )=0;
+        virtual int32_t rand()=0;
+        virtual inline int32_t rand( int32_t iMax ) {
+            return rand( 0, iMax );
+        }
+        virtual inline int32_t rand( int32_t iMin, int32_t iMax ) {
+            return iMin+(randNorm()*(iMax-iMin));
+        }
+        virtual inline double randNorm() {
+            return (((uint32_t)rand())&0xfffffffeul)*0x1.00000001p-32;
+//          return (((uint32_t)rand())&0xfffffffeul)/(double)(0xfffffffful);
+        }
+    };
 };
 
 #endif
diff --git a/src/stable/randombasic.cpp b/src/stable/randombasic.cpp
index 89e2780..e253b70 100644
--- a/src/stable/randombasic.cpp
+++ b/src/stable/randombasic.cpp
@@ -8,9 +8,9 @@
 #include "bu/randombasic.h"
 
 Bu::RandomBasic::RandomBasic() :
-        a( 6364136223846793005ll ),
-        c( 1442695040888963407ll ),
-        x( 0 )
+    a( 6364136223846793005ll ),
+    c( 1442695040888963407ll ),
+    x( 0 )
 {
 }
 
@@ -20,12 +20,12 @@ Bu::RandomBasic::~RandomBasic()
 
 void Bu::RandomBasic::seed( int32_t iSeed )
 {
-        c = iSeed;
+    c = iSeed;
 }
 
 int32_t Bu::RandomBasic::rand()
 {
-        x = (a*x + c);
-        return (int32_t)x;
+    x = (a*x + c);
+    return (int32_t)x;
 }
 
diff --git a/src/stable/randombasic.h b/src/stable/randombasic.h
index a53e16f..4d1c2f8 100644
--- a/src/stable/randombasic.h
+++ b/src/stable/randombasic.h
@@ -11,19 +11,19 @@
 
 namespace Bu
 {
-        class RandomBasic : public RandomBase
-        {
-        public:
-                RandomBasic();
-                virtual ~RandomBasic();
+    class RandomBasic : public RandomBase
+    {
+    public:
+        RandomBasic();
+        virtual ~RandomBasic();
 
-                virtual void seed( int32_t iSeed );
+        virtual void seed( int32_t iSeed );
 
-                virtual int32_t rand();
+        virtual int32_t rand();
 
-        private:
-                int64_t a, c, x;
-        };
+    private:
+        int64_t a, c, x;
+    };
 };
 
 #endif
diff --git a/src/stable/randomcmwc.cpp b/src/stable/randomcmwc.cpp
index 9f68982..1d4a913 100644
--- a/src/stable/randomcmwc.cpp
+++ b/src/stable/randomcmwc.cpp
@@ -12,52 +12,52 @@
 #define PHI 0x9e3779b9
 
 Bu::RandomCmwc::RandomCmwc() :
-        q( 0 ),
-        c( 362436 )
+    q( 0 ),
+    c( 362436 )
 {
-        q = new uint32_t[4096];
+    q = new uint32_t[4096];
 }
 
 Bu::RandomCmwc::~RandomCmwc()
 {
-        delete[] q;
+    delete[] q;
 }
 
 void Bu::RandomCmwc::seed( int32_t iSeed )
 {
-        i = 4095;
-        c = 362436;
+    i = 4095;
+    c = 362436;
 
-        Bu::RandomBasic rb;
-        rb.seed( iSeed );
+    Bu::RandomBasic rb;
+    rb.seed( iSeed );
 
-        for( int j = 0; j < 4096; j++ )
-                q[j] = rb.rand();
+    for( int j = 0; j < 4096; j++ )
+        q[j] = rb.rand();
 
-        c = rb.rand();
+    c = rb.rand();
 
-        return;
-        q[0] = (uint32_t)rb.rand();
-        q[1] = (uint32_t)rb.rand() + PHI;
-        q[2] = (uint32_t)rb.rand() + PHI + PHI;
+    return;
+    q[0] = (uint32_t)rb.rand();
+    q[1] = (uint32_t)rb.rand() + PHI;
+    q[2] = (uint32_t)rb.rand() + PHI + PHI;
 
-        for (int j = 3; j < 4096; j++)
-                q[j] = q[j - 3] ^ q[j - 2] ^ PHI ^ j;
+    for (int j = 3; j < 4096; j++)
+        q[j] = q[j - 3] ^ q[j - 2] ^ PHI ^ j;
 }
 
 int32_t Bu::RandomCmwc::rand()
 {
-        uint64_t t, a = 18782LL;
-        uint32_t x, r = 0xfffffffe;
-        i = (i + 1) & 4095;
-        t = a * q[i] + c;
-        c = (t >> 32);
-        x = t + c;
-        if( x < c )
-        {
-                x++;
-                c++;
-        }
-        return (q[i] = r - x);
+    uint64_t t, a = 18782LL;
+    uint32_t x, r = 0xfffffffe;
+    i = (i + 1) & 4095;
+    t = a * q[i] + c;
+    c = (t >> 32);
+    x = t + c;
+    if( x < c )
+    {
+        x++;
+        c++;
+    }
+    return (q[i] = r - x);
 }
 
diff --git a/src/stable/randomcmwc.h b/src/stable/randomcmwc.h
index fff891b..547b5bb 100644
--- a/src/stable/randomcmwc.h
+++ b/src/stable/randomcmwc.h
@@ -11,19 +11,19 @@
 
 namespace Bu
 {
-        class RandomCmwc : public RandomBase
-        {
-        public:
-                RandomCmwc();
-                virtual ~RandomCmwc();
+    class RandomCmwc : public RandomBase
+    {
+    public:
+        RandomCmwc();
+        virtual ~RandomCmwc();
 
-                virtual void seed( int32_t iSeed );
+        virtual void seed( int32_t iSeed );
 
-                virtual int32_t rand();
+        virtual int32_t rand();
 
-        private:
-                uint32_t *q, c, i;
-        };
+    private:
+        uint32_t *q, c, i;
+    };
 };
 
 #endif
diff --git a/src/stable/randomsystem.cpp b/src/stable/randomsystem.cpp
index 0501587..68c69d5 100644
--- a/src/stable/randomsystem.cpp
+++ b/src/stable/randomsystem.cpp
@@ -2,39 +2,39 @@
 #include "bu/file.h"
 
 Bu::RandomSystem::RandomSystem( Type eType ) :
-        eType( eType ),
-        pSrc( 0 )
+    eType( eType ),
+    pSrc( 0 )
 {
-        switch( eType )
-        {
-                case Bu::RandomSystem::Fast:
-                        pSrc = new Bu::File("/dev/urandom", Bu::File::Read );
-                        break;
+    switch( eType )
+    {
+        case Bu::RandomSystem::Fast:
+            pSrc = new Bu::File("/dev/urandom", Bu::File::Read );
+            break;
 
-                case Bu::RandomSystem::Good:
-                        pSrc = new Bu::File("/dev/random", Bu::File::Read );
-                        break;
-        }
+        case Bu::RandomSystem::Good:
+            pSrc = new Bu::File("/dev/random", Bu::File::Read );
+            break;
+    }
 }
 
 Bu::RandomSystem::~RandomSystem()
 {
-        delete pSrc;
+    delete pSrc;
 }
 
 void Bu::RandomSystem::seed( int32_t /*iSeed*/ )
 {
-        // Seed really has no effect here...
-        // on linux, if we were root, we could write data to random/urandom to
-        // perturb the data, but it's not necesarry
+    // Seed really has no effect here...
+    // on linux, if we were root, we could write data to random/urandom to
+    // perturb the data, but it's not necesarry
 }
 
 int32_t Bu::RandomSystem::rand()
 {
-        if( !pSrc )
-                throw Bu::ExceptionBase("Not initialized");
-        int32_t i;
-        pSrc->read( &i, sizeof(int32_t) );
-        return i;
+    if( !pSrc )
+        throw Bu::ExceptionBase("Not initialized");
+    int32_t i;
+    pSrc->read( &i, sizeof(int32_t) );
+    return i;
 }
 
diff --git a/src/stable/randomsystem.h b/src/stable/randomsystem.h
index 7106d58..63b40f3 100644
--- a/src/stable/randomsystem.h
+++ b/src/stable/randomsystem.h
@@ -11,27 +11,27 @@
 
 namespace Bu
 {
-        class File;
-        class RandomSystem : public RandomBase
-        {
-        public:
-                enum Type
-                {
-                        Fast,
-                        Good
-                };
+    class File;
+    class RandomSystem : public RandomBase
+    {
+    public:
+        enum Type
+        {
+            Fast,
+            Good
+        };
 
-                RandomSystem( Type eType=Fast );
-                virtual ~RandomSystem();
+        RandomSystem( Type eType=Fast );
+        virtual ~RandomSystem();
 
-                virtual void seed( int32_t iSeed );
+        virtual void seed( int32_t iSeed );
 
-                virtual int32_t rand();
+        virtual int32_t rand();
 
-        private:
-                Type eType;
-                File *pSrc;
-        };
+    private:
+        Type eType;
+        File *pSrc;
+    };
 };
 
 #endif
diff --git a/src/stable/ringbuffer.h b/src/stable/ringbuffer.h
index 79c5a15..39d053e 100644
--- a/src/stable/ringbuffer.h
+++ b/src/stable/ringbuffer.h
@@ -15,237 +15,237 @@
 
 namespace Bu
 {
-        template<typename value, typename valuealloc> class RingBuffer;
-
-        /** @cond DEVEL */
-        template<typename value, typename valuealloc>
-        class RingBufferCore
-        {
-        friend class RingBuffer<value, valuealloc>;
-        friend class SharedCore<RingBuffer<value, valuealloc>,
-                   RingBufferCore<value, valuealloc> >;
-        private:
-                RingBufferCore() :
-                        iCapacity( 0 ),
-                        iStart( -1 ),
-                        iEnd( -2 ),
-                        aData( NULL )
-                {
-                }
-
-                virtual ~RingBufferCore()
-                {
-                        clear();
-                }
-
-                void init( int iNewCapacity )
-                {
-                        if( iCapacity > 0 )
-                                return;
-
-                        iCapacity = iNewCapacity;
-                        iStart = -1;
-                        iEnd = -2;
-                        aData = va.allocate( iCapacity );
-                }
-
-                void clear()
-                {
-                        for( int j = iStart; j < iEnd; j=(j+1%iCapacity) )
-                        {
-                                va.destroy( &aData[j] );
-                        }
-                        va.deallocate( aData, iCapacity );
-                        aData = NULL;
-                        iCapacity = 0;
-                }
-                
-                void enqueue( const value &v )
-                {
-                        if( iStart == -1 )
-                        {
-                                iStart = 0;
-                                iEnd = 1;
-                                va.construct( &aData[0], v );
-                                return;
-                        }
-                        else if( iStart == iEnd )
-                        {
-                                // The ringbuffer is full
-                                dequeue();
-                        }
-                        va.construct( &aData[iEnd], v );
-                        iEnd = (iEnd+1)%iCapacity;
-                }
-
-                value dequeue()
-                {
-                        if( iStart == -1 )
-                        {
-                                throw ExceptionBase("No data");
-                        }
-                        else
-                        {
-                                value &v = aData[iStart];
-                                va.destroy( &aData[iStart] );
-                                iStart = (iStart+1)%iCapacity;
-                                if( iStart == iEnd )
-                                {
-                                        iStart = -1;
-                                        iEnd = -2;
-                                }
-                                return v;
-                        }
-                }
-
-                value &get( int iIndex )
-                {
-                        return aData[(iIndex+iStart)%iCapacity];
-                }
-
-                value &first()
-                {
-                        return aData[iStart];
-                }
-
-                value &last()
-                {
-                        return aData[(iEnd-1+iCapacity)%iCapacity];
-                }
-
-                int getSize()
-                {
-                        if( iStart < 0 )
-                                return 0;
-                        if( iEnd == iStart )
-                                return iCapacity;
-                        if( iEnd < iStart )
-                                return iEnd-iStart;
-                        return iCapacity-(iEnd-iStart);
-                }
-
-                int iCapacity;
-                int iStart, iEnd;
-                value *aData;
-                valuealloc va;
-        };
-        /** @endcond */
-
-        /**
-         *@ingroup Containers
-         */
-        template<typename value, typename valuealloc=std::allocator<value> >
-        class RingBuffer : public Queue<value>, public SharedCore<
-                                           RingBuffer<value, valuealloc>,
-                                           RingBufferCore<value, valuealloc>
-                                           >
-        {
-        private:
-                typedef RingBuffer<value, valuealloc> MyType;
-                typedef RingBufferCore<value, valuealloc> Core;
-
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_allocateCore;
-
-        public:
-                RingBuffer( int iCapacity )
-                {
-                        core->init( iCapacity );
-                }
-
-                RingBuffer( const RingBuffer &rSrc ) :
-                        SharedCore<MyType, Core>( rSrc )
-                {
-                }
-
-                virtual ~RingBuffer()
-                {
-                }
-
-                int getCapacity() const
-                {
-                        return core->iCapacity;
-                }
-
-                bool isFilled() const
-                {
-                        return (core->iStart == core->iEnd);
-                }
-
-                bool isEmpty() const
-                {
-                        return (core->iStart == -1);
-                }
-
-                virtual void enqueue( const value &v )
-                {
-                        _hardCopy();
-
-                        core->enqueue( v );
-                }
-
-                virtual value dequeue()
-                {
-                        _hardCopy();
-
-                        return core->dequeue();
-                }
-
-                virtual int getSize() const
-                {
-                        return core->getSize();
-                }
-
-                virtual value &peek()
-                {
-                        _hardCopy();
-
-                        return core->get( 0 );
-                }
-
-                virtual const value &peek() const
-                {
-                        return core->get( 0 );
-                }
-
-                virtual value &first()
-                {
-                        _hardCopy();
-
-                        return core->first();
-                }
-
-                virtual value &last()
-                {
-                        _hardCopy();
-
-                        return core->last();
-                }
-
-                value &operator[]( int iIndex )
-                {
-                        _hardCopy();
-
-                        return core->get( iIndex );
-                }
-
-        protected:
-                virtual Core *_copyCore( Core *src )
-                {
-                        Core *pRet = _allocateCore();
-
-                        pRet->init( src->iCapacity );
-                        int iSize = src->getSize();
-                        for( int j = 0; j < iSize; j++ )
-                        {
-                                pRet->enqueue( src->get( j ) );
-                        }
-
-                        return pRet;
-                }
-        };
+    template<typename value, typename valuealloc> class RingBuffer;
+
+    /** @cond DEVEL */
+    template<typename value, typename valuealloc>
+    class RingBufferCore
+    {
+    friend class RingBuffer<value, valuealloc>;
+    friend class SharedCore<RingBuffer<value, valuealloc>,
+           RingBufferCore<value, valuealloc> >;
+    private:
+        RingBufferCore() :
+            iCapacity( 0 ),
+            iStart( -1 ),
+            iEnd( -2 ),
+            aData( NULL )
+        {
+        }
+
+        virtual ~RingBufferCore()
+        {
+            clear();
+        }
+
+        void init( int iNewCapacity )
+        {
+            if( iCapacity > 0 )
+                return;
+
+            iCapacity = iNewCapacity;
+            iStart = -1;
+            iEnd = -2;
+            aData = va.allocate( iCapacity );
+        }
+
+        void clear()
+        {
+            for( int j = iStart; j < iEnd; j=(j+1%iCapacity) )
+            {
+                va.destroy( &aData[j] );
+            }
+            va.deallocate( aData, iCapacity );
+            aData = NULL;
+            iCapacity = 0;
+        }
+        
+        void enqueue( const value &v )
+        {
+            if( iStart == -1 )
+            {
+                iStart = 0;
+                iEnd = 1;
+                va.construct( &aData[0], v );
+                return;
+            }
+            else if( iStart == iEnd )
+            {
+                // The ringbuffer is full
+                dequeue();
+            }
+            va.construct( &aData[iEnd], v );
+            iEnd = (iEnd+1)%iCapacity;
+        }
+
+        value dequeue()
+        {
+            if( iStart == -1 )
+            {
+                throw ExceptionBase("No data");
+            }
+            else
+            {
+                value &v = aData[iStart];
+                va.destroy( &aData[iStart] );
+                iStart = (iStart+1)%iCapacity;
+                if( iStart == iEnd )
+                {
+                    iStart = -1;
+                    iEnd = -2;
+                }
+                return v;
+            }
+        }
+
+        value &get( int iIndex )
+        {
+            return aData[(iIndex+iStart)%iCapacity];
+        }
+
+        value &first()
+        {
+            return aData[iStart];
+        }
+
+        value &last()
+        {
+            return aData[(iEnd-1+iCapacity)%iCapacity];
+        }
+
+        int getSize()
+        {
+            if( iStart < 0 )
+                return 0;
+            if( iEnd == iStart )
+                return iCapacity;
+            if( iEnd < iStart )
+                return iEnd-iStart;
+            return iCapacity-(iEnd-iStart);
+        }
+
+        int iCapacity;
+        int iStart, iEnd;
+        value *aData;
+        valuealloc va;
+    };
+    /** @endcond */
+
+    /**
+     *@ingroup Containers
+     */
+    template<typename value, typename valuealloc=std::allocator<value> >
+    class RingBuffer : public Queue<value>, public SharedCore<
+                       RingBuffer<value, valuealloc>,
+                       RingBufferCore<value, valuealloc>
+                       >
+    {
+    private:
+        typedef RingBuffer<value, valuealloc> MyType;
+        typedef RingBufferCore<value, valuealloc> Core;
+
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_allocateCore;
+
+    public:
+        RingBuffer( int iCapacity )
+        {
+            core->init( iCapacity );
+        }
+
+        RingBuffer( const RingBuffer &rSrc ) :
+            SharedCore<MyType, Core>( rSrc )
+        {
+        }
+
+        virtual ~RingBuffer()
+        {
+        }
+
+        int getCapacity() const
+        {
+            return core->iCapacity;
+        }
+
+        bool isFilled() const
+        {
+            return (core->iStart == core->iEnd);
+        }
+
+        bool isEmpty() const
+        {
+            return (core->iStart == -1);
+        }
+
+        virtual void enqueue( const value &v )
+        {
+            _hardCopy();
+
+            core->enqueue( v );
+        }
+
+        virtual value dequeue()
+        {
+            _hardCopy();
+
+            return core->dequeue();
+        }
+
+        virtual int getSize() const
+        {
+            return core->getSize();
+        }
+
+        virtual value &peek()
+        {
+            _hardCopy();
+
+            return core->get( 0 );
+        }
+
+        virtual const value &peek() const
+        {
+            return core->get( 0 );
+        }
+
+        virtual value &first()
+        {
+            _hardCopy();
+
+            return core->first();
+        }
+
+        virtual value &last()
+        {
+            _hardCopy();
+
+            return core->last();
+        }
+
+        value &operator[]( int iIndex )
+        {
+            _hardCopy();
+
+            return core->get( iIndex );
+        }
+
+    protected:
+        virtual Core *_copyCore( Core *src )
+        {
+            Core *pRet = _allocateCore();
+
+            pRet->init( src->iCapacity );
+            int iSize = src->getSize();
+            for( int j = 0; j < iSize; j++ )
+            {
+                pRet->enqueue( src->get( j ) );
+            }
+
+            return pRet;
+        }
+    };
 }
 
 #endif
diff --git a/src/stable/server.cpp b/src/stable/server.cpp
index 39ff7bb..e6c256e 100644
--- a/src/stable/server.cpp
+++ b/src/stable/server.cpp
@@ -14,138 +14,138 @@
 #include "bu/config.h"
 
 Bu::Server::Server() :
-        nTimeoutSec( 0 ),
-        nTimeoutUSec( 0 ),
-        bAutoTick( false )
+    nTimeoutSec( 0 ),
+    nTimeoutUSec( 0 ),
+    bAutoTick( false )
 {
-        FD_ZERO( &fdActive );
+    FD_ZERO( &fdActive );
 }
 
 Bu::Server::~Server()
 {
-        shutdown();
+    shutdown();
 }
 
 void Bu::Server::addPort( int nPort, int nPoolSize )
 {
-        TcpServerSocket *s = new TcpServerSocket( nPort, nPoolSize );
-        socket_t nSocket = s->getSocket();
-        FD_SET( nSocket, &fdActive );
-        hServers.insert( nSocket, s );
+    TcpServerSocket *s = new TcpServerSocket( nPort, nPoolSize );
+    socket_t nSocket = s->getSocket();
+    FD_SET( nSocket, &fdActive );
+    hServers.insert( nSocket, s );
 }
 
 void Bu::Server::addPort( const String &sAddr, int nPort, int nPoolSize )
 {
-        TcpServerSocket *s = new TcpServerSocket( sAddr, nPort, nPoolSize );
-        socket_t nSocket = s->getSocket();
-        FD_SET( nSocket, &fdActive );
-        hServers.insert( nSocket, s );
+    TcpServerSocket *s = new TcpServerSocket( sAddr, nPort, nPoolSize );
+    socket_t nSocket = s->getSocket();
+    FD_SET( nSocket, &fdActive );
+    hServers.insert( nSocket, s );
 }
 
 void Bu::Server::setTimeout( int nTimeoutSec, int nTimeoutUSec )
 {
-        this->nTimeoutSec = nTimeoutSec;
-        this->nTimeoutUSec = nTimeoutUSec;
+    this->nTimeoutSec = nTimeoutSec;
+    this->nTimeoutUSec = nTimeoutUSec;
 }
 
 void Bu::Server::scan()
 {
-        struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
-        
-        fd_set fdRead = fdActive;
-        fd_set fdWrite /* = fdActive*/;
-        fd_set fdException = fdActive;
-
-        FD_ZERO( &fdWrite );
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                if( (*i)->hasOutput() )
-                        FD_SET( i.getKey(), &fdWrite );
-        }
-
-        if( TEMP_FAILURE_RETRY( select( FD_SETSIZE,
-                        &fdRead, &fdWrite, &fdException, &xTimeout ) ) < 0 )
-        {
-                throw ExceptionBase("Error attempting to scan open connections.");
-        }
-
-        for( int j = 0; j < FD_SETSIZE; j++ )
-        {
-                if( FD_ISSET( j, &fdRead ) )
-                {
-                        if( hServers.has( j ) )
-                        {
-                                TcpServerSocket *pSrv = hServers.get( j );
-                                addClient( pSrv->accept(), pSrv->getPort() );
-                        }
-                        else
-                        {
-                                Client *pClient = hClients.get( j );
-                                pClient->processInput();
-                                if( !pClient->isOpen() )
-                                {
-                                        closeClient( j );
-                                }
-                        }
-                }
-                if( FD_ISSET( j, &fdWrite ) )
-                {
-                        try
-                        {
-                                Client *pClient = hClients.get( j );
-                                try
-                                {
-                                        pClient->processOutput();
-                                }
-                                catch( Bu::TcpSocketException &e )
-                                {
-                                        closeClient( j );
-                                }
-                        }
-                        catch( Bu::HashException &e )
-                        {
-                                // Do nothing, I guess, the client is already dead...
-                                // TODO:  Someday, we may want to handle this more graceully.
-                        }
-                }
-        }
-
-        Bu::List<int> lDelete;
-        // Now we just try to write all the pending data on all the sockets.
-        // this could be done better eventually, if we care about the socket
-        // wanting to accept writes (using a select).
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                if( (*i)->wantsDisconnect() && !(*i)->hasOutput() )
-                {
-                        lDelete.append( i.getKey() );
-                }
-        }
-
-        for( Bu::List<int>::iterator i = lDelete.begin(); i != lDelete.end(); i++ )
-        {
-                closeClient( *i );
-        }
-
-        if( bAutoTick )
-                tick();
+    struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
+    
+    fd_set fdRead = fdActive;
+    fd_set fdWrite /* = fdActive*/;
+    fd_set fdException = fdActive;
+
+    FD_ZERO( &fdWrite );
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        if( (*i)->hasOutput() )
+            FD_SET( i.getKey(), &fdWrite );
+    }
+
+    if( TEMP_FAILURE_RETRY( select( FD_SETSIZE,
+            &fdRead, &fdWrite, &fdException, &xTimeout ) ) < 0 )
+    {
+        throw ExceptionBase("Error attempting to scan open connections.");
+    }
+
+    for( int j = 0; j < FD_SETSIZE; j++ )
+    {
+        if( FD_ISSET( j, &fdRead ) )
+        {
+            if( hServers.has( j ) )
+            {
+                TcpServerSocket *pSrv = hServers.get( j );
+                addClient( pSrv->accept(), pSrv->getPort() );
+            }
+            else
+            {
+                Client *pClient = hClients.get( j );
+                pClient->processInput();
+                if( !pClient->isOpen() )
+                {
+                    closeClient( j );
+                }
+            }
+        }
+        if( FD_ISSET( j, &fdWrite ) )
+        {
+            try
+            {
+                Client *pClient = hClients.get( j );
+                try
+                {
+                    pClient->processOutput();
+                }
+                catch( Bu::TcpSocketException &e )
+                {
+                    closeClient( j );
+                }
+            }
+            catch( Bu::HashException &e )
+            {
+                // Do nothing, I guess, the client is already dead...
+                // TODO:  Someday, we may want to handle this more graceully.
+            }
+        }
+    }
+
+    Bu::List<int> lDelete;
+    // Now we just try to write all the pending data on all the sockets.
+    // this could be done better eventually, if we care about the socket
+    // wanting to accept writes (using a select).
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        if( (*i)->wantsDisconnect() && !(*i)->hasOutput() )
+        {
+            lDelete.append( i.getKey() );
+        }
+    }
+
+    for( Bu::List<int>::iterator i = lDelete.begin(); i != lDelete.end(); i++ )
+    {
+        closeClient( *i );
+    }
+
+    if( bAutoTick )
+        tick();
 }
 
 void Bu::Server::addClient( socket_t nSocket, int nPort )
 {
-        FD_SET( nSocket, &fdActive );
+    FD_SET( nSocket, &fdActive );
 
-        Client *c = new Client(
-                new Bu::TcpSocket( nSocket ),
-                new SrvClientLinkFactory()
-                );
-        hClients.insert( nSocket, c );
+    Client *c = new Client(
+        new Bu::TcpSocket( nSocket ),
+        new SrvClientLinkFactory()
+        );
+    hClients.insert( nSocket, c );
 
-        onNewConnection( c, nPort );
+    onNewConnection( c, nPort );
 }
 
 Bu::Server::SrvClientLink::SrvClientLink( Bu::Client *pClient ) :
-        pClient( pClient )
+    pClient( pClient )
 {
 }
 
@@ -155,7 +155,7 @@ Bu::Server::SrvClientLink::~SrvClientLink()
 
 void Bu::Server::SrvClientLink::sendMessage( const Bu::String &sMsg )
 {
-        pClient->onMessage( sMsg );
+    pClient->onMessage( sMsg );
 }
 
 Bu::Server::SrvClientLinkFactory::SrvClientLinkFactory()
@@ -167,48 +167,48 @@ Bu::Server::SrvClientLinkFactory::~SrvClientLinkFactory()
 }
 
 Bu::ClientLink *Bu::Server::SrvClientLinkFactory::createLink(
-                Bu::Client *pClient )
+        Bu::Client *pClient )
 {
-        return new SrvClientLink( pClient );
+    return new SrvClientLink( pClient );
 }
 
 void Bu::Server::setAutoTick( bool bEnable )
 {
-        bAutoTick = bEnable;
+    bAutoTick = bEnable;
 }
 
 void Bu::Server::tick()
 {
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                (*i)->tick();
-        }
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        (*i)->tick();
+    }
 }
 
 void Bu::Server::shutdown()
 {
-        for( SrvHash::iterator i = hServers.begin(); i != hServers.end(); i++ )
-        {
-                delete *i;
-        }
+    for( SrvHash::iterator i = hServers.begin(); i != hServers.end(); i++ )
+    {
+        delete *i;
+    }
 
-        hServers.clear();
+    hServers.clear();
 
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                closeClient( i.getKey() );
-        }
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        closeClient( i.getKey() );
+    }
 
-        hClients.clear();
+    hClients.clear();
 }
 
 void Bu::Server::closeClient( socket_t iSocket )
 {
-        Bu::Client *pClient = hClients.get( iSocket );
-        onClosedConnection( pClient );
-        pClient->close();
-        hClients.erase( iSocket );
-        FD_CLR( iSocket, &fdActive );
-        delete pClient;
+    Bu::Client *pClient = hClients.get( iSocket );
+    onClosedConnection( pClient );
+    pClient->close();
+    hClients.erase( iSocket );
+    FD_CLR( iSocket, &fdActive );
+    delete pClient;
 }
 
diff --git a/src/stable/server.h b/src/stable/server.h
index 5a414d9..05ec018 100644
--- a/src/stable/server.h
+++ b/src/stable/server.h
@@ -11,7 +11,7 @@
 #include <stdint.h>
 
 #ifndef WIN32
-        #include <sys/select.h>
+    #include <sys/select.h>
 #endif
 
 #include "bu/string.h"
@@ -25,90 +25,90 @@
 
 namespace Bu
 {
-        class TcpServerSocket;
-        class TcpSocket;
-        class Client;
-
-        /**
-         * Core of a network server.  This class is distinct from a ServerSocket in
-         * that a ServerSocket is one listening socket, nothing more.  Socket will
-         * manage a pool of both ServerSockets and connected Sockets along with
-         * their protocols and buffers.
-         *
-         * To start serving on a new port, use the addPort functions.  Each call to
-         * addPort creates a new ServerSocket, starts it listening, and adds it to
-         * the server pool.
-         *
-         * All of the real work is done by scan, which will wait for up
-         * to the timeout set by setTimeout before returning if there is no data
-         * pending.  scan should probably be called in some sort of tight
-         * loop, possibly in it's own thread, or in the main control loop.
-         *
-         * In order to use a Server you must subclass it and implement the pure
-         * virtual functions.  These allow you to receive notification of events
-         * happening within the server itself, and actually makes it useful.
-         *@ingroup Serving
-         */
-        class Server
-        {
-        public:
-                Server();
-                virtual ~Server();
+    class TcpServerSocket;
+    class TcpSocket;
+    class Client;
+
+    /**
+     * Core of a network server.  This class is distinct from a ServerSocket in
+     * that a ServerSocket is one listening socket, nothing more.  Socket will
+     * manage a pool of both ServerSockets and connected Sockets along with
+     * their protocols and buffers.
+     *
+     * To start serving on a new port, use the addPort functions.  Each call to
+     * addPort creates a new ServerSocket, starts it listening, and adds it to
+     * the server pool.
+     *
+     * All of the real work is done by scan, which will wait for up
+     * to the timeout set by setTimeout before returning if there is no data
+     * pending.  scan should probably be called in some sort of tight
+     * loop, possibly in it's own thread, or in the main control loop.
+     *
+     * In order to use a Server you must subclass it and implement the pure
+     * virtual functions.  These allow you to receive notification of events
+     * happening within the server itself, and actually makes it useful.
+     *@ingroup Serving
+     */
+    class Server
+    {
+    public:
+        Server();
+        virtual ~Server();
 
 #ifdef WIN32
-                typedef unsigned int socket_t;
+        typedef unsigned int socket_t;
 #else
-                typedef int socket_t;
+        typedef int socket_t;
 #endif
 
-                void addPort( int nPort, int nPoolSize=40 );
-                void addPort( const String &sAddr, int nPort, int nPoolSize=40 );
+        void addPort( int nPort, int nPoolSize=40 );
+        void addPort( const String &sAddr, int nPort, int nPoolSize=40 );
 
-                virtual void scan();
-                void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
+        virtual void scan();
+        void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
 
-                void addClient( socket_t nSocket, int nPort );
+        void addClient( socket_t nSocket, int nPort );
 
-                void setAutoTick( bool bEnable=true );
-                void tick();
+        void setAutoTick( bool bEnable=true );
+        void tick();
 
-                virtual void onNewConnection( Client *pClient, int nPort )=0;
-                virtual void onClosedConnection( Client *pClient )=0;
+        virtual void onNewConnection( Client *pClient, int nPort )=0;
+        virtual void onClosedConnection( Client *pClient )=0;
 
-                void shutdown();
+        void shutdown();
 
-        private:
-                void closeClient( socket_t iSocket );
-                class SrvClientLink : public Bu::ClientLink
-                {
-                public:
-                        SrvClientLink( Bu::Client *pClient );
-                        virtual ~SrvClientLink();
+    private:
+        void closeClient( socket_t iSocket );
+        class SrvClientLink : public Bu::ClientLink
+        {
+        public:
+            SrvClientLink( Bu::Client *pClient );
+            virtual ~SrvClientLink();
 
-                        virtual void sendMessage( const Bu::String &sMsg );
+            virtual void sendMessage( const Bu::String &sMsg );
 
-                private:
-                        Bu::Client *pClient;
-                };
+        private:
+            Bu::Client *pClient;
+        };
 
-                class SrvClientLinkFactory : public Bu::ClientLinkFactory
-                {
-                public:
-                        SrvClientLinkFactory();
-                        virtual ~SrvClientLinkFactory();
+        class SrvClientLinkFactory : public Bu::ClientLinkFactory
+        {
+        public:
+            SrvClientLinkFactory();
+            virtual ~SrvClientLinkFactory();
 
-                        virtual Bu::ClientLink *createLink( Bu::Client *pClient );
-                };
+            virtual Bu::ClientLink *createLink( Bu::Client *pClient );
+        };
 
-                int nTimeoutSec;
-                int nTimeoutUSec;
-                fd_set fdActive;
-                typedef Hash<socket_t,TcpServerSocket *> SrvHash;
-                SrvHash hServers;
-                typedef Hash<socket_t,Client *> ClientHash;
-                ClientHash hClients;
-                bool bAutoTick;
-        };
+        int nTimeoutSec;
+        int nTimeoutUSec;
+        fd_set fdActive;
+        typedef Hash<socket_t,TcpServerSocket *> SrvHash;
+        SrvHash hServers;
+        typedef Hash<socket_t,Client *> ClientHash;
+        ClientHash hClients;
+        bool bAutoTick;
+    };
 }
 
 #endif
diff --git a/src/stable/sha1.cpp b/src/stable/sha1.cpp
index e6a85cc..30e5dc8 100644
--- a/src/stable/sha1.cpp
+++ b/src/stable/sha1.cpp
@@ -12,15 +12,15 @@
 #include "bu/sha1.h"

 

 Bu::Sha1::Sha1() :

-        uH0( 0x67452301 ),

-        uH1( 0xefcdab89 ),

-        uH2( 0x98badcfe ),

-        uH3( 0x10325476 ),

-        uH4( 0xc3d2e1f0 ),

-        iUnprocessedBytes( 0 ),

-        uTotalBytes( 0 )

+    uH0( 0x67452301 ),

+    uH1( 0xefcdab89 ),

+    uH2( 0x98badcfe ),

+    uH3( 0x10325476 ),

+    uH4( 0xc3d2e1f0 ),

+    iUnprocessedBytes( 0 ),

+    uTotalBytes( 0 )

 {

-        reset();

+    reset();

 }

 

 Bu::Sha1::~Sha1()

@@ -29,13 +29,13 @@ Bu::Sha1::~Sha1()
 

 void Bu::Sha1::reset()

 {

-        uH0 = 0x67452301;

-        uH1 = 0xefcdab89;

-        uH2 = 0x98badcfe;

-        uH3 = 0x10325476;

-        uH4 = 0xc3d2e1f0;

-        iUnprocessedBytes = 0;

-        uTotalBytes = 0;

+    uH0 = 0x67452301;

+    uH1 = 0xefcdab89;

+    uH2 = 0x98badcfe;

+    uH3 = 0x10325476;

+    uH4 = 0xc3d2e1f0;

+    iUnprocessedBytes = 0;

+    uTotalBytes = 0;

 }

 

 void Bu::Sha1::setSalt( const Bu::String & /*sSalt*/ )

@@ -44,151 +44,151 @@ void Bu::Sha1::setSalt( const Bu::String & /*sSalt*/ )
 

 void Bu::Sha1::addData( const void *sDataRaw, int iSize )

 {

-        const unsigned char *sData = (const unsigned char *)sDataRaw;

-        // add these bytes to the running total

-        uTotalBytes += iSize;

-

-        // repeat until all data is processed

-        while( iSize > 0 )

-        {

-                // number of bytes required to complete block

-                int iNeeded = 64 - iUnprocessedBytes;

-

-                // number of bytes to copy (use smaller of two)

-                int iToCopy = (iSize < iNeeded) ? iSize : iNeeded;

-

-                // Copy the bytes

-                memcpy( uBytes + iUnprocessedBytes, sData, iToCopy );

-

-                // Bytes have been copied

-                iSize -= iToCopy;

-                sData += iToCopy;

-                iUnprocessedBytes += iToCopy;

-                

-                // there is a full block

-                if( iUnprocessedBytes == 64 )

-                {

-                        process();

-                }

-        }

+    const unsigned char *sData = (const unsigned char *)sDataRaw;

+    // add these bytes to the running total

+    uTotalBytes += iSize;

+

+    // repeat until all data is processed

+    while( iSize > 0 )

+    {

+        // number of bytes required to complete block

+        int iNeeded = 64 - iUnprocessedBytes;

+

+        // number of bytes to copy (use smaller of two)

+        int iToCopy = (iSize < iNeeded) ? iSize : iNeeded;

+

+        // Copy the bytes

+        memcpy( uBytes + iUnprocessedBytes, sData, iToCopy );

+

+        // Bytes have been copied

+        iSize -= iToCopy;

+        sData += iToCopy;

+        iUnprocessedBytes += iToCopy;

+        

+        // there is a full block

+        if( iUnprocessedBytes == 64 )

+        {

+            process();

+        }

+    }

 }

 

 Bu::String Bu::Sha1::getResult()

 {

-        // save the message size

-        uint32_t totalBitsL = uTotalBytes << 3;

-        uint32_t totalBitsH = uTotalBytes >> 29;

-

-        // add 0x80 to the message

-        addData( "\x80", 1 );

-        

-        unsigned char footer[64] = {

-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

-

-        // block has no room for 8-byte filesize, so finish it

-        if( iUnprocessedBytes > 56 )

-                addData( (char*)footer, 64 - iUnprocessedBytes);

-

-        // how many zeros do we need

-        int iNeededZeros = 56 - iUnprocessedBytes;

-

-        // store file size (in bits) in big-endian format

-        toBigEndian( totalBitsH, footer + iNeededZeros );

-        toBigEndian( totalBitsL, footer + iNeededZeros + 4 );

-

-        // finish the final block

-        addData( (char*)footer, iNeededZeros + 8 );

-

-        Bu::String sRet( 20 );

-

-        unsigned char *digest = (unsigned char *)sRet.getStr();

-

-        // copy the digest bytes

-        toBigEndian( uH0, digest );

-        toBigEndian( uH1, digest + 4 );

-        toBigEndian( uH2, digest + 8 );

-        toBigEndian( uH3, digest + 12 );

-        toBigEndian( uH4, digest + 16 );

-

-        // return the digest

-        return sRet;

+    // save the message size

+    uint32_t totalBitsL = uTotalBytes << 3;

+    uint32_t totalBitsH = uTotalBytes >> 29;

+

+    // add 0x80 to the message

+    addData( "\x80", 1 );

+    

+    unsigned char footer[64] = {

+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

+

+    // block has no room for 8-byte filesize, so finish it

+    if( iUnprocessedBytes > 56 )

+        addData( (char*)footer, 64 - iUnprocessedBytes);

+

+    // how many zeros do we need

+    int iNeededZeros = 56 - iUnprocessedBytes;

+

+    // store file size (in bits) in big-endian format

+    toBigEndian( totalBitsH, footer + iNeededZeros );

+    toBigEndian( totalBitsL, footer + iNeededZeros + 4 );

+

+    // finish the final block

+    addData( (char*)footer, iNeededZeros + 8 );

+

+    Bu::String sRet( 20 );

+

+    unsigned char *digest = (unsigned char *)sRet.getStr();

+

+    // copy the digest bytes

+    toBigEndian( uH0, digest );

+    toBigEndian( uH1, digest + 4 );

+    toBigEndian( uH2, digest + 8 );

+    toBigEndian( uH3, digest + 12 );

+    toBigEndian( uH4, digest + 16 );

+

+    // return the digest

+    return sRet;

 }

 

 void Bu::Sha1::writeResult( Bu::Stream &sOut )

 {

-        sOut.write( getResult() );

+    sOut.write( getResult() );

 }

 

 void Bu::Sha1::process()

 {

-        int t;

-        uint32_t a, b, c, d, e, K, f, W[80];

-

-        // starting values

-        a = uH0;

-        b = uH1;

-        c = uH2;

-        d = uH3;

-        e = uH4;

-

-        // copy and expand the message block

-        for( t = 0; t < 16; t++ ) W[t] = (uBytes[t*4] << 24)

-                                                                        +(uBytes[t*4 + 1] << 16)

-                                                                        +(uBytes[t*4 + 2] << 8)

-                                                                        + uBytes[t*4 + 3];

-        for(; t< 80; t++ ) W[t] = lrot( W[t-3]^W[t-8]^W[t-14]^W[t-16], 1 );

-        

-        /* main loop */

-        uint32_t temp;

-        for( t = 0; t < 80; t++ )

-        {

-                if( t < 20 ) {

-                        K = 0x5a827999;

-                        f = (b & c) | ((~b) & d);

-                } else if( t < 40 ) {

-                        K = 0x6ed9eba1;

-                        f = b ^ c ^ d;

-                } else if( t < 60 ) {

-                        K = 0x8f1bbcdc;

-                        f = (b & c) | (b & d) | (c & d);

-                } else {

-                        K = 0xca62c1d6;

-                        f = b ^ c ^ d;

-                }

-                temp = lrot(a,5) + f + e + W[t] + K;

-                e = d;

-                d = c;

-                c = lrot(b,30);

-                b = a;

-                a = temp;

-                //printf( "t=%d %08x %08x %08x %08x %08x\n",t,a,b,c,d,e );

-        }

-

-        /* add variables */

-        uH0 += a;

-        uH1 += b;

-        uH2 += c;

-        uH3 += d;

-        uH4 += e;

-

-        //printf( "Current: %08x %08x %08x %08x %08x\n",H0,H1,H2,H3,H4 );

-        /* all bytes have been processed */

-        iUnprocessedBytes = 0;

+    int t;

+    uint32_t a, b, c, d, e, K, f, W[80];

+

+    // starting values

+    a = uH0;

+    b = uH1;

+    c = uH2;

+    d = uH3;

+    e = uH4;

+

+    // copy and expand the message block

+    for( t = 0; t < 16; t++ ) W[t] = (uBytes[t*4] << 24)

+                                    +(uBytes[t*4 + 1] << 16)

+                                    +(uBytes[t*4 + 2] << 8)

+                                    + uBytes[t*4 + 3];

+    for(; t< 80; t++ ) W[t] = lrot( W[t-3]^W[t-8]^W[t-14]^W[t-16], 1 );

+    

+    /* main loop */

+    uint32_t temp;

+    for( t = 0; t < 80; t++ )

+    {

+        if( t < 20 ) {

+            K = 0x5a827999;

+            f = (b & c) | ((~b) & d);

+        } else if( t < 40 ) {

+            K = 0x6ed9eba1;

+            f = b ^ c ^ d;

+        } else if( t < 60 ) {

+            K = 0x8f1bbcdc;

+            f = (b & c) | (b & d) | (c & d);

+        } else {

+            K = 0xca62c1d6;

+            f = b ^ c ^ d;

+        }

+        temp = lrot(a,5) + f + e + W[t] + K;

+        e = d;

+        d = c;

+        c = lrot(b,30);

+        b = a;

+        a = temp;

+        //printf( "t=%d %08x %08x %08x %08x %08x\n",t,a,b,c,d,e );

+    }

+

+    /* add variables */

+    uH0 += a;

+    uH1 += b;

+    uH2 += c;

+    uH3 += d;

+    uH4 += e;

+

+    //printf( "Current: %08x %08x %08x %08x %08x\n",H0,H1,H2,H3,H4 );

+    /* all bytes have been processed */

+    iUnprocessedBytes = 0;

 }

 

 uint32_t Bu::Sha1::lrot( uint32_t x, int bits )

 {

-        return (x<<bits) | (x>>(32 - bits));

+    return (x<<bits) | (x>>(32 - bits));

 }

 

 void Bu::Sha1::toBigEndian( uint32_t num, unsigned char* byte )

 {

-        byte[0] = (unsigned char)(num>>24);

-        byte[1] = (unsigned char)(num>>16);

-        byte[2] = (unsigned char)(num>>8);

-        byte[3] = (unsigned char)num;

+    byte[0] = (unsigned char)(num>>24);

+    byte[1] = (unsigned char)(num>>16);

+    byte[2] = (unsigned char)(num>>8);

+    byte[3] = (unsigned char)num;

 }

 

diff --git a/src/stable/sha1.h b/src/stable/sha1.h
index e861f94..f882473 100644
--- a/src/stable/sha1.h
+++ b/src/stable/sha1.h
@@ -13,41 +13,41 @@
 

 namespace Bu

 {

-        /**

-         * Calculates SHA-1 sums.  This is based strongly on code from Michael D.

-         * Leonhard who released his code under the terms of the MIT license,

-         * thank you!  Check out his website http://tamale.net he has a lot of

-         * cool stuff there.

-         */

-        class Sha1 : public CryptoHash

-        {

-        public:

-                Sha1();

-                virtual ~Sha1();

-

-                virtual void reset();

-                virtual void setSalt( const Bu::String &sSalt );

-                virtual void addData( const void *sData, int iSize );

-                using CryptoHash::addData;

-                virtual String getResult();

-                virtual void writeResult( Stream &sOut );

-

-                void update( const char* data, int num );

-                unsigned char* getDigest();

-

-                // utility methods

-

-        private:

-                static uint32_t lrot( uint32_t x, int bits );

-                static void toBigEndian( uint32_t in, unsigned char* out );

-                void process();

-        

-        private:

-                uint32_t uH0, uH1, uH2, uH3, uH4;

-                unsigned char uBytes[64];

-                int iUnprocessedBytes;

-                uint32_t uTotalBytes;

-        };

+    /**

+     * Calculates SHA-1 sums.  This is based strongly on code from Michael D.

+     * Leonhard who released his code under the terms of the MIT license,

+     * thank you!  Check out his website http://tamale.net he has a lot of

+     * cool stuff there.

+     */

+    class Sha1 : public CryptoHash

+    {

+    public:

+        Sha1();

+        virtual ~Sha1();

+

+        virtual void reset();

+        virtual void setSalt( const Bu::String &sSalt );

+        virtual void addData( const void *sData, int iSize );

+        using CryptoHash::addData;

+        virtual String getResult();

+        virtual void writeResult( Stream &sOut );

+

+        void update( const char* data, int num );

+        unsigned char* getDigest();

+

+        // utility methods

+

+    private:

+        static uint32_t lrot( uint32_t x, int bits );

+        static void toBigEndian( uint32_t in, unsigned char* out );

+        void process();

+    

+    private:

+        uint32_t uH0, uH1, uH2, uH3, uH4;

+        unsigned char uBytes[64];

+        int iUnprocessedBytes;

+        uint32_t uTotalBytes;

+    };

 };

 

 #endif

diff --git a/src/stable/sharedcore.h b/src/stable/sharedcore.h
index f000077..f8b9d4e 100644
--- a/src/stable/sharedcore.h
+++ b/src/stable/sharedcore.h
@@ -15,176 +15,176 @@
 
 namespace Bu
 {
-        /**
-         * A mechanism for creating classes that perform lazy copies.  The concept
-         * behind this is that instead of copying a large object when it is assigned
-         * or passed into a copy constructor we simply copy a pointer internally.
-         * The assumption is that many times when an object is passed by value we
-         * don't really want to keep the object around, we want the recipient to
-         * take ownership without allocating a new object.  This allows that to
-         * happen.
-         *
-         * When used properly this makes object copying essentially free (O(1),
-         * that is) and performs the actual copy when a user tries to modify the
-         * object.
-         *
-         * For example, lets look at something like the getKeys function in
-         * Bu::Hash.  When this function is called it creates a Bu::List of
-         * appropriate type, fills it with keys, and returns it.  This is a good
-         * way for this function to behave, there may be additional issues if the
-         * List object were allocated with new and not on the stack.  However,
-         * returning the List at the end of the function could potentially take
-         * a very long time depending on the size of the list and the type of the
-         * key.  In this case the getKeys function doesn't want ownership of the
-         * List object, and when it returns it, it's local copy will be destroyed.
-         *
-         * However, List inherits from SharedCore, which means that when it is
-         * returned all we do is copy a pointer to the "core" of the list, which
-         * is a very fast operatorion.  For a brief moment, before anyone can do
-         * anything else, there are two objects referencing the core of that single
-         * list.  However, the getKeys() function will destroy it's local copy
-         * before the calling function can use it's new copy.  That means that by
-         * the time the calling function can use it's new List of keys it is the
-         * only one with a reference to the core, and no copy will need to happen.
-         *
-         * Using SharedCore on your own classes is fairly straight forward.  There
-         * are only a couple of steps.  First, break the class into two classes.
-         * Move every variable from the original class (generally everything that's
-         * private) into the new class.  Then make the original class inherit from
-         * SharedCore.  The SharedCore template takes 2 parameters, first is the
-         * class it's inheriting from, second is the new core class.  Now, in your
-         * original class you will have one class variable, a pointer named core.
-         * All of your original variables will be accessable through core.  The next
-         * step is to access everything you used to through core, and to find 
-         * every function that may change data in the core.  At the top of every
-         * function that may change data you want to call _hardCopy().
-         *
-         * That's more or less it.  A more detailed guide will be written soon.
-         * @todo Write a guide for this.
-         */
-        template<typename Shell, typename Core>
-        class SharedCore
-        {
-                typedef class SharedCore<Shell, Core> _SharedType;
-        public:
-                SharedCore() :
-                        core( NULL ),
-                        iRefCount( NULL )
-                {
-                        core = _allocateCore();
-                        iRefCount = new int(1);
-                }
-
-                SharedCore( const _SharedType &rSrc ) :
-                        core( NULL ),
-                        iRefCount( NULL )
-                {
-                        _softCopy( rSrc );
-                }
-
-                virtual ~SharedCore()
-                {
-                        _deref();
-                }
-
-                SharedCore &operator=( const SharedCore &rhs )
-                {
-                        if( core == rhs.core )
-                                return *this;
-
-                        _softCopy( rhs );
-                        return *this;
-                }
-
-                int getRefCount() const
-                {
-                        return *iRefCount;
-                }
-
-                Shell clone() const
-                {
-                        Shell s( dynamic_cast<const Shell &>(*this) );
-                        s._hardCopy();
-                        return s;
-                }
-
-                bool isCoreShared( const Shell &rOther ) const
-                {
-                        return rOther.core == core;
-                }
-
-        protected:
-                Core *core;
-                void _hardCopy()
-                {
-                        if( !core || !iRefCount )
-                                return;
-                        if( (*iRefCount) == 1 )
-                                return;
-                        Core *copy = _copyCore( core );
-                        _deref();
-                        core = copy;
-                        iRefCount = new int( 1 );
-                }
-
-                /**
-                 * Reset core acts like a hard copy, except instead of providing a
-                 * standalone copy of the shared core, it provides a brand new core.
-                 *
-                 * Very useful in functions used to reset the state of an object.
-                 */
-                void _resetCore()
-                {
-                        if( core )
-                                _deref();
-                        core = _allocateCore();
-                        iRefCount = new int( 1 );
-                }
-
-                virtual Core *_allocateCore()
-                {
-                        return new Core();
-                }
-
-                virtual Core *_copyCore( Core *pSrc )
-                {
-                        return new Core( *pSrc );
-                }
-
-                virtual void _deallocateCore( Core *pSrc )
-                {
-                        delete pSrc;
-                }
-
-        private:
-                void _deref()
-                {
-                        if( (--(*iRefCount)) == 0 )
-                        {
-                                _deallocateCore( core );
-                                delete iRefCount;
-                        }
-                        core = NULL;
-                        iRefCount = NULL;
-                }
-
-                void _incRefCount()
-                {
-                        if( iRefCount && core )
-                                ++(*iRefCount);
-                }
-
-                void _softCopy( const _SharedType &rSrc )
-                {
-                        if( core )
-                                _deref();
-                        core = rSrc.core;
-                        iRefCount = rSrc.iRefCount;
-                        _incRefCount();
-                }
-
-                int *iRefCount;
-        };
+    /**
+     * A mechanism for creating classes that perform lazy copies.  The concept
+     * behind this is that instead of copying a large object when it is assigned
+     * or passed into a copy constructor we simply copy a pointer internally.
+     * The assumption is that many times when an object is passed by value we
+     * don't really want to keep the object around, we want the recipient to
+     * take ownership without allocating a new object.  This allows that to
+     * happen.
+     *
+     * When used properly this makes object copying essentially free (O(1),
+     * that is) and performs the actual copy when a user tries to modify the
+     * object.
+     *
+     * For example, lets look at something like the getKeys function in
+     * Bu::Hash.  When this function is called it creates a Bu::List of
+     * appropriate type, fills it with keys, and returns it.  This is a good
+     * way for this function to behave, there may be additional issues if the
+     * List object were allocated with new and not on the stack.  However,
+     * returning the List at the end of the function could potentially take
+     * a very long time depending on the size of the list and the type of the
+     * key.  In this case the getKeys function doesn't want ownership of the
+     * List object, and when it returns it, it's local copy will be destroyed.
+     *
+     * However, List inherits from SharedCore, which means that when it is
+     * returned all we do is copy a pointer to the "core" of the list, which
+     * is a very fast operatorion.  For a brief moment, before anyone can do
+     * anything else, there are two objects referencing the core of that single
+     * list.  However, the getKeys() function will destroy it's local copy
+     * before the calling function can use it's new copy.  That means that by
+     * the time the calling function can use it's new List of keys it is the
+     * only one with a reference to the core, and no copy will need to happen.
+     *
+     * Using SharedCore on your own classes is fairly straight forward.  There
+     * are only a couple of steps.  First, break the class into two classes.
+     * Move every variable from the original class (generally everything that's
+     * private) into the new class.  Then make the original class inherit from
+     * SharedCore.  The SharedCore template takes 2 parameters, first is the
+     * class it's inheriting from, second is the new core class.  Now, in your
+     * original class you will have one class variable, a pointer named core.
+     * All of your original variables will be accessable through core.  The next
+     * step is to access everything you used to through core, and to find 
+     * every function that may change data in the core.  At the top of every
+     * function that may change data you want to call _hardCopy().
+     *
+     * That's more or less it.  A more detailed guide will be written soon.
+     * @todo Write a guide for this.
+     */
+    template<typename Shell, typename Core>
+    class SharedCore
+    {
+        typedef class SharedCore<Shell, Core> _SharedType;
+    public:
+        SharedCore() :
+            core( NULL ),
+            iRefCount( NULL )
+        {
+            core = _allocateCore();
+            iRefCount = new int(1);
+        }
+
+        SharedCore( const _SharedType &rSrc ) :
+            core( NULL ),
+            iRefCount( NULL )
+        {
+            _softCopy( rSrc );
+        }
+
+        virtual ~SharedCore()
+        {
+            _deref();
+        }
+
+        SharedCore &operator=( const SharedCore &rhs )
+        {
+            if( core == rhs.core )
+                return *this;
+
+            _softCopy( rhs );
+            return *this;
+        }
+
+        int getRefCount() const
+        {
+            return *iRefCount;
+        }
+
+        Shell clone() const
+        {
+            Shell s( dynamic_cast<const Shell &>(*this) );
+            s._hardCopy();
+            return s;
+        }
+
+        bool isCoreShared( const Shell &rOther ) const
+        {
+            return rOther.core == core;
+        }
+
+    protected:
+        Core *core;
+        void _hardCopy()
+        {
+            if( !core || !iRefCount )
+                return;
+            if( (*iRefCount) == 1 )
+                return;
+            Core *copy = _copyCore( core );
+            _deref();
+            core = copy;
+            iRefCount = new int( 1 );
+        }
+
+        /**
+         * Reset core acts like a hard copy, except instead of providing a
+         * standalone copy of the shared core, it provides a brand new core.
+         *
+         * Very useful in functions used to reset the state of an object.
+         */
+        void _resetCore()
+        {
+            if( core )
+                _deref();
+            core = _allocateCore();
+            iRefCount = new int( 1 );
+        }
+
+        virtual Core *_allocateCore()
+        {
+            return new Core();
+        }
+
+        virtual Core *_copyCore( Core *pSrc )
+        {
+            return new Core( *pSrc );
+        }
+
+        virtual void _deallocateCore( Core *pSrc )
+        {
+            delete pSrc;
+        }
+
+    private:
+        void _deref()
+        {
+            if( (--(*iRefCount)) == 0 )
+            {
+                _deallocateCore( core );
+                delete iRefCount;
+            }
+            core = NULL;
+            iRefCount = NULL;
+        }
+
+        void _incRefCount()
+        {
+            if( iRefCount && core )
+                ++(*iRefCount);
+        }
+
+        void _softCopy( const _SharedType &rSrc )
+        {
+            if( core )
+                _deref();
+            core = rSrc.core;
+            iRefCount = rSrc.iRefCount;
+            _incRefCount();
+        }
+
+        int *iRefCount;
+    };
 };
 
 #undef fin
diff --git a/src/stable/singleton.h b/src/stable/singleton.h
index 6fe2777..27d907d 100644
--- a/src/stable/singleton.h
+++ b/src/stable/singleton.h
@@ -12,57 +12,57 @@
 
 namespace Bu
 {
-        /**
-         * Provides singleton functionality in a modular sort of way.  Make this the
-         * base class of any other class and you immediately gain singleton
-         * functionality.  Be sure to make your constructor and various functions use
-         * intellegent scoping.  Cleanup and instantiation are performed automatically
-         * for you at first use and program exit.  There are two things that you must
-         * do when using this template, first is to inherit from it with the name of
-         * your class filling in for T and then make this class a friend of your class.
-         *@code
-         * // Making the Single Singleton:
-         * class Single : public Singleton<Single>
-         * {
-         *              friend class Singleton<Single>;
-         *      protected:
-         *              Single();
-         *              ...
-         * };
-         @endcode
-         * You can still add public functions and variables to your new Singleton child
-         * class, but your constructor should be protected (hence the need for the
-         * friend decleration).
-         */
-        template <class T>
-        class Singleton
-        {
-        protected:
-                /**
-                 * Private constructor.  This constructor is empty but has a body so that
-                 * you can make your own override of it.  Be sure that you're override is
-                 * also protected.
-                 */
-                Singleton() {};
+    /**
+     * Provides singleton functionality in a modular sort of way.  Make this the
+     * base class of any other class and you immediately gain singleton
+     * functionality.  Be sure to make your constructor and various functions use
+     * intellegent scoping.  Cleanup and instantiation are performed automatically
+     * for you at first use and program exit.  There are two things that you must
+     * do when using this template, first is to inherit from it with the name of
+     * your class filling in for T and then make this class a friend of your class.
+     *@code
+     * // Making the Single Singleton:
+     * class Single : public Singleton<Single>
+     * {
+     *      friend class Singleton<Single>;
+     *  protected:
+     *      Single();
+     *      ...
+     * };
+     @endcode
+     * You can still add public functions and variables to your new Singleton child
+     * class, but your constructor should be protected (hence the need for the
+     * friend decleration).
+     */
+    template <class T>
+    class Singleton
+    {
+    protected:
+        /**
+         * Private constructor.  This constructor is empty but has a body so that
+         * you can make your own override of it.  Be sure that you're override is
+         * also protected.
+         */
+        Singleton() {};
 
-        private:
-                /**
-                 * Copy constructor, defined so that you could write your own as well.
-                 */
-                Singleton( const Singleton& );
+    private:
+        /**
+         * Copy constructor, defined so that you could write your own as well.
+         */
+        Singleton( const Singleton& );
 
-        public:
-                /**
-                 * Get a handle to the contained instance of the contained class.  It is
-                 * a reference.
-                 *@returns A reference to the contained object.
-                 */
-                static T &getInstance()
-                {
-                        static T i;
-                        return i;
-                }
-        };
+    public:
+        /**
+         * Get a handle to the contained instance of the contained class.  It is
+         * a reference.
+         *@returns A reference to the contained object.
+         */
+        static T &getInstance()
+        {
+            static T i;
+            return i;
+        }
+    };
 }
 
 #endif
diff --git a/src/stable/sio.cpp b/src/stable/sio.cpp
index 6a650ed..1ea30c2 100644
--- a/src/stable/sio.cpp
+++ b/src/stable/sio.cpp
@@ -16,51 +16,51 @@ Bu::Formatter Bu::serr( Bu::serrRaw );
 
 namespace Bu
 {
-        class PrintEndAction : public Bu::String::FormatProxyEndAction
-        {
-        public:
-                PrintEndAction( Bu::Stream &s, bool bEndLn ) :
-                        s( s ),
-                        bEndLn( bEndLn )
-                {
-                }
+    class PrintEndAction : public Bu::String::FormatProxyEndAction
+    {
+    public:
+        PrintEndAction( Bu::Stream &s, bool bEndLn ) :
+            s( s ),
+            bEndLn( bEndLn )
+        {
+        }
 
-                virtual ~PrintEndAction()
-                {
-                }
+        virtual ~PrintEndAction()
+        {
+        }
 
-                virtual void operator()( const Bu::String &sFinal )
-                {
-                        s.write( sFinal.getStr(), sFinal.getSize() );
-                        if( bEndLn )
-                        {
-                                s.write("\n", 1);
-                                s.flush();
-                        }
-                }
+        virtual void operator()( const Bu::String &sFinal )
+        {
+            s.write( sFinal.getStr(), sFinal.getSize() );
+            if( bEndLn )
+            {
+                s.write("\n", 1);
+                s.flush();
+            }
+        }
 
-                Bu::Stream &s;
-                bool bEndLn;
-        };
+        Bu::Stream &s;
+        bool bEndLn;
+    };
 }
 
 Bu::String::FormatProxy Bu::print( Bu::Stream &s, const Bu::String &str )
 {
-        return str.format( new Bu::PrintEndAction( s, false ) );
+    return str.format( new Bu::PrintEndAction( s, false ) );
 }
 
 Bu::String::FormatProxy Bu::print( const Bu::String &str )
 {
-        return print( sioRaw, str );
+    return print( sioRaw, str );
 }
 
 Bu::String::FormatProxy Bu::println( Bu::Stream &s, const Bu::String &str )
 {
-        return str.format( new Bu::PrintEndAction( s, true ) );
+    return str.format( new Bu::PrintEndAction( s, true ) );
 }
 
 Bu::String::FormatProxy Bu::println( const Bu::String &str )
 {
-        return println( sioRaw, str );
+    return println( sioRaw, str );
 }
 
diff --git a/src/stable/sio.h b/src/stable/sio.h
index 2d4a104..ddaea1b 100644
--- a/src/stable/sio.h
+++ b/src/stable/sio.h
@@ -12,18 +12,18 @@
 
 namespace Bu
 {
-        class StreamStack;
+    class StreamStack;
 
-        extern Bu::StreamStack sioRaw;
-        extern Bu::Formatter sio;
-        extern Bu::StreamStack serrRaw;
-        extern Bu::Formatter serr;
+    extern Bu::StreamStack sioRaw;
+    extern Bu::Formatter sio;
+    extern Bu::StreamStack serrRaw;
+    extern Bu::Formatter serr;
 
-        Bu::String::FormatProxy print( Bu::Stream &s, const Bu::String &str );
-        Bu::String::FormatProxy print( const Bu::String &str );
+    Bu::String::FormatProxy print( Bu::Stream &s, const Bu::String &str );
+    Bu::String::FormatProxy print( const Bu::String &str );
 
-        Bu::String::FormatProxy println( Bu::Stream &s, const Bu::String &str );
-        Bu::String::FormatProxy println( const Bu::String &str );
+    Bu::String::FormatProxy println( Bu::Stream &s, const Bu::String &str );
+    Bu::String::FormatProxy println( const Bu::String &str );
 };
 
 #endif
diff --git a/src/stable/sptr.h b/src/stable/sptr.h
index 58ea223..6a9c340 100644
--- a/src/stable/sptr.h
+++ b/src/stable/sptr.h
@@ -13,217 +13,217 @@
 
 namespace Bu
 {
-        template<typename T> class SPtr;
-        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
-
-        /**
-         *@ingroup Containers
-         */
-        template<typename T>
-        class SPtr
-        {
-                template<typename Tb, typename Ta>
-                friend SPtr<Tb> SPtrCast( SPtr<Ta> pt );
-        public:
-                SPtr() :
-                        pRefCnt( NULL ),
-                        pData( NULL )
-                {
-                }
-
-                ~SPtr()
-                {
-                        decCount();
-                }
-
-                SPtr( const SPtr<T> &src ) :
-                        pRefCnt( src.pRefCnt ),
-                        pData( src.pData )
-                {
-                        if( pRefCnt )
-                                (*pRefCnt) += 1;
-                }
-
-                SPtr( T *pSrc ) :
-                        pRefCnt( NULL ),
-                        pData( pSrc )
-                {
-                        if( pData )
-                        {
-                                pRefCnt = new int32_t;
-                                (*pRefCnt) = 1;
-                        }
-                }
-
-                /**
-                 * Get the number of references to this pointer.
-                 *@returns (int32_t) The number of references to this pointer.
-                 */
-                int32_t getRefCount() const
-                {
-                        return *pRefCnt;
-                }
-
-                void clear()
-                {
-                        decCount();
-                        pRefCnt = NULL;
-                        pData = NULL;
-                }
-
-                /**
-                 * Pointer access operator.
-                 *@returns (const T *)
-                 */
-                const T *operator->() const
-                {
-                        return pData;
-                }
-
-                /**
-                 * Dereference operator.
-                 *@returns (const T &) The value at the end of the pointer.
-                 */
-                const T &operator*() const
-                {
-                        return *pData;
-                }
-                
-                /**
-                 * Pointer access operator.
-                 *@returns (T *)
-                 */
-                T *operator->()
-                {
-                        return pData;
-                }
-
-                /**
-                 * Dereference operator.
-                 *@returns (T &) The value at the end of the pointer.
-                 */
-                T &operator*()
-                {
-                        return *pData;
-                }
-
-                /**
-                 * Assignment operator.
-                 *@param src (const SPtr<T> &)
-                 */
-                SPtr<T> operator=( const SPtr<T> &src )
-                {
-                        decCount();
-                        pRefCnt = src.pRefCnt;
-                        pData = src.pData;
-                        if( pRefCnt )
-                                (*pRefCnt) += 1;
-
-                        return *this;
-                }
-
-                /**
-                 * Assignment operator.
-                 *@param src (const SPtr<T> &)
-                 */
-                const SPtr<T> operator=( const SPtr<T> &src ) const
-                {
-                        decCount();
-                        pRefCnt = src.pRefCnt;
-                        pData = src.pData;
-                        if( pRefCnt )
-                                (*pRefCnt) += 1;
-
-                        return *this;
-                }
-
-                /**
-                 * Equals comparison operator.
-                 *@param src (const SPtr<T> &) The SPtr to compare to.
-                 *@returns (bool) Are the equal?
-                 */
-                bool operator==( const SPtr<T> &src ) const
-                {
-                        return pData == src.pData;
-                }
-
-                /**
-                 * Equals comparison operator.
-                 *@param src (const T *) The pointer to compare to.
-                 *@returns (bool) Are the equal?
-                 */
-                bool operator==( const T *src ) const
-                {
-                        return pData == src;
-                }
-                
-                /**
-                 * Not equals comparison operator.
-                 *@param src (const SPtr<T> &) The SPtr to compare to.
-                 *@returns (bool) Are the equal?
-                 */
-                bool operator!=( const SPtr<T> &src ) const
-                {
-                        return !(pData == src.pData);
-                }
-
-                /**
-                 * Not equals comparison operator.
-                 *@param src (const T *) The pointer to compare to.
-                 *@returns (bool) Are the equal?
-                 */
-                bool operator!=( const T *src ) const
-                {
-                        return !(pData == src);
-                }
-
-                /**
-                 * Boolean cast operator. Do we have a pointer?
-                 */
-                operator bool() const
-                {
-                        return pRefCnt != NULL;
-                }
-
-                /**
-                 * Do we have a pointer?
-                 *@returns (bool) Do we have a pointer?
-                 */
-                bool isSet() const
-                {
-                        return pRefCnt != NULL;
-                }
-
-        private:
-                void decCount() const
-                {
-                        if( pRefCnt )
-                        {
-                                (*pRefCnt) -= 1;
-                                //printf("Decrementing ref-count to %d\n", *pRefCnt );
-                                if( (*pRefCnt) == 0 )
-                                {
-                                        delete pRefCnt;
-                                        delete pData;
-                                        pRefCnt = NULL;
-                                        pData = NULL;
-                                }
-                        }
-                }
-
-                mutable int32_t *pRefCnt;
-                mutable T *pData;
-        };
-
-        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src )
-        {
-                SPtr<Tb> ret;
-                ret.pRefCnt = src.pRefCnt;
-                ret.pData = dynamic_cast<Tb *>(src.pData);
-                if( ret.pRefCnt )
-                        (*(ret.pRefCnt)) += 1;
-                return ret;
-        }
+    template<typename T> class SPtr;
+    template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
+
+    /**
+     *@ingroup Containers
+     */
+    template<typename T>
+    class SPtr
+    {
+        template<typename Tb, typename Ta>
+        friend SPtr<Tb> SPtrCast( SPtr<Ta> pt );
+    public:
+        SPtr() :
+            pRefCnt( NULL ),
+            pData( NULL )
+        {
+        }
+
+        ~SPtr()
+        {
+            decCount();
+        }
+
+        SPtr( const SPtr<T> &src ) :
+            pRefCnt( src.pRefCnt ),
+            pData( src.pData )
+        {
+            if( pRefCnt )
+                (*pRefCnt) += 1;
+        }
+
+        SPtr( T *pSrc ) :
+            pRefCnt( NULL ),
+            pData( pSrc )
+        {
+            if( pData )
+            {
+                pRefCnt = new int32_t;
+                (*pRefCnt) = 1;
+            }
+        }
+
+        /**
+         * Get the number of references to this pointer.
+         *@returns (int32_t) The number of references to this pointer.
+         */
+        int32_t getRefCount() const
+        {
+            return *pRefCnt;
+        }
+
+        void clear()
+        {
+            decCount();
+            pRefCnt = NULL;
+            pData = NULL;
+        }
+
+        /**
+         * Pointer access operator.
+         *@returns (const T *)
+         */
+        const T *operator->() const
+        {
+            return pData;
+        }
+
+        /**
+         * Dereference operator.
+         *@returns (const T &) The value at the end of the pointer.
+         */
+        const T &operator*() const
+        {
+            return *pData;
+        }
+        
+        /**
+         * Pointer access operator.
+         *@returns (T *)
+         */
+        T *operator->()
+        {
+            return pData;
+        }
+
+        /**
+         * Dereference operator.
+         *@returns (T &) The value at the end of the pointer.
+         */
+        T &operator*()
+        {
+            return *pData;
+        }
+
+        /**
+         * Assignment operator.
+         *@param src (const SPtr<T> &)
+         */
+        SPtr<T> operator=( const SPtr<T> &src )
+        {
+            decCount();
+            pRefCnt = src.pRefCnt;
+            pData = src.pData;
+            if( pRefCnt )
+                (*pRefCnt) += 1;
+
+            return *this;
+        }
+
+        /**
+         * Assignment operator.
+         *@param src (const SPtr<T> &)
+         */
+        const SPtr<T> operator=( const SPtr<T> &src ) const
+        {
+            decCount();
+            pRefCnt = src.pRefCnt;
+            pData = src.pData;
+            if( pRefCnt )
+                (*pRefCnt) += 1;
+
+            return *this;
+        }
+
+        /**
+         * Equals comparison operator.
+         *@param src (const SPtr<T> &) The SPtr to compare to.
+         *@returns (bool) Are the equal?
+         */
+        bool operator==( const SPtr<T> &src ) const
+        {
+            return pData == src.pData;
+        }
+
+        /**
+         * Equals comparison operator.
+         *@param src (const T *) The pointer to compare to.
+         *@returns (bool) Are the equal?
+         */
+        bool operator==( const T *src ) const
+        {
+            return pData == src;
+        }
+        
+        /**
+         * Not equals comparison operator.
+         *@param src (const SPtr<T> &) The SPtr to compare to.
+         *@returns (bool) Are the equal?
+         */
+        bool operator!=( const SPtr<T> &src ) const
+        {
+            return !(pData == src.pData);
+        }
+
+        /**
+         * Not equals comparison operator.
+         *@param src (const T *) The pointer to compare to.
+         *@returns (bool) Are the equal?
+         */
+        bool operator!=( const T *src ) const
+        {
+            return !(pData == src);
+        }
+
+        /**
+         * Boolean cast operator. Do we have a pointer?
+         */
+        operator bool() const
+        {
+            return pRefCnt != NULL;
+        }
+
+        /**
+         * Do we have a pointer?
+         *@returns (bool) Do we have a pointer?
+         */
+        bool isSet() const
+        {
+            return pRefCnt != NULL;
+        }
+
+    private:
+        void decCount() const
+        {
+            if( pRefCnt )
+            {
+                (*pRefCnt) -= 1;
+                //printf("Decrementing ref-count to %d\n", *pRefCnt );
+                if( (*pRefCnt) == 0 )
+                {
+                    delete pRefCnt;
+                    delete pData;
+                    pRefCnt = NULL;
+                    pData = NULL;
+                }
+            }
+        }
+
+        mutable int32_t *pRefCnt;
+        mutable T *pData;
+    };
+
+    template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src )
+    {
+        SPtr<Tb> ret;
+        ret.pRefCnt = src.pRefCnt;
+        ret.pData = dynamic_cast<Tb *>(src.pData);
+        if( ret.pRefCnt )
+            (*(ret.pRefCnt)) += 1;
+        return ret;
+    }
 }
 
 #endif
diff --git a/src/stable/stack.h b/src/stable/stack.h
index f60907d..6b5f65a 100644
--- a/src/stable/stack.h
+++ b/src/stable/stack.h
@@ -13,73 +13,73 @@
 
 namespace Bu
 {
-        template<typename value, typename valuealloc=std::allocator<value> >
-        class Stack
-        {
-        private:
-                typedef struct Chunk
-                {
-                        value *pValue;
-                        Chunk *pPrev;
-                } Chunk;
-        public:
-                Stack() :
-                        pTop( NULL )
-                {
-                }
+    template<typename value, typename valuealloc=std::allocator<value> >
+    class Stack
+    {
+    private:
+        typedef struct Chunk
+        {
+            value *pValue;
+            Chunk *pPrev;
+        } Chunk;
+    public:
+        Stack() :
+            pTop( NULL )
+        {
+        }
 
-                virtual ~Stack()
-                {
-                }
+        virtual ~Stack()
+        {
+        }
 
-                void push( const value &v )
-                {
-                        Chunk *pChnk = new Chunk;
-                        pChnk->pValue = va.allocate( 1 );
-                        va.construct( pChnk->pValue, v );
-                        pChnk->pPrev = pTop;
-                        pTop = pChnk;
-                }
+        void push( const value &v )
+        {
+            Chunk *pChnk = new Chunk;
+            pChnk->pValue = va.allocate( 1 );
+            va.construct( pChnk->pValue, v );
+            pChnk->pPrev = pTop;
+            pTop = pChnk;
+        }
 
-                value &peek()
-                {
-                        return *pTop->pValue;
-                }
-                
-                value &top()
-                {
-                        return *pTop->pValue;
-                }
+        value &peek()
+        {
+            return *pTop->pValue;
+        }
+        
+        value &top()
+        {
+            return *pTop->pValue;
+        }
 
-                value pop()
-                {
-                        value ret( *pTop->pValue );
-                        
-                        Chunk *pChnk = pTop;
-                        pTop = pTop->pPrev;
+        value pop()
+        {
+            value ret( *pTop->pValue );
+            
+            Chunk *pChnk = pTop;
+            pTop = pTop->pPrev;
 
-                        va.destroy( pChnk->pValue );
-                        va.deallocate( pChnk->pValue, 1 );
-                        delete pChnk;
+            va.destroy( pChnk->pValue );
+            va.deallocate( pChnk->pValue, 1 );
+            delete pChnk;
 
-                        return ret;
-                }
+            return ret;
+        }
 
-                void clear()
-                {
-                        while( !isEmpty() )
-                                pop();
-                }
+        void clear()
+        {
+            while( !isEmpty() )
+                pop();
+        }
 
-                bool isEmpty()
-                {
-                        return pTop == NULL;
-                }
+        bool isEmpty()
+        {
+            return pTop == NULL;
+        }
 
-        private:
-                Chunk *pTop;
-                valuealloc va;
-        };
+    private:
+        Chunk *pTop;
+        valuealloc va;
+    };
 }
 
 #endif
diff --git a/src/stable/staticmembuf.cpp b/src/stable/staticmembuf.cpp
index d470916..43f098b 100644
--- a/src/stable/staticmembuf.cpp
+++ b/src/stable/staticmembuf.cpp
@@ -10,9 +10,9 @@
 using namespace Bu;
 
 Bu::StaticMemBuf::StaticMemBuf( const void *pData, size iSize ) :
-        pData( pData ),
-        iSize( iSize ),
-        nPos( 0 )
+    pData( pData ),
+    iSize( iSize ),
+    nPos( 0 )
 {
 }
 
@@ -26,54 +26,54 @@ void Bu::StaticMemBuf::close()
 
 size Bu::StaticMemBuf::read( void *pBuf, size nBytes )
 {
-        if( iSize-nPos < nBytes )
-                nBytes = iSize-nPos;
+    if( iSize-nPos < nBytes )
+        nBytes = iSize-nPos;
 
-        memcpy( pBuf, ((char *)pData)+nPos, nBytes );
-        nPos += nBytes;
+    memcpy( pBuf, ((char *)pData)+nPos, nBytes );
+    nPos += nBytes;
 
-        return nBytes;
+    return nBytes;
 }
-        
+    
 size Bu::StaticMemBuf::write( const void *, size )
 {
-        return -1;
+    return -1;
 }
 
 size Bu::StaticMemBuf::tell()
 {
-        return nPos;
+    return nPos;
 }
 
 void Bu::StaticMemBuf::seek( size offset )
 {
-        nPos += offset;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > iSize ) nPos = iSize;
+    nPos += offset;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > iSize ) nPos = iSize;
 }
 
 void Bu::StaticMemBuf::setPos( size pos )
 {
-        nPos = pos;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > iSize ) nPos = iSize;
+    nPos = pos;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > iSize ) nPos = iSize;
 }
 
 void Bu::StaticMemBuf::setPosEnd( size pos )
 {
-        nPos = iSize-pos;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > iSize ) nPos = iSize;
+    nPos = iSize-pos;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > iSize ) nPos = iSize;
 }
 
 bool Bu::StaticMemBuf::isEos()
 {
-        return (nPos == iSize);
+    return (nPos == iSize);
 }
 
 bool Bu::StaticMemBuf::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::StaticMemBuf::flush()
@@ -82,32 +82,32 @@ void Bu::StaticMemBuf::flush()
 
 bool Bu::StaticMemBuf::canRead()
 {
-        return !isEos();
+    return !isEos();
 }
 
 bool Bu::StaticMemBuf::canWrite()
 {
-        return false;
+    return false;
 }
 
 bool Bu::StaticMemBuf::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StaticMemBuf::isWritable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::StaticMemBuf::isSeekable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StaticMemBuf::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::StaticMemBuf::setBlocking( bool )
@@ -120,16 +120,16 @@ void Bu::StaticMemBuf::setSize( size )
 
 Bu::size Bu::StaticMemBuf::getSize() const
 {
-        return iSize;
+    return iSize;
 }
 
 Bu::size Bu::StaticMemBuf::getBlockSize() const
 {
-        return iSize;
+    return iSize;
 }
 
 Bu::String Bu::StaticMemBuf::getLocation() const
 {
-        return "";
+    return "";
 }
 
diff --git a/src/stable/staticmembuf.h b/src/stable/staticmembuf.h
index 332e27d..2be05a0 100644
--- a/src/stable/staticmembuf.h
+++ b/src/stable/staticmembuf.h
@@ -15,51 +15,51 @@
 
 namespace Bu
 {
-        /**
-         * An immutable, read-only memory buffer.  Construct this buffer around a
-         * block of raw memory, provide the length of the block, and you can read
-         * from that block via this class as though it were a normal stream.
-         *
-         * Use this class instead of MemBuf when you have a string already, and
-         * don't need to change it.  MemBuf will make a copy of your string for
-         * it's own use (often) and this will not (ever).
-         *@ingroup Streams
-         */
-        class StaticMemBuf : public Stream
-        {
-        public:
-                StaticMemBuf( const void *pData, size iSize );
-                virtual ~StaticMemBuf();
+    /**
+     * An immutable, read-only memory buffer.  Construct this buffer around a
+     * block of raw memory, provide the length of the block, and you can read
+     * from that block via this class as though it were a normal stream.
+     *
+     * Use this class instead of MemBuf when you have a string already, and
+     * don't need to change it.  MemBuf will make a copy of your string for
+     * it's own use (often) and this will not (ever).
+     *@ingroup Streams
+     */
+    class StaticMemBuf : public Stream
+    {
+    public:
+        StaticMemBuf( const void *pData, size iSize );
+        virtual ~StaticMemBuf();
 
-                virtual void close();
-                virtual size read( void *pBuf, size iBytes );
+        virtual void close();
+        virtual size read( void *pBuf, size iBytes );
 
-                virtual size write( const void *pBuf, size iBytes );
-                using Stream::write;
-                virtual size tell();
-                virtual void seek( size offset );
-                virtual void setPos( size pos );
-                virtual void setPosEnd( size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( size iSize );
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size write( const void *pBuf, size iBytes );
+        using Stream::write;
+        virtual size tell();
+        virtual void seek( size offset );
+        virtual void setPos( size pos );
+        virtual void setPosEnd( size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( size iSize );
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-        private:
-                const void *pData;
-                size iSize;
-                size nPos;
-        };
+    private:
+        const void *pData;
+        size iSize;
+        size nPos;
+    };
 }
 
 #endif
diff --git a/src/stable/stdstream.cpp b/src/stable/stdstream.cpp
index 25ad8d4..9cd216d 100644
--- a/src/stable/stdstream.cpp
+++ b/src/stable/stdstream.cpp
@@ -9,7 +9,7 @@
 #include "bu/stdstream.h"
 
 Bu::StdStream::StdStream( OutMode eOut ) :
-        eOut( eOut )
+    eOut( eOut )
 {
 }
 
@@ -23,17 +23,17 @@ void Bu::StdStream::close()
 
 Bu::size Bu::StdStream::read( void *pBuf, Bu::size nBytes )
 {
-        return fread( pBuf, 1, nBytes, stdin );
+    return fread( pBuf, 1, nBytes, stdin );
 }
 
 Bu::size Bu::StdStream::write( const void *pBuf, Bu::size nBytes )
 {
-        return fwrite( pBuf, 1, nBytes, eOut==StdOut?stdout:stderr );
+    return fwrite( pBuf, 1, nBytes, eOut==StdOut?stdout:stderr );
 }
 
 Bu::size Bu::StdStream::tell()
 {
-        return 0;
+    return 0;
 }
 
 void Bu::StdStream::seek( Bu::size )
@@ -50,47 +50,47 @@ void Bu::StdStream::setPosEnd( Bu::size )
 
 bool Bu::StdStream::isEos()
 {
-        return false;
+    return false;
 }
 
 bool Bu::StdStream::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::StdStream::flush()
 {
-        fflush( eOut==StdOut?stdout:stderr );
+    fflush( eOut==StdOut?stdout:stderr );
 }
 
 bool Bu::StdStream::canRead()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StdStream::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StdStream::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StdStream::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StdStream::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::StdStream::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::StdStream::setBlocking( bool )
@@ -103,16 +103,16 @@ void Bu::StdStream::setSize( Bu::size )
 
 Bu::size Bu::StdStream::getSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::StdStream::getBlockSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::String Bu::StdStream::getLocation() const
 {
-        return "";
+    return "";
 }
 
diff --git a/src/stable/stdstream.h b/src/stable/stdstream.h
index d71d95d..80c0fab 100644
--- a/src/stable/stdstream.h
+++ b/src/stable/stdstream.h
@@ -13,46 +13,46 @@
 
 namespace Bu
 {
-        /**
-         *@ingroup Streams
-         */
-        class StdStream : public Stream
-        {
-        public:
-                enum OutMode
-                {
-                        StdOut,
-                        StdError
-                };
-                StdStream( OutMode eOut=StdOut );
-                virtual ~StdStream();
+    /**
+     *@ingroup Streams
+     */
+    class StdStream : public Stream
+    {
+    public:
+        enum OutMode
+        {
+            StdOut,
+            StdError
+        };
+        StdStream( OutMode eOut=StdOut );
+        virtual ~StdStream();
 
-                virtual void close();
-                virtual size read( void *pBuf, size nBytes );
-                virtual size write( const void *pBuf, size nBytes );
-                using Stream::write;
-                virtual size tell();
-                virtual void seek( size offset );
-                virtual void setPos( size pos );
-                virtual void setPosEnd( size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( size iSize );
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-        
-        private:
-                OutMode eOut;
-        };
+        virtual void close();
+        virtual size read( void *pBuf, size nBytes );
+        virtual size write( const void *pBuf, size nBytes );
+        using Stream::write;
+        virtual size tell();
+        virtual void seek( size offset );
+        virtual void setPos( size pos );
+        virtual void setPosEnd( size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( size iSize );
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+    
+    private:
+        OutMode eOut;
+    };
 }
 
 #endif
diff --git a/src/stable/stream.cpp b/src/stable/stream.cpp
index 23a7f0f..551d657 100644
--- a/src/stable/stream.cpp
+++ b/src/stable/stream.cpp
@@ -17,37 +17,37 @@ Bu::Stream::~Stream()
 
 Bu::String Bu::Stream::readLine()
 {
-        Bu::String sRet;
-        
-        for(;;)
-        {
-                char s;
-                if( read( &s, 1 ) == 0 )
-                        return sRet;
-                if( s == '\n' || s == '\r' )
-                        return sRet;
-                sRet.append( s );
-        }
+    Bu::String sRet;
+    
+    for(;;)
+    {
+        char s;
+        if( read( &s, 1 ) == 0 )
+            return sRet;
+        if( s == '\n' || s == '\r' )
+            return sRet;
+        sRet.append( s );
+    }
 }
 
 Bu::String Bu::Stream::readAll()
 {
-        Bu::String sRet;
-        char buf[4096];
-
-        while( !isEos() )
-        {
-                int iRead = read( buf, 4096 );
-                if( iRead == 0 )
-                        return sRet;
-                sRet.append( buf, iRead );
-        }
-
-        return sRet;
+    Bu::String sRet;
+    char buf[4096];
+
+    while( !isEos() )
+    {
+        int iRead = read( buf, 4096 );
+        if( iRead == 0 )
+            return sRet;
+        sRet.append( buf, iRead );
+    }
+
+    return sRet;
 }
 
 Bu::size Bu::Stream::write( const Bu::String &sBuf )
 {
-        return write( sBuf.getStr(), sBuf.getSize() );
+    return write( sBuf.getStr(), sBuf.getSize() );
 }
 
diff --git a/src/stable/stream.h b/src/stable/stream.h
index 21e090e..a76e5fd 100644
--- a/src/stable/stream.h
+++ b/src/stable/stream.h
@@ -17,189 +17,189 @@
 
 namespace Bu
 {
-        /**
-         * The basis for a completely general data transport mechanism.  Anything
-         * that inherits from this should provide at least the basic read and/or
-         * write functions, and very probably the close function.  Any functions
-         * that aren't supported should throw an exception if called.
-         *
-         * The constructor of a child class should pretty much universally be used
-         * to open the stream.  I can't think of anything that should require an
-         * exception.
-         *@ingroup Streams
-         */
-        class Stream
-        {
-        public:
-                Stream();
-                virtual ~Stream();
-
-                /**
-                 * Close the stream.
-                 */
-                virtual void close() = 0;
-
-                /**
-                 * Read data from the stream into a buffer.
-                 *@param pBuf (void *) Buffer which will be filled.
-                 *@param nBytes (size_t) Max data to read.
-                 *@returns (size_t) Amount of data read.
-                 */
-                virtual size read( void *pBuf, size iBytes ) = 0;
-
-                /**
-                 * Attempts to read a complete line from the stream.  This will stop
-                 * reading when it has reached the end of the stream, or runs out of
-                 * data in a non-blocking stream.
-                 *@returns The line read, not including newline character.
-                 */
-                virtual Bu::String readLine();
-
-                /**
-                 * Reads all data from the current position onward until isEos returns
-                 * true and returns it as a Bu::String.  This will also return if no
-                 * data is available and the stream is in non-blocking mode.  This
-                 * function is intended for very particular circumstances and is often
-                 * not the most efficient way to access the data that you would like.
-                 *@returns The entire stream contents.
-                 */
-                virtual Bu::String readAll();
-
-                /**
-                 * Write data to the stream.
-                 *@param pBuf (const void *) The data to be written.
-                 *@param nBytes (size_t) Amount of data to write from pBuf.
-                 *@returns (size_t) Amount of data actually written.
-                 */
-                virtual size write( const void *pBuf, size iBytes ) = 0;
-
-                virtual size write( const Bu::String &sBuf );
-
-                /**
-                 * Get the current position in the stream.
-                 *@returns (long) The current position in the stream.
-                 */
-                virtual size tell() = 0;
-
-                /**
-                 * Seek to a position in the stream relative to the current position.
-                 *@param offset (long) Offset from current position to seek to.
-                 */
-                virtual void seek( size offset ) = 0;
-
-                /**
-                 * Set position in the stream relative to the start of the stream.
-                 *@param pos (long) The position.
-                 */
-                virtual void setPos( size pos ) = 0;
-
-                /**
-                 * Set position in the stream relative to the end of the stream.
-                 *@param pos (long) The position.
-                 */
-                virtual void setPosEnd( size pos ) = 0;
-
-                /**
-                 * Are we at the end of the stream?
-                 *@returns (bool) Are we at the end of the stream?
-                 */
-                virtual bool isEos() = 0;
-
-                /**
-                 * Is the stream open?
-                 *@returns (bool) Is the stream open?
-                 */
-                virtual bool isOpen() = 0;
-
-                /**
-                 * Flush any data still held in buffers.
-                 */
-                virtual void flush() = 0;
-
-                /**
-                 * In non-blocking streams this indicates if a read operation will
-                 * return data at the moment or not.  In blocking streams this should
-                 * return the same value as isEos().
-                 */
-                virtual bool canRead() = 0;
-
-                /**
-                 * In non-blocking streams this indicates if a write operation will
-                 * actually write one or more bytes.  In some cases writing is not
-                 * allowed (e.g. internal buffers are full) temporarilly.  In blocking
-                 * streams this should return the same value as isWritable.
-                 */
-                virtual bool canWrite() = 0;
-
-                /**
-                 * Indicates if the stream is capable of read operations.  This does not
-                 * indicate if such operations will return useful data, see canRead for
-                 * that.
-                 */
-                virtual bool isReadable() = 0;
-
-                /**
-                 * Indicates if the stream is capable of write operations.  This does
-                 * not indicate if such operations will succeed or fail, see canWrite
-                 * for that.
-                 */
-                virtual bool isWritable() = 0;
-
-                /**
-                 * Indicates if the stream is capable of seek operations.  This is
-                 * generally false for non-blocking streams.  Some buffered streams may
-                 * support limited in-buffer seeking.
-                 */
-                virtual bool isSeekable() = 0;
-
-                /**
-                 * Are we currently set to block mode?
-                 *@returns (bool)
-                 */
-                virtual bool isBlocking() = 0;
-
-                /**
-                 * Set stream to blocking or non-blocking mode.
-                 *@param bBlocking (bool) Whether we should block or not.
-                 */
-                virtual void setBlocking( bool bBlocking=true ) = 0;
-
-                /**
-                 * Set the size of the stream, this does not apply to many types of
-                 * streams.  For those that it does apply to, data will be added or
-                 * removed from the end of the stream, but the content of the added
-                 * data is undefined.
-                 */
-                virtual void setSize( size iSize ) = 0;
-
-                /**
-                 * Returns the size of the stream if the stream can have a size.  For
-                 * streams that do not (sockets, pipes, etc.) this should throw an
-                 * unsupported exception.
-                 */
-                virtual size getSize() const = 0;
-
-                /**
-                 * Returns the block-size of the stream, if it has one.  This should
-                 * throw an unsupported exception.  In some cases the block size
-                 * returned will not represent quite the same thing, for example,
-                 * sockets will return their MTU, while files will return the
-                 * filesystem's block size, and memory buffers will throw an exception.
-                 */
-                virtual size getBlockSize() const = 0;
-
-                /**
-                 * If possible, this returns a string that can be used to describe how
-                 * to access the open stream.  Not all streams support this, such as
-                 * MemBuf, but for files it may give you a path to a file, for a socket
-                 * it may give you an ip address, etc.  If it isn't supported, an empty
-                 * string may be returned.
-                 */
-                virtual Bu::String getLocation() const = 0;
-
-        private:
-
-        };
+    /**
+     * The basis for a completely general data transport mechanism.  Anything
+     * that inherits from this should provide at least the basic read and/or
+     * write functions, and very probably the close function.  Any functions
+     * that aren't supported should throw an exception if called.
+     *
+     * The constructor of a child class should pretty much universally be used
+     * to open the stream.  I can't think of anything that should require an
+     * exception.
+     *@ingroup Streams
+     */
+    class Stream
+    {
+    public:
+        Stream();
+        virtual ~Stream();
+
+        /**
+         * Close the stream.
+         */
+        virtual void close() = 0;
+
+        /**
+         * Read data from the stream into a buffer.
+         *@param pBuf (void *) Buffer which will be filled.
+         *@param nBytes (size_t) Max data to read.
+         *@returns (size_t) Amount of data read.
+         */
+        virtual size read( void *pBuf, size iBytes ) = 0;
+
+        /**
+         * Attempts to read a complete line from the stream.  This will stop
+         * reading when it has reached the end of the stream, or runs out of
+         * data in a non-blocking stream.
+         *@returns The line read, not including newline character.
+         */
+        virtual Bu::String readLine();
+
+        /**
+         * Reads all data from the current position onward until isEos returns
+         * true and returns it as a Bu::String.  This will also return if no
+         * data is available and the stream is in non-blocking mode.  This
+         * function is intended for very particular circumstances and is often
+         * not the most efficient way to access the data that you would like.
+         *@returns The entire stream contents.
+         */
+        virtual Bu::String readAll();
+
+        /**
+         * Write data to the stream.
+         *@param pBuf (const void *) The data to be written.
+         *@param nBytes (size_t) Amount of data to write from pBuf.
+         *@returns (size_t) Amount of data actually written.
+         */
+        virtual size write( const void *pBuf, size iBytes ) = 0;
+
+        virtual size write( const Bu::String &sBuf );
+
+        /**
+         * Get the current position in the stream.
+         *@returns (long) The current position in the stream.
+         */
+        virtual size tell() = 0;
+
+        /**
+         * Seek to a position in the stream relative to the current position.
+         *@param offset (long) Offset from current position to seek to.
+         */
+        virtual void seek( size offset ) = 0;
+
+        /**
+         * Set position in the stream relative to the start of the stream.
+         *@param pos (long) The position.
+         */
+        virtual void setPos( size pos ) = 0;
+
+        /**
+         * Set position in the stream relative to the end of the stream.
+         *@param pos (long) The position.
+         */
+        virtual void setPosEnd( size pos ) = 0;
+
+        /**
+         * Are we at the end of the stream?
+         *@returns (bool) Are we at the end of the stream?
+         */
+        virtual bool isEos() = 0;
+
+        /**
+         * Is the stream open?
+         *@returns (bool) Is the stream open?
+         */
+        virtual bool isOpen() = 0;
+
+        /**
+         * Flush any data still held in buffers.
+         */
+        virtual void flush() = 0;
+
+        /**
+         * In non-blocking streams this indicates if a read operation will
+         * return data at the moment or not.  In blocking streams this should
+         * return the same value as isEos().
+         */
+        virtual bool canRead() = 0;
+
+        /**
+         * In non-blocking streams this indicates if a write operation will
+         * actually write one or more bytes.  In some cases writing is not
+         * allowed (e.g. internal buffers are full) temporarilly.  In blocking
+         * streams this should return the same value as isWritable.
+         */
+        virtual bool canWrite() = 0;
+
+        /**
+         * Indicates if the stream is capable of read operations.  This does not
+         * indicate if such operations will return useful data, see canRead for
+         * that.
+         */
+        virtual bool isReadable() = 0;
+
+        /**
+         * Indicates if the stream is capable of write operations.  This does
+         * not indicate if such operations will succeed or fail, see canWrite
+         * for that.
+         */
+        virtual bool isWritable() = 0;
+
+        /**
+         * Indicates if the stream is capable of seek operations.  This is
+         * generally false for non-blocking streams.  Some buffered streams may
+         * support limited in-buffer seeking.
+         */
+        virtual bool isSeekable() = 0;
+
+        /**
+         * Are we currently set to block mode?
+         *@returns (bool)
+         */
+        virtual bool isBlocking() = 0;
+
+        /**
+         * Set stream to blocking or non-blocking mode.
+         *@param bBlocking (bool) Whether we should block or not.
+         */
+        virtual void setBlocking( bool bBlocking=true ) = 0;
+
+        /**
+         * Set the size of the stream, this does not apply to many types of
+         * streams.  For those that it does apply to, data will be added or
+         * removed from the end of the stream, but the content of the added
+         * data is undefined.
+         */
+        virtual void setSize( size iSize ) = 0;
+
+        /**
+         * Returns the size of the stream if the stream can have a size.  For
+         * streams that do not (sockets, pipes, etc.) this should throw an
+         * unsupported exception.
+         */
+        virtual size getSize() const = 0;
+
+        /**
+         * Returns the block-size of the stream, if it has one.  This should
+         * throw an unsupported exception.  In some cases the block size
+         * returned will not represent quite the same thing, for example,
+         * sockets will return their MTU, while files will return the
+         * filesystem's block size, and memory buffers will throw an exception.
+         */
+        virtual size getBlockSize() const = 0;
+
+        /**
+         * If possible, this returns a string that can be used to describe how
+         * to access the open stream.  Not all streams support this, such as
+         * MemBuf, but for files it may give you a path to a file, for a socket
+         * it may give you an ip address, etc.  If it isn't supported, an empty
+         * string may be returned.
+         */
+        virtual Bu::String getLocation() const = 0;
+
+    private:
+
+    };
 }
 
 #endif
diff --git a/src/stable/streamstack.cpp b/src/stable/streamstack.cpp
index 47ae5c0..deafbcf 100644
--- a/src/stable/streamstack.cpp
+++ b/src/stable/streamstack.cpp
@@ -13,222 +13,222 @@ Bu::StreamStack::StreamStack()
 
 Bu::StreamStack::StreamStack( Bu::Stream *pStream )
 {
-        lFilts.prepend( pStream );
+    lFilts.prepend( pStream );
 }
 
 Bu::StreamStack::~StreamStack()
 {
-        clear();
+    clear();
 }
 
 bool Bu::StreamStack::isEmpty()
 {
-        return lFilts.isEmpty();
+    return lFilts.isEmpty();
 }
 
 bool Bu::StreamStack::hasStream()
 {
-        return !lFilts.isEmpty();
+    return !lFilts.isEmpty();
 }
 
 void Bu::StreamStack::setStream( Bu::Stream *pStream )
 {
-        if( !lFilts.isEmpty() )
-                throw Bu::ExceptionBase("There is already a stream set.");
+    if( !lFilts.isEmpty() )
+        throw Bu::ExceptionBase("There is already a stream set.");
 
-        lFilts.prepend( pStream );
+    lFilts.prepend( pStream );
 }
 
 void Bu::StreamStack::clear()
 {
-        for( FilterList::iterator i = lFilts.begin(); i; i++ )
-        {
-                delete *i;
-        }
+    for( FilterList::iterator i = lFilts.begin(); i; i++ )
+    {
+        delete *i;
+    }
 
-        lFilts.clear();
+    lFilts.clear();
 }
 
 void Bu::StreamStack::popFilter()
 {
-        if( lFilts.isEmpty() )
-                return;
+    if( lFilts.isEmpty() )
+        return;
 
-        delete lFilts.first();
-        lFilts.erase( lFilts.begin() );
+    delete lFilts.first();
+    lFilts.erase( lFilts.begin() );
 }
 
 Bu::Stream *Bu::StreamStack::getTop()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first();
+    return lFilts.first();
 }
 
 Bu::Stream *Bu::StreamStack::getStream()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.last();
+    return lFilts.last();
 }
 
 void Bu::StreamStack::close()
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->close();
+    lFilts.first()->close();
 }
 
 Bu::size Bu::StreamStack::read( void *pBuf, Bu::size nBytes )
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->read( pBuf, nBytes );
+    return lFilts.first()->read( pBuf, nBytes );
 }
 
 Bu::size Bu::StreamStack::write( const void *pBuf, Bu::size nBytes )
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->write( pBuf, nBytes );
+    return lFilts.first()->write( pBuf, nBytes );
 }
 
 Bu::size Bu::StreamStack::write( const Bu::String &sBuf )
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->write( sBuf );
+    return lFilts.first()->write( sBuf );
 }
 
 Bu::size Bu::StreamStack::tell()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->tell();
+    return lFilts.first()->tell();
 }
 
 void Bu::StreamStack::seek( Bu::size offset )
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->seek( offset );
+    lFilts.first()->seek( offset );
 }
 
 void Bu::StreamStack::setPos( Bu::size pos )
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->setPos( pos );
+    lFilts.first()->setPos( pos );
 }
 
 void Bu::StreamStack::setPosEnd( Bu::size pos )
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->setPosEnd( pos );
+    lFilts.first()->setPosEnd( pos );
 }
 
 bool Bu::StreamStack::isEos()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isEos();
+    return lFilts.first()->isEos();
 }
 
 bool Bu::StreamStack::isOpen()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isOpen();
+    return lFilts.first()->isOpen();
 }
 
 void Bu::StreamStack::flush()
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->flush();
+    lFilts.first()->flush();
 }
 
 bool Bu::StreamStack::canRead()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->canRead();
+    return lFilts.first()->canRead();
 }
 
 bool Bu::StreamStack::canWrite()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->canWrite();
+    return lFilts.first()->canWrite();
 }
 
 bool Bu::StreamStack::isReadable()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isReadable();
+    return lFilts.first()->isReadable();
 }
 
 bool Bu::StreamStack::isWritable()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isWritable();
+    return lFilts.first()->isWritable();
 }
 
 bool Bu::StreamStack::isSeekable()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isSeekable();
+    return lFilts.first()->isSeekable();
 }
 
 bool Bu::StreamStack::isBlocking()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isBlocking();
+    return lFilts.first()->isBlocking();
 }
 
 void Bu::StreamStack::setBlocking( bool bBlocking )
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->setBlocking( bBlocking );
+    lFilts.first()->setBlocking( bBlocking );
 }
 
 void Bu::StreamStack::setSize( Bu::size iSize )
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->setSize( iSize );
+    lFilts.first()->setSize( iSize );
 }
 
 Bu::size Bu::StreamStack::getSize() const
 {
-        checkStack();
-        
-        return lFilts.first()->getSize();
+    checkStack();
+    
+    return lFilts.first()->getSize();
 }
 
 Bu::size Bu::StreamStack::getBlockSize() const
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->getBlockSize();
+    return lFilts.first()->getBlockSize();
 }
 
 Bu::String Bu::StreamStack::getLocation() const
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->getLocation();
+    return lFilts.first()->getLocation();
 }
 
 inline void Bu::StreamStack::checkStack() const
 {
-        if( lFilts.isEmpty() )
-                throw Bu::ExceptionBase("StreamStack is empty.");
+    if( lFilts.isEmpty() )
+        throw Bu::ExceptionBase("StreamStack is empty.");
 }
 
diff --git a/src/stable/streamstack.h b/src/stable/streamstack.h
index 36c2e11..06a3214 100644
--- a/src/stable/streamstack.h
+++ b/src/stable/streamstack.h
@@ -14,131 +14,131 @@
 
 namespace Bu
 {
-        class StreamStack : public Bu::Stream
-        {
-        private:
-                typedef Bu::List<Bu::Stream *> FilterList;
-
-        public:
-                StreamStack();
-                StreamStack( Bu::Stream *pStream );
-                virtual ~StreamStack();
-
-                bool isEmpty();
-                bool hasStream();
-                void setStream( Bu::Stream *pStream );
-
-                void clear();
-                void popFilter();
-                Bu::Stream *getTop();
-
-                Bu::Stream *getStream();
-
-                template<typename filter>
-                Bu::Stream *findFilter()
-                {
-                        for( FilterList::iterator i = lFilts.begin(); i; i++ )
-                        {
-                                if( typeid(**i) == typeid( filter ) )
-                                {
-                                        return *i;
-                                }
-                        }
-
-                        throw Bu::ExceptionBase("Filter not found.");
-                }
-
-                template<typename filter>
-                void pushFilter()
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first() );
-                        lFilts.prepend( pFlt );
-                }
-
-                template<typename filter, typename p1t>
-                void pushFilter( p1t p1 )
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first(), p1 );
-                        lFilts.prepend( pFlt );
-                }
-
-                template<typename filter, typename p1t, typename p2t>
-                void pushFilter( p1t p1, p2t p2 )
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first(), p1, p2 );
-                        lFilts.prepend( pFlt );
-                }
-
-                template<typename filter, typename p1t, typename p2t, typename p3t>
-                void pushFilter( p1t p1, p2t p2, p3t p3 )
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first(), p1, p2, p3 );
-                        lFilts.prepend( pFlt );
-                }
-
-                template<typename filter, typename p1t, typename p2t, typename p3t,
-                        typename p4t>
-                void pushFilter( p1t p1, p2t p2, p3t p3, p4t p4 )
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first(), p1, p2, p3, p4 );
-                        lFilts.prepend( pFlt );
-                }
-
-                template<typename filter, typename p1t, typename p2t, typename p3t,
-                        typename p4t, typename p5t>
-                void pushFilter( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first(), p1, p2, p3, p4, p5 );
-                        lFilts.prepend( pFlt );
-                }
-
-                //
-                // Everything below here merely passes on the call to the top of the
-                // stream stack.
-                //
-
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-
-                virtual Bu::size write( const Bu::String &sBuf );
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-
-        private:
-                void checkStack() const;
-
-        private:
-                FilterList lFilts;
-        };
+    class StreamStack : public Bu::Stream
+    {
+    private:
+        typedef Bu::List<Bu::Stream *> FilterList;
+
+    public:
+        StreamStack();
+        StreamStack( Bu::Stream *pStream );
+        virtual ~StreamStack();
+
+        bool isEmpty();
+        bool hasStream();
+        void setStream( Bu::Stream *pStream );
+
+        void clear();
+        void popFilter();
+        Bu::Stream *getTop();
+
+        Bu::Stream *getStream();
+
+        template<typename filter>
+        Bu::Stream *findFilter()
+        {
+            for( FilterList::iterator i = lFilts.begin(); i; i++ )
+            {
+                if( typeid(**i) == typeid( filter ) )
+                {
+                    return *i;
+                }
+            }
+
+            throw Bu::ExceptionBase("Filter not found.");
+        }
+
+        template<typename filter>
+        void pushFilter()
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first() );
+            lFilts.prepend( pFlt );
+        }
+
+        template<typename filter, typename p1t>
+        void pushFilter( p1t p1 )
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first(), p1 );
+            lFilts.prepend( pFlt );
+        }
+
+        template<typename filter, typename p1t, typename p2t>
+        void pushFilter( p1t p1, p2t p2 )
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first(), p1, p2 );
+            lFilts.prepend( pFlt );
+        }
+
+        template<typename filter, typename p1t, typename p2t, typename p3t>
+        void pushFilter( p1t p1, p2t p2, p3t p3 )
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first(), p1, p2, p3 );
+            lFilts.prepend( pFlt );
+        }
+
+        template<typename filter, typename p1t, typename p2t, typename p3t,
+            typename p4t>
+        void pushFilter( p1t p1, p2t p2, p3t p3, p4t p4 )
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first(), p1, p2, p3, p4 );
+            lFilts.prepend( pFlt );
+        }
+
+        template<typename filter, typename p1t, typename p2t, typename p3t,
+            typename p4t, typename p5t>
+        void pushFilter( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first(), p1, p2, p3, p4, p5 );
+            lFilts.prepend( pFlt );
+        }
+
+        //
+        // Everything below here merely passes on the call to the top of the
+        // stream stack.
+        //
+
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+        virtual Bu::size write( const Bu::String &sBuf );
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+
+    private:
+        void checkStack() const;
+
+    private:
+        FilterList lFilts;
+    };
 };
 
 #endif
diff --git a/src/stable/strfilter.h b/src/stable/strfilter.h
index 8da0a3f..c910574 100644
--- a/src/stable/strfilter.h
+++ b/src/stable/strfilter.h
@@ -6,119 +6,119 @@
 
 namespace Bu
 {
-        //
-        // Encoders
-        //
-        template<typename tFilter>
-        Bu::String encodeStr( const Bu::String &sIn )
-        {
-                Bu::MemBuf mb;
-                {
-                        tFilter fEnc( mb );
-                        fEnc.write( sIn.getStr(), sIn.getSize() );
-                }
-                return mb.getString();
-        }
+    //
+    // Encoders
+    //
+    template<typename tFilter>
+    Bu::String encodeStr( const Bu::String &sIn )
+    {
+        Bu::MemBuf mb;
+        {
+            tFilter fEnc( mb );
+            fEnc.write( sIn.getStr(), sIn.getSize() );
+        }
+        return mb.getString();
+    }
 
-        template<typename tFilter, typename p1t>
-        Bu::String encodeStr( const Bu::String &sIn, p1t p1 )
-        {
-                Bu::MemBuf mb;
-                {
-                        tFilter fEnc( mb, p1 );
-                        fEnc.write( sIn.getStr(), sIn.getSize() );
-                }
-                return mb.getString();
-        }
+    template<typename tFilter, typename p1t>
+    Bu::String encodeStr( const Bu::String &sIn, p1t p1 )
+    {
+        Bu::MemBuf mb;
+        {
+            tFilter fEnc( mb, p1 );
+            fEnc.write( sIn.getStr(), sIn.getSize() );
+        }
+        return mb.getString();
+    }
 
-        template<typename tFilter, typename p1t, typename p2t>
-        Bu::String encodeStr( const Bu::String &sIn, p1t p1, p2t p2 )
-        {
-                Bu::MemBuf mb;
-                {
-                        tFilter fEnc( mb, p1, p2 );
-                        fEnc.write( sIn.getStr(), sIn.getSize() );
-                }
-                return mb.getString();
-        }
+    template<typename tFilter, typename p1t, typename p2t>
+    Bu::String encodeStr( const Bu::String &sIn, p1t p1, p2t p2 )
+    {
+        Bu::MemBuf mb;
+        {
+            tFilter fEnc( mb, p1, p2 );
+            fEnc.write( sIn.getStr(), sIn.getSize() );
+        }
+        return mb.getString();
+    }
 
-        template<typename tFilter, typename p1t, typename p2t, typename p3t>
-        Bu::String encodeStr( const Bu::String &sIn, p1t p1, p2t p2, p3t p3 )
-        {
-                Bu::MemBuf mb;
-                {
-                        tFilter fEnc( mb, p1, p2 );
-                        fEnc.write( sIn.getStr(), sIn.getSize() );
-                }
-                return mb.getString();
-        }
+    template<typename tFilter, typename p1t, typename p2t, typename p3t>
+    Bu::String encodeStr( const Bu::String &sIn, p1t p1, p2t p2, p3t p3 )
+    {
+        Bu::MemBuf mb;
+        {
+            tFilter fEnc( mb, p1, p2 );
+            fEnc.write( sIn.getStr(), sIn.getSize() );
+        }
+        return mb.getString();
+    }
 
-        //
-        // Decoders
-        //
-        template<typename tFilter>
-        Bu::String decodeStr( const Bu::String &sIn )
-        {
-                Bu::MemBuf mb( sIn );
-                tFilter fDec( mb );
-                char buf[1024];
-                String sRet;
-                for(;;)
-                {
-                        int iRead = fDec.read( buf, 1024 );
-                        if( iRead == 0 )
-                                return sRet;
-                        sRet.append( buf, iRead );
-                }
-        }
-        
-        template<typename tFilter, typename p1t>
-        Bu::String decodeStr( const Bu::String &sIn, p1t p1 )
-        {
-                Bu::MemBuf mb( sIn );
-                tFilter fDec( mb, p1 );
-                char buf[1024];
-                String sRet;
-                for(;;)
-                {
-                        int iRead = fDec.read( buf, 1024 );
-                        if( iRead == 0 )
-                                return sRet;
-                        sRet.append( buf, iRead );
-                }
-        }
-        
-        template<typename tFilter, typename p1t, typename p2t>
-        Bu::String decodeStr( const Bu::String &sIn, p1t p1, p2t p2 )
-        {
-                Bu::MemBuf mb( sIn );
-                tFilter fDec( mb, p1, p2 );
-                char buf[1024];
-                String sRet;
-                for(;;)
-                {
-                        int iRead = fDec.read( buf, 1024 );
-                        if( iRead == 0 )
-                                return sRet;
-                        sRet.append( buf, iRead );
-                }
-        }
-        
-        template<typename tFilter, typename p1t, typename p2t, typename p3t>
-        Bu::String decodeStr( const Bu::String &sIn, p1t p1, p2t p2, p3t p3 )
-        {
-                Bu::MemBuf mb( sIn );
-                tFilter fDec( mb, p1, p2, p3 );
-                char buf[1024];
-                String sRet;
-                for(;;)
-                {
-                        int iRead = fDec.read( buf, 1024 );
-                        if( iRead == 0 )
-                                return sRet;
-                        sRet.append( buf, iRead );
-                }
-        }
+    //
+    // Decoders
+    //
+    template<typename tFilter>
+    Bu::String decodeStr( const Bu::String &sIn )
+    {
+        Bu::MemBuf mb( sIn );
+        tFilter fDec( mb );
+        char buf[1024];
+        String sRet;
+        for(;;)
+        {
+            int iRead = fDec.read( buf, 1024 );
+            if( iRead == 0 )
+                return sRet;
+            sRet.append( buf, iRead );
+        }
+    }
+    
+    template<typename tFilter, typename p1t>
+    Bu::String decodeStr( const Bu::String &sIn, p1t p1 )
+    {
+        Bu::MemBuf mb( sIn );
+        tFilter fDec( mb, p1 );
+        char buf[1024];
+        String sRet;
+        for(;;)
+        {
+            int iRead = fDec.read( buf, 1024 );
+            if( iRead == 0 )
+                return sRet;
+            sRet.append( buf, iRead );
+        }
+    }
+    
+    template<typename tFilter, typename p1t, typename p2t>
+    Bu::String decodeStr( const Bu::String &sIn, p1t p1, p2t p2 )
+    {
+        Bu::MemBuf mb( sIn );
+        tFilter fDec( mb, p1, p2 );
+        char buf[1024];
+        String sRet;
+        for(;;)
+        {
+            int iRead = fDec.read( buf, 1024 );
+            if( iRead == 0 )
+                return sRet;
+            sRet.append( buf, iRead );
+        }
+    }
+    
+    template<typename tFilter, typename p1t, typename p2t, typename p3t>
+    Bu::String decodeStr( const Bu::String &sIn, p1t p1, p2t p2, p3t p3 )
+    {
+        Bu::MemBuf mb( sIn );
+        tFilter fDec( mb, p1, p2, p3 );
+        char buf[1024];
+        String sRet;
+        for(;;)
+        {
+            int iRead = fDec.read( buf, 1024 );
+            if( iRead == 0 )
+                return sRet;
+            sRet.append( buf, iRead );
+        }
+    }
 };
 
 #endif
diff --git a/src/stable/string.cpp b/src/stable/string.cpp
index dd484fd..d073ec6 100644
--- a/src/stable/string.cpp
+++ b/src/stable/string.cpp
@@ -14,117 +14,117 @@
 #include "bu/formatter.h"
 #include <stdlib.h>
 
-#define nMinSize        (256)
+#define nMinSize    (256)
 
 Bu::StringCore::StringCore() :
-        nLength( 0 ),
-        pFirst( NULL ),
-        pLast( NULL )
+    nLength( 0 ),
+    pFirst( NULL ),
+    pLast( NULL )
 {
 }
 
 Bu::StringCore::StringCore( const StringCore &rSrc ) :
-        nLength( rSrc.nLength ),
-        pFirst( NULL ),
-        pLast( NULL )
-{
-        if( rSrc.pFirst == NULL || rSrc.nLength == 0 )
-        {
-                pFirst = pLast = NULL;
-        }
-        else
-        {
-                pFirst = pLast = newChunk( nLength );
-                Chunk *pLink = rSrc.pFirst;
-                int iPos = 0;
-                while( pLink != NULL )
-                {
-                        memcpy( pFirst->pData+iPos, pLink->pData, pLink->nLength );
-                        iPos += pLink->nLength;
-                        pLink = pLink->pNext;
-                }
-        }
+    nLength( rSrc.nLength ),
+    pFirst( NULL ),
+    pLast( NULL )
+{
+    if( rSrc.pFirst == NULL || rSrc.nLength == 0 )
+    {
+        pFirst = pLast = NULL;
+    }
+    else
+    {
+        pFirst = pLast = newChunk( nLength );
+        Chunk *pLink = rSrc.pFirst;
+        int iPos = 0;
+        while( pLink != NULL )
+        {
+            memcpy( pFirst->pData+iPos, pLink->pData, pLink->nLength );
+            iPos += pLink->nLength;
+            pLink = pLink->pNext;
+        }
+    }
 }
 
 Bu::StringCore::~StringCore()
 {
-        clear();
+    clear();
 }
 
 void Bu::StringCore::clear() const
 {
-        if( pFirst == NULL )
-                return;
-
-        Chunk *i = pFirst;
-        for(;;)
-        {
-                Chunk *n = i->pNext;
-                delete[] i->pData;
-                delete i;
-                if( n == NULL )
-                        break;
-                i = n;
-        }
-        pFirst = pLast = NULL;
-        nLength = 0;
-}       
+    if( pFirst == NULL )
+        return;
+
+    Chunk *i = pFirst;
+    for(;;)
+    {
+        Chunk *n = i->pNext;
+        delete[] i->pData;
+        delete i;
+        if( n == NULL )
+            break;
+        i = n;
+    }
+    pFirst = pLast = NULL;
+    nLength = 0;
+}   
 
 Bu::StringCore::Chunk *Bu::StringCore::newChunk() const
 {
-        Chunk *pNew = new Chunk;
-        pNew->pNext = NULL;
-        return pNew;
+    Chunk *pNew = new Chunk;
+    pNew->pNext = NULL;
+    return pNew;
 }
 
 Bu::StringCore::Chunk *Bu::StringCore::newChunk( long nLen ) const
 {
-        Chunk *pNew = new Chunk;
-        pNew->pNext = NULL;
-        pNew->nLength = nLen;
-        pNew->pData = new char[(nLen<nMinSize)?(nMinSize):(nLen)+1];
-        pNew->pData[nLen] = (char)0;
-        return pNew;
+    Chunk *pNew = new Chunk;
+    pNew->pNext = NULL;
+    pNew->nLength = nLen;
+    pNew->pData = new char[(nLen<nMinSize)?(nMinSize):(nLen)+1];
+    pNew->pData[nLen] = (char)0;
+    return pNew;
 }
 
 Bu::StringCore::Chunk *Bu::StringCore::copyChunk(
-                Bu::StringCore::Chunk *pSrc ) const
+        Bu::StringCore::Chunk *pSrc ) const
 {
-        Chunk *pNew = new Chunk;
-        pNew->pNext = pSrc->pNext;
-        pNew->nLength = pSrc->nLength;
-        pNew->pData = new char[
-                (pNew->nLength<nMinSize)?(nMinSize):(pNew->nLength)+1
-                ];
-        memcpy( pNew->pData, pSrc->pData, pSrc->nLength );
-        pNew->pData[pNew->nLength] = (char)0;
-        return pNew;
+    Chunk *pNew = new Chunk;
+    pNew->pNext = pSrc->pNext;
+    pNew->nLength = pSrc->nLength;
+    pNew->pData = new char[
+        (pNew->nLength<nMinSize)?(nMinSize):(pNew->nLength)+1
+        ];
+    memcpy( pNew->pData, pSrc->pData, pSrc->nLength );
+    pNew->pData[pNew->nLength] = (char)0;
+    return pNew;
 }
 
 void Bu::StringCore::appendChunk( Bu::StringCore::Chunk *pNewChunk )
 {
-        if( pFirst == NULL )
-                pLast = pFirst = pNewChunk;
-        else
-        {
-                pLast->pNext = pNewChunk;
-                pLast = pNewChunk;
-        }
+    if( pFirst == NULL )
+        pLast = pFirst = pNewChunk;
+    else
+    {
+        pLast->pNext = pNewChunk;
+        pLast = pNewChunk;
+    }
 
-        nLength += pNewChunk->nLength;
+    nLength += pNewChunk->nLength;
 }
 
 void Bu::StringCore::prependChunk( Bu::StringCore::Chunk *pNewChunk )
 {
-        if( pFirst == NULL )
-                pLast = pFirst = pNewChunk;
-        else
-        {
-                pNewChunk->pNext = pFirst;
-                pFirst = pNewChunk;
-        }
+    if( pFirst == NULL )
+        pLast = pFirst = pNewChunk;
+    else
+    {
+        pNewChunk->pNext = pFirst;
+        pFirst = pNewChunk;
+    }
 
-        nLength += pNewChunk->nLength;
+    nLength += pNewChunk->nLength;
 }
 
 Bu::String::String()
@@ -133,44 +133,44 @@ Bu::String::String()
 
 Bu::String::String( const char *pData )
 {
-        append( pData );
+    append( pData );
 }
 
 Bu::String::String( const char *pData, long nLength )
 {
-        append( pData, nLength );
+    append( pData, nLength );
 }
 
 Bu::String::String( const Bu::String &rSrc ) :
-        Bu::SharedCore<Bu::String, Bu::StringCore>( rSrc )
+    Bu::SharedCore<Bu::String, Bu::StringCore>( rSrc )
 {
 }
 
 Bu::String::String( const Bu::String &rSrc, long nLength )
 {
-        append( rSrc, nLength );
+    append( rSrc, nLength );
 }
 
 Bu::String::String( const Bu::String &rSrc, long nStart, long nLength )
 {
-        append( rSrc, nStart, nLength );
+    append( rSrc, nStart, nLength );
 }
 
 Bu::String::String( long nSize )
 {
-        core->pFirst = core->pLast = core->newChunk( nSize );
-        core->nLength = nSize;
+    core->pFirst = core->pLast = core->newChunk( nSize );
+    core->nLength = nSize;
 }
 
 Bu::String::String( const Bu::String::const_iterator &s )
 {
-        append( s );
+    append( s );
 }
 
 Bu::String::String( const Bu::String::const_iterator &s,
-                const Bu::String::const_iterator &e )
+        const Bu::String::const_iterator &e )
 {
-        append( s, e );
+    append( s, e );
 }
 
 Bu::String::~String()
@@ -179,1049 +179,1049 @@ Bu::String::~String()
 
 void Bu::String::append( const char *pData )
 {
-        if( !pData ) return;
-        long nLen;
-        for( nLen = 0; pData[nLen] != (char)0; nLen++ ) { }
+    if( !pData ) return;
+    long nLen;
+    for( nLen = 0; pData[nLen] != (char)0; nLen++ ) { }
 
-        append( pData, 0, nLen );
+    append( pData, 0, nLen );
 }
 
 void Bu::String::append( const char *pData, long nLen )
 {
-        append( pData, 0, nLen );
+    append( pData, 0, nLen );
 }
 
 void Bu::String::append( const char *pData, long nStart, long nLen )
 {
-        if( !pData ) return;
-        if( nLen <= 0 )
-                return;
-
-        pData += nStart;
-
-        _hardCopy();
-
-        if( core->pLast && core->pLast->nLength < nMinSize )
-        {
-                int nAmnt = nMinSize - core->pLast->nLength;
-                if( nAmnt > nLen )
-                        nAmnt = nLen;
-                memcpy(
-                        core->pLast->pData+core->pLast->nLength,
-                        pData,
-                        nAmnt
-                   );
-                pData += nAmnt;
-                core->pLast->nLength += nAmnt;
-                nLen -= nAmnt;
-                core->nLength += nAmnt;
-        }
-
-        if( nLen > 0 )
-        {
-                Chunk *pNew = core->newChunk( nLen );
-                memcpy( pNew->pData, pData, nLen );
-                core->appendChunk( pNew );
-//                              core->nLength += nLen;
-        }
+    if( !pData ) return;
+    if( nLen <= 0 )
+        return;
+
+    pData += nStart;
+
+    _hardCopy();
+
+    if( core->pLast && core->pLast->nLength < nMinSize )
+    {
+        int nAmnt = nMinSize - core->pLast->nLength;
+        if( nAmnt > nLen )
+            nAmnt = nLen;
+        memcpy(
+            core->pLast->pData+core->pLast->nLength,
+            pData,
+            nAmnt
+           );
+        pData += nAmnt;
+        core->pLast->nLength += nAmnt;
+        nLen -= nAmnt;
+        core->nLength += nAmnt;
+    }
+
+    if( nLen > 0 )
+    {
+        Chunk *pNew = core->newChunk( nLen );
+        memcpy( pNew->pData, pData, nLen );
+        core->appendChunk( pNew );
+//              core->nLength += nLen;
+    }
 }
 
 void Bu::String::append( const char &cData )
 {
-        if( core->pLast && core->pLast->nLength < nMinSize )
-        {
-                _hardCopy();
-                core->pLast->pData[core->pLast->nLength] = cData;
-                ++core->pLast->nLength; ++core->nLength;
-//              pLast->pData[pLast->nLength] = (char)0;
-        }
-        else
-        {
-                append( &cData, 1 );
-        }
+    if( core->pLast && core->pLast->nLength < nMinSize )
+    {
+        _hardCopy();
+        core->pLast->pData[core->pLast->nLength] = cData;
+        ++core->pLast->nLength; ++core->nLength;
+//      pLast->pData[pLast->nLength] = (char)0;
+    }
+    else
+    {
+        append( &cData, 1 );
+    }
 }
 
 void Bu::String::append( const String & sData )
 {
-        append( sData.getStr(), 0, sData.getSize() );
+    append( sData.getStr(), 0, sData.getSize() );
 }
 
 void Bu::String::append( const String & sData, long nLen )
 {
-        append( sData.getStr(), 0, nLen );
+    append( sData.getStr(), 0, nLen );
 }
 
 void Bu::String::append( const String & sData, long nStart, long nLen )
 {
-        if( nLen < 0 )
-                nLen = sData.getSize() - nStart;
-        append( sData.getStr(), nStart, nLen );
+    if( nLen < 0 )
+        nLen = sData.getSize() - nStart;
+    append( sData.getStr(), nStart, nLen );
 }
 
 void Bu::String::append( const const_iterator &s )
 {
-        if( !s.isValid() )
-                return;
-        Chunk *pSrc = s.pChunk;
+    if( !s.isValid() )
+        return;
+    Chunk *pSrc = s.pChunk;
 
-        Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
-        memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
+    Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
+    memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
 
-        _hardCopy();
-        core->appendChunk( pNew );
+    _hardCopy();
+    core->appendChunk( pNew );
 
-        while( (pSrc = pSrc->pNext) )
-        {
-                core->appendChunk( core->copyChunk( pSrc ) );
-        }
+    while( (pSrc = pSrc->pNext) )
+    {
+        core->appendChunk( core->copyChunk( pSrc ) );
+    }
 }
 
 void Bu::String::append( const iterator &s )
 {
-        append( const_iterator( s ) );
+    append( const_iterator( s ) );
 }
 
 void Bu::String::append( const const_iterator &s, const const_iterator &e )
 {
-        if( !s.isValid() )
-                return;
-        if( !e.isValid() )
-        {
-                append( s );
-                return;
-        }
-        _hardCopy();
-        if( s.pChunk == e.pChunk )
-        {
-                // Simple case, they're the same chunk
-                Chunk *pNew = core->newChunk( e.iPos-s.iPos );
-                memcpy( pNew->pData, s.pChunk->pData+s.iPos, e.iPos-s.iPos );
-                core->appendChunk( pNew );
-        }
-        else
-        {
-                // A little trickier, scan the blocks...
-                Chunk *pSrc = s.pChunk;
-                Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
-                memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
-                core->appendChunk( pNew );
-
-                while( (pSrc = pSrc->pNext) != e.pChunk )
-                {
-                        core->appendChunk( core->copyChunk( pSrc ) );
-                }
-
-                pNew = core->newChunk( e.iPos );
-                memcpy( pNew->pData, pSrc->pData, e.iPos );
-                core->appendChunk( pNew );
-        }
+    if( !s.isValid() )
+        return;
+    if( !e.isValid() )
+    {
+        append( s );
+        return;
+    }
+    _hardCopy();
+    if( s.pChunk == e.pChunk )
+    {
+        // Simple case, they're the same chunk
+        Chunk *pNew = core->newChunk( e.iPos-s.iPos );
+        memcpy( pNew->pData, s.pChunk->pData+s.iPos, e.iPos-s.iPos );
+        core->appendChunk( pNew );
+    }
+    else
+    {
+        // A little trickier, scan the blocks...
+        Chunk *pSrc = s.pChunk;
+        Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
+        memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
+        core->appendChunk( pNew );
+
+        while( (pSrc = pSrc->pNext) != e.pChunk )
+        {
+            core->appendChunk( core->copyChunk( pSrc ) );
+        }
+
+        pNew = core->newChunk( e.iPos );
+        memcpy( pNew->pData, pSrc->pData, e.iPos );
+        core->appendChunk( pNew );
+    }
 }
 
 void Bu::String::prepend( const String & sData )
 {
-        prepend( sData.getStr(), sData.getSize() );
+    prepend( sData.getStr(), sData.getSize() );
 }
 
 void Bu::String::prepend( const char *pData )
 {
-        if( pData == NULL )
-                return;
+    if( pData == NULL )
+        return;
 
-        _hardCopy();
-        long nLen;
-        for( nLen = 0; pData[nLen] != (char)0; nLen++ ) { }
-        
-        Chunk *pNew = core->newChunk( nLen );
-        memcpy( pNew->pData, pData, nLen );
+    _hardCopy();
+    long nLen;
+    for( nLen = 0; pData[nLen] != (char)0; nLen++ ) { }
+    
+    Chunk *pNew = core->newChunk( nLen );
+    memcpy( pNew->pData, pData, nLen );
 
-        core->prependChunk( pNew );
+    core->prependChunk( pNew );
 }
 
 void Bu::String::prepend( const char *pData, long nLen )
 {
-        Chunk *pNew = core->newChunk( nLen );
-        
-        memcpy( pNew->pData, pData, nLen );
+    Chunk *pNew = core->newChunk( nLen );
+    
+    memcpy( pNew->pData, pData, nLen );
 
-        _hardCopy();
-        core->prependChunk( pNew );
+    _hardCopy();
+    core->prependChunk( pNew );
 }
 
 void Bu::String::prepend( const char c )
 {
-        prepend( &c, 1 );
+    prepend( &c, 1 );
 }
 
 void Bu::String::insert( long nPos, const char *pData, long nLen )
 {
-        if( nLen <= 0 )
-                return;
-        if( nPos <= 0 )
-        {
-                prepend( pData, nLen );
-        }
-        else if( nPos >= core->nLength )
-        {
-                append( pData, nLen );
-        }
-        else
-        {
-                // If we're going to flatten anyway, might as well for everyone
-                flatten();
-                _hardCopy();
-                Chunk *p1 = core->newChunk( nPos );
-                Chunk *p2 = core->newChunk( nLen );
-                Chunk *p3 = core->newChunk( core->nLength-nPos );
-                memcpy( p1->pData, core->pFirst->pData, nPos );
-                memcpy( p2->pData, pData, nLen );
-                memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
-                core->clear();
-                core->appendChunk( p1 );
-                core->appendChunk( p2 );
-                core->appendChunk( p3 );
-        }
+    if( nLen <= 0 )
+        return;
+    if( nPos <= 0 )
+    {
+        prepend( pData, nLen );
+    }
+    else if( nPos >= core->nLength )
+    {
+        append( pData, nLen );
+    }
+    else
+    {
+        // If we're going to flatten anyway, might as well for everyone
+        flatten();
+        _hardCopy();
+        Chunk *p1 = core->newChunk( nPos );
+        Chunk *p2 = core->newChunk( nLen );
+        Chunk *p3 = core->newChunk( core->nLength-nPos );
+        memcpy( p1->pData, core->pFirst->pData, nPos );
+        memcpy( p2->pData, pData, nLen );
+        memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
+        core->clear();
+        core->appendChunk( p1 );
+        core->appendChunk( p2 );
+        core->appendChunk( p3 );
+    }
 }
 
 void Bu::String::insert( long nPos, const String &str )
 {
-        if( nPos <= 0 )
-        {
-                prepend( str );
-        }
-        else if( nPos >= core->nLength )
-        {
-                append( str );
-        }
-        else
-        {
-                flatten();
-                _hardCopy();
-                Chunk *p1 = core->newChunk( nPos );
-                Chunk *p3 = core->newChunk( core->nLength-nPos );
-                memcpy( p1->pData, core->pFirst->pData, nPos );
-                memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
-                core->clear();
-                core->appendChunk( p1 );
-                for( Chunk *pChnk = str.core->pFirst; pChnk;
-                         pChnk = pChnk->pNext )
-                {
-                        core->appendChunk( core->copyChunk( pChnk ) );
-                }
-
-                core->appendChunk( p3 );
-        }
+    if( nPos <= 0 )
+    {
+        prepend( str );
+    }
+    else if( nPos >= core->nLength )
+    {
+        append( str );
+    }
+    else
+    {
+        flatten();
+        _hardCopy();
+        Chunk *p1 = core->newChunk( nPos );
+        Chunk *p3 = core->newChunk( core->nLength-nPos );
+        memcpy( p1->pData, core->pFirst->pData, nPos );
+        memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
+        core->clear();
+        core->appendChunk( p1 );
+        for( Chunk *pChnk = str.core->pFirst; pChnk;
+             pChnk = pChnk->pNext )
+        {
+            core->appendChunk( core->copyChunk( pChnk ) );
+        }
+
+        core->appendChunk( p3 );
+    }
 }
 
 void Bu::String::insert( long nPos, const char *pData )
 {
-        insert( nPos, pData, strlen( pData ) );
+    insert( nPos, pData, strlen( pData ) );
 }
 
 void Bu::String::remove( long nPos, long nLen )
 {
-        if( nLen <= 0 || nPos < 0 || nPos >= core->nLength )
-                return;
-        if( nLen > core->nLength-nPos )
-                nLen = core->nLength-nPos;
-        flatten();
-        _hardCopy();
-        memmove( core->pFirst->pData+nPos, core->pFirst->pData+nPos+nLen, core->nLength-nPos-nLen+1 );
-        core->nLength -= nLen;
-        core->pFirst->nLength -= nLen;
+    if( nLen <= 0 || nPos < 0 || nPos >= core->nLength )
+        return;
+    if( nLen > core->nLength-nPos )
+        nLen = core->nLength-nPos;
+    flatten();
+    _hardCopy();
+    memmove( core->pFirst->pData+nPos, core->pFirst->pData+nPos+nLen, core->nLength-nPos-nLen+1 );
+    core->nLength -= nLen;
+    core->pFirst->nLength -= nLen;
 }
 
 void Bu::String::clear()
 {
-        _hardCopy();
-        core->clear();
+    _hardCopy();
+    core->clear();
 }
 
 Bu::String Bu::String::replace( const Bu::String &fnd,
-                const Bu::String &rep ) const
-{
-        String out;
-        const_iterator o = begin();
-        while( true )
-        {
-                const_iterator i = o.find( fnd, fnd.getSize() );
-                if( !i )
-                {
-                        out.append( o );
-                        return out;
-                }
-                else
-                {
-                        out.append( o, i );
-                        out.append( rep );
-                        o = i;
-                        o += fnd.getSize();
-                }
-        }
+        const Bu::String &rep ) const
+{
+    String out;
+    const_iterator o = begin();
+    while( true )
+    {
+        const_iterator i = o.find( fnd, fnd.getSize() );
+        if( !i )
+        {
+            out.append( o );
+            return out;
+        }
+        else
+        {
+            out.append( o, i );
+            out.append( rep );
+            o = i;
+            o += fnd.getSize();
+        }
+    }
 }
 
 void Bu::String::resize( long nNewSize )
 {
-        if( core->nLength == nNewSize )
-                return;
-        if( nNewSize < 0 )
-                nNewSize = 0;
+    if( core->nLength == nNewSize )
+        return;
+    if( nNewSize < 0 )
+        nNewSize = 0;
 
-        flatten();
-        _hardCopy();
+    flatten();
+    _hardCopy();
 
-        // TODO:  This is bad
+    // TODO:  This is bad
 
-        Chunk *pNew = core->newChunk( nNewSize );
-        long nNewLen = (nNewSize<core->nLength)?(nNewSize):(core->nLength);
-        if( core->nLength > 0 )
-        {
-                memcpy( pNew->pData, core->pFirst->pData, nNewLen );
-                delete[] core->pFirst->pData;
-                delete core->pFirst;
-        }
-        pNew->pData[nNewLen] = (char)0;
-        core->pFirst = core->pLast = pNew;
-        core->nLength = nNewSize;
+    Chunk *pNew = core->newChunk( nNewSize );
+    long nNewLen = (nNewSize<core->nLength)?(nNewSize):(core->nLength);
+    if( core->nLength > 0 )
+    {
+        memcpy( pNew->pData, core->pFirst->pData, nNewLen );
+        delete[] core->pFirst->pData;
+        delete core->pFirst;
+    }
+    pNew->pData[nNewLen] = (char)0;
+    core->pFirst = core->pLast = pNew;
+    core->nLength = nNewSize;
 }
 
 long Bu::String::getSize() const
 {
-        return core->nLength;
+    return core->nLength;
 }
 
 char *Bu::String::getStr()
 {
-        if( core->pFirst == NULL || core->nLength == 0 )
-                return (char *)"";
+    if( core->pFirst == NULL || core->nLength == 0 )
+        return (char *)"";
 
-        flatten();
-        _hardCopy();
-        core->pFirst->pData[core->nLength] = (char)0;
-        return core->pFirst->pData;
+    flatten();
+    _hardCopy();
+    core->pFirst->pData[core->nLength] = (char)0;
+    return core->pFirst->pData;
 }
 
 const char *Bu::String::getStr() const
 {
-        if( core->pFirst == NULL || core->nLength == 0 )
-                return (char *)"";
+    if( core->pFirst == NULL || core->nLength == 0 )
+        return (char *)"";
 
-        flatten();
-        core->pFirst->pData[core->nLength] = (char)0;
-        return core->pFirst->pData;
+    flatten();
+    core->pFirst->pData[core->nLength] = (char)0;
+    return core->pFirst->pData;
 }
 
 const char *Bu::String::getConstStr() const
 {
-        return getStr();
+    return getStr();
 }
 
 Bu::String Bu::String::getSubStrIdx( long iStart, long iSize ) const
 {
-        if( iStart < 0 )
-                iStart = 0;
-        if( iStart >= core->nLength )
-                return (const char[]){(char)0};
-        if( iSize < 0 )
-                iSize = core->nLength;
-        if( iStart+iSize > core->nLength )
-                iSize = core->nLength-iStart;
-        if( iSize == 0 )
-                return (const char[]){(char)0};
+    if( iStart < 0 )
+        iStart = 0;
+    if( iStart >= core->nLength )
+        return (const char[]){(char)0};
+    if( iSize < 0 )
+        iSize = core->nLength;
+    if( iStart+iSize > core->nLength )
+        iSize = core->nLength-iStart;
+    if( iSize == 0 )
+        return (const char[]){(char)0};
 
-        flatten();
-        String ret( core->pFirst->pData+iStart, iSize );
-        return ret;
+    flatten();
+    String ret( core->pFirst->pData+iStart, iSize );
+    return ret;
 }
 
 Bu::String Bu::String::getSubStr( const_iterator iBegin,
-                const_iterator iEnd ) const
-{
-        if( !iBegin.isValid() )
-                return String();
-        if( iBegin.pChunk == iEnd.pChunk )
-        {
-                return String( iBegin.pChunk->pData+iBegin.iPos,
-                        iEnd.iPos-iBegin.iPos );
-        }
-        else if( !iEnd.isValid() )
-        {
-                String ret;
-                ret.append(
-                        iBegin.pChunk->pData+iBegin.iPos,
-                        iBegin.pChunk->nLength-iBegin.iPos
-                        );
-                for( Chunk *pCur = iBegin.pChunk->pNext;
-                         pCur; pCur = pCur->pNext )
-                {
-                        ret.append( pCur->pData, pCur->nLength );
-                }
-                return ret;
-        }
-        else
-        {
-                String ret;
-                ret.append(
-                        iBegin.pChunk->pData+iBegin.iPos,
-                        iBegin.pChunk->nLength-iBegin.iPos
-                        );
-                for( Chunk *pCur = iBegin.pChunk->pNext;
-                         pCur != iEnd.pChunk; pCur = pCur->pNext )
-                {
-                        ret.append( pCur->pData, pCur->nLength );
-                }
-                ret.append(
-                        iEnd.pChunk->pData,
-                        iEnd.iPos
-                        );
-                return ret;
-        }
+        const_iterator iEnd ) const
+{
+    if( !iBegin.isValid() )
+        return String();
+    if( iBegin.pChunk == iEnd.pChunk )
+    {
+        return String( iBegin.pChunk->pData+iBegin.iPos,
+            iEnd.iPos-iBegin.iPos );
+    }
+    else if( !iEnd.isValid() )
+    {
+        String ret;
+        ret.append(
+            iBegin.pChunk->pData+iBegin.iPos,
+            iBegin.pChunk->nLength-iBegin.iPos
+            );
+        for( Chunk *pCur = iBegin.pChunk->pNext;
+             pCur; pCur = pCur->pNext )
+        {
+            ret.append( pCur->pData, pCur->nLength );
+        }
+        return ret;
+    }
+    else
+    {
+        String ret;
+        ret.append(
+            iBegin.pChunk->pData+iBegin.iPos,
+            iBegin.pChunk->nLength-iBegin.iPos
+            );
+        for( Chunk *pCur = iBegin.pChunk->pNext;
+             pCur != iEnd.pChunk; pCur = pCur->pNext )
+        {
+            ret.append( pCur->pData, pCur->nLength );
+        }
+        ret.append(
+            iEnd.pChunk->pData,
+            iEnd.iPos
+            );
+        return ret;
+    }
 }
 
 Bu::StringList Bu::String::split( const char c ) const
 {
-        Bu::StringList ret;
-        const_iterator l, r;
-        l = begin();
-        for(r=l; l;)
-        {
-                for( r = l; r && r != c; r++ ) { }
-                ret.append( String( l, r ) );
-                l = r;
-                l++;
-        }
-        return ret;
+    Bu::StringList ret;
+    const_iterator l, r;
+    l = begin();
+    for(r=l; l;)
+    {
+        for( r = l; r && r != c; r++ ) { }
+        ret.append( String( l, r ) );
+        l = r;
+        l++;
+    }
+    return ret;
 }
 
 Bu::String &Bu::String::operator+=( const char *pData )
 {
-        append( pData );
+    append( pData );
 
-        return (*this);
+    return (*this);
 }
 
 Bu::String &Bu::String::operator+=( const Bu::String &rSrc )
 {
-        append( rSrc );
+    append( rSrc );
 
-        return (*this);
+    return (*this);
 }
 
 Bu::String &Bu::String::operator+=( const Bu::String::const_iterator &i )
 {
-        append( i, i+1 );
+    append( i, i+1 );
 
-        return (*this);
+    return (*this);
 }
 
 Bu::String &Bu::String::operator+=( const char cData )
 {
-        if( core->pLast && core->pLast->nLength < nMinSize )
-        {
-                _hardCopy();
-                core->pLast->pData[core->pLast->nLength] = cData;
-                ++core->pLast->nLength; ++core->nLength;
-//              pLast->pData[pLast->nLength] = (char)0;
-        }
-        else
-        {
-                append( &cData, 1 );
-        }
-        //append( pData );
+    if( core->pLast && core->pLast->nLength < nMinSize )
+    {
+        _hardCopy();
+        core->pLast->pData[core->pLast->nLength] = cData;
+        ++core->pLast->nLength; ++core->nLength;
+//      pLast->pData[pLast->nLength] = (char)0;
+    }
+    else
+    {
+        append( &cData, 1 );
+    }
+    //append( pData );
 
-        return (*this);
+    return (*this);
 }
 
 Bu::String &Bu::String::operator=( const char *pData )
 {
-        set( pData );
+    set( pData );
 
-        return (*this);
+    return (*this);
 }
 
 Bu::String Bu::String::operator+( const Bu::String &rRight ) const
 {
-        String ret( *this );
-        ret.append( rRight );
-        return ret;
+    String ret( *this );
+    ret.append( rRight );
+    return ret;
 }
 
 Bu::String Bu::String::operator+( const char *pRight ) const
 {
-        String ret( *this );
-        ret.append( pRight );
-        return ret;
+    String ret( *this );
+    ret.append( pRight );
+    return ret;
 }
 
 Bu::String Bu::String::operator+( char *pRight ) const
 {
-        String ret( *this );
-        ret.append( pRight );
-        return ret;
+    String ret( *this );
+    ret.append( pRight );
+    return ret;
 }
 
 void Bu::String::set( const char *pData )
 {
-        clear();
-        append( pData );
+    clear();
+    append( pData );
 }
 
 void Bu::String::set( const char *pData, long nSize )
 {
-        clear();
-        append( pData, nSize );
+    clear();
+    append( pData, nSize );
 }
 
 void Bu::String::set( const char *pData, long nStart, long nSize )
 {
-        clear();
-        append( pData, nStart, nSize );
+    clear();
+    append( pData, nStart, nSize );
 }
 
 void Bu::String::set( const String &rData )
 {
-        clear();
-        append( rData );
+    clear();
+    append( rData );
 }
 
 void Bu::String::set( const String &rData, long nSize )
 {
-        clear();
-        append( rData, nSize );
+    clear();
+    append( rData, nSize );
 }
 
 void Bu::String::set( const String &rData, long nStart, long nSize )
 {
-        clear();
-        append( rData, nStart, nSize );
+    clear();
+    append( rData, nStart, nSize );
 }
 
 void Bu::String::set( const_iterator s )
 {
-        clear();
-        append( s );
+    clear();
+    append( s );
 }
 
 void Bu::String::set( const_iterator s, const_iterator e )
 {
-        clear();
-        append( s, e );
+    clear();
+    append( s, e );
 }
 
 void Bu::String::setSize( long iSize )
 {
-        _hardCopy();
-        core->clear();
-        core->appendChunk( core->newChunk( iSize ) );
+    _hardCopy();
+    core->clear();
+    core->appendChunk( core->newChunk( iSize ) );
 }
 
 bool Bu::String::operator==( const char *pData ) const
 {
-        if( core->pFirst == NULL || core->nLength == 0 ) {
-                if( pData == NULL )
-                        return true;
-                if( pData[0] == (char)0 )
-                        return true;
-                return false;
-        }
-
-        flatten();
-        core->pFirst->pData[core->nLength] = (char)0;
-        const char *a = pData;
-        char *b = core->pFirst->pData;
-        for( long j = 0; *a!=(char)0 || *b!=(char)0; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return false;
-                if( *a == (char)0 && j < core->nLength )
-                        return false;
-        }
-
-        return true;
+    if( core->pFirst == NULL || core->nLength == 0 ) {
+        if( pData == NULL )
+            return true;
+        if( pData[0] == (char)0 )
+            return true;
+        return false;
+    }
+
+    flatten();
+    core->pFirst->pData[core->nLength] = (char)0;
+    const char *a = pData;
+    char *b = core->pFirst->pData;
+    for( long j = 0; *a!=(char)0 || *b!=(char)0; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return false;
+        if( *a == (char)0 && j < core->nLength )
+            return false;
+    }
+
+    return true;
 }
 
 bool Bu::String::operator==( const String &pData ) const
 {
-        if( core == pData.core )
-                return true;
-        if( core->pFirst == pData.core->pFirst )
-                return true;
-        if( (core->nLength == 0 && pData.core->nLength == 0) ) 
-                return true;
-        if( core->nLength != pData.core->nLength )
-                return false;
-        if( pData.core->pFirst == NULL || core->pFirst == NULL )
-                return false;
-
-        flatten();
-        pData.flatten();
-        const char *a = pData.core->pFirst->pData;
-        char *b = core->pFirst->pData;
-        for( long j = 0; j < core->nLength; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return false;
-        }
-
-        return true;
+    if( core == pData.core )
+        return true;
+    if( core->pFirst == pData.core->pFirst )
+        return true;
+    if( (core->nLength == 0 && pData.core->nLength == 0) ) 
+        return true;
+    if( core->nLength != pData.core->nLength )
+        return false;
+    if( pData.core->pFirst == NULL || core->pFirst == NULL )
+        return false;
+
+    flatten();
+    pData.flatten();
+    const char *a = pData.core->pFirst->pData;
+    char *b = core->pFirst->pData;
+    for( long j = 0; j < core->nLength; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return false;
+    }
+
+    return true;
 }
 
 bool Bu::String::operator!=(const char *pData ) const
 {
-        return !(*this == pData);
+    return !(*this == pData);
 }
 
 bool Bu::String::operator!=(const String &pData ) const
 {
-        return !(*this == pData);
+    return !(*this == pData);
 }
 
 bool Bu::String::operator<(const String &pData ) const
 {
-        flatten();
-        pData.flatten();
+    flatten();
+    pData.flatten();
 
-        const char *a = core->pFirst->pData;
-        char *b = pData.core->pFirst->pData;
-        for( long j = 0; j < core->nLength; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return *a < *b;
-        }
+    const char *a = core->pFirst->pData;
+    char *b = pData.core->pFirst->pData;
+    for( long j = 0; j < core->nLength; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return *a < *b;
+    }
 
-        return false;
+    return false;
 }
 
 bool Bu::String::operator<=(const String &pData ) const
 {
-        flatten();
-        pData.flatten();
+    flatten();
+    pData.flatten();
 
-        const char *a = core->pFirst->pData;
-        char *b = pData.core->pFirst->pData;
-        for( long j = 0; j < core->nLength; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return *a < *b;
-        }
+    const char *a = core->pFirst->pData;
+    char *b = pData.core->pFirst->pData;
+    for( long j = 0; j < core->nLength; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return *a < *b;
+    }
 
-        return true;
+    return true;
 }
 
 bool Bu::String::operator>(const String &pData ) const
 {
-        flatten();
-        pData.flatten();
+    flatten();
+    pData.flatten();
 
-        const char *a = core->pFirst->pData;
-        char *b = pData.core->pFirst->pData;
-        for( long j = 0; j < core->nLength; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return *a > *b;
-        }
+    const char *a = core->pFirst->pData;
+    char *b = pData.core->pFirst->pData;
+    for( long j = 0; j < core->nLength; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return *a > *b;
+    }
 
-        return false;
+    return false;
 }
 
 bool Bu::String::operator>=(const String &pData ) const
 {
-        flatten();
-        pData.flatten();
+    flatten();
+    pData.flatten();
 
-        const char *a = core->pFirst->pData;
-        char *b = pData.core->pFirst->pData;
-        for( long j = 0; j < core->nLength; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return *a > *b;
-        }
+    const char *a = core->pFirst->pData;
+    char *b = pData.core->pFirst->pData;
+    for( long j = 0; j < core->nLength; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return *a > *b;
+    }
 
-        return true;
+    return true;
 }
 
 char &Bu::String::operator[]( long nIndex )
 {
-        if( nIndex < 0 || nIndex >= core->nLength )
-                throw Bu::ExceptionBase("Index out of range.");
-        flatten();
-        _hardCopy();
+    if( nIndex < 0 || nIndex >= core->nLength )
+        throw Bu::ExceptionBase("Index out of range.");
+    flatten();
+    _hardCopy();
 
-        return core->pFirst->pData[nIndex];
+    return core->pFirst->pData[nIndex];
 }
 
 const char &Bu::String::operator[]( long nIndex ) const
 {
-        if( nIndex < 0 || nIndex >= core->nLength )
-                throw Bu::ExceptionBase("Index out of range.");
-        flatten();
+    if( nIndex < 0 || nIndex >= core->nLength )
+        throw Bu::ExceptionBase("Index out of range.");
+    flatten();
 
-        return core->pFirst->pData[nIndex];
+    return core->pFirst->pData[nIndex];
 }
 
 bool Bu::String::isSet() const
 {
-        return (core->pFirst != NULL);
+    return (core->pFirst != NULL);
 }
 
 bool Bu::String::compareSub( const char *pData, long nIndex, long nLen ) const
 {
-        if( core->pFirst == NULL || core->nLength == 0 ) {
-                if( pData == NULL )
-                        return true;
-                if( nLen == 0 )
-                        return true;
-                if( pData[0] == (char)0 )
-                        return true;
-                return false;
-        }
-        if( nIndex+nLen > core->nLength )
-                return false;
-
-        flatten();
-        core->pFirst->pData[core->nLength] = (char)0;
-        const char *a = pData;
-        char *b = core->pFirst->pData+nIndex;
-        for( long j = 0; j < nLen; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return false;
-                if( *a == (char)0 && j < core->nLength )
-                        return false;
-        }
-
-        return true;
+    if( core->pFirst == NULL || core->nLength == 0 ) {
+        if( pData == NULL )
+            return true;
+        if( nLen == 0 )
+            return true;
+        if( pData[0] == (char)0 )
+            return true;
+        return false;
+    }
+    if( nIndex+nLen > core->nLength )
+        return false;
+
+    flatten();
+    core->pFirst->pData[core->nLength] = (char)0;
+    const char *a = pData;
+    char *b = core->pFirst->pData+nIndex;
+    for( long j = 0; j < nLen; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return false;
+        if( *a == (char)0 && j < core->nLength )
+            return false;
+    }
+
+    return true;
 }
 
 bool Bu::String::compareSub( const String &rData, long nIndex, long nLen ) const
 {
-        if( core->pFirst == NULL || core->nLength == 0 || rData.core->pFirst == NULL || rData.core->nLength == 0 ) 
-                return false;
-        if( nLen < 0 )
-                nLen = rData.core->nLength;
-        if( nIndex+nLen > core->nLength )
-                return false;
+    if( core->pFirst == NULL || core->nLength == 0 || rData.core->pFirst == NULL || rData.core->nLength == 0 ) 
+        return false;
+    if( nLen < 0 )
+        nLen = rData.core->nLength;
+    if( nIndex+nLen > core->nLength )
+        return false;
 
-        flatten();
-        rData.flatten();
-        const char *a = rData.core->pFirst->pData;
-        char *b = core->pFirst->pData + nIndex;
-        for( long j = 0; j < nLen; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return false;
-        }
+    flatten();
+    rData.flatten();
+    const char *a = rData.core->pFirst->pData;
+    char *b = core->pFirst->pData + nIndex;
+    for( long j = 0; j < nLen; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return false;
+    }
 
-        return true;
+    return true;
 }
 
 bool Bu::String::isWS( long nIndex ) const
 {
-        flatten();
+    flatten();
 
-        return core->pFirst->pData[nIndex]==' ' || core->pFirst->pData[nIndex]=='\t'
-                || core->pFirst->pData[nIndex]=='\r' || core->pFirst->pData[nIndex]=='\n';
+    return core->pFirst->pData[nIndex]==' ' || core->pFirst->pData[nIndex]=='\t'
+        || core->pFirst->pData[nIndex]=='\r' || core->pFirst->pData[nIndex]=='\n';
 }
 
 bool Bu::String::isAlpha( long nIndex ) const
 {
-        flatten();
+    flatten();
 
-        return (core->pFirst->pData[nIndex] >= 'a' && core->pFirst->pData[nIndex] <= 'z')
-                || (core->pFirst->pData[nIndex] >= 'A' && core->pFirst->pData[nIndex] <= 'Z');
+    return (core->pFirst->pData[nIndex] >= 'a' && core->pFirst->pData[nIndex] <= 'z')
+        || (core->pFirst->pData[nIndex] >= 'A' && core->pFirst->pData[nIndex] <= 'Z');
 }
 
 Bu::String Bu::String::toLower() const
 {
-        Bu::String sRet = *this;
+    Bu::String sRet = *this;
 
-        sRet.flatten();
-        sRet._hardCopy();
+    sRet.flatten();
+    sRet._hardCopy();
 
-        for( long j = 0; j < sRet.core->nLength; j++ )
-        {
-                if( sRet.core->pFirst->pData[j] >= 'A' &&
-                        sRet.core->pFirst->pData[j] <= 'Z' )
-                        sRet.core->pFirst->pData[j] -= 'A'-'a';
-        }
+    for( long j = 0; j < sRet.core->nLength; j++ )
+    {
+        if( sRet.core->pFirst->pData[j] >= 'A' &&
+            sRet.core->pFirst->pData[j] <= 'Z' )
+            sRet.core->pFirst->pData[j] -= 'A'-'a';
+    }
 
-        return sRet;
+    return sRet;
 }
 
 Bu::String Bu::String::toUpper() const
 {
-        Bu::String sRet = *this;
+    Bu::String sRet = *this;
 
-        sRet.flatten();
-        sRet._hardCopy();
+    sRet.flatten();
+    sRet._hardCopy();
 
-        for( long j = 0; j < sRet.core->nLength; j++ )
-        {
-                if( sRet.core->pFirst->pData[j] >= 'a' &&
-                        sRet.core->pFirst->pData[j] <= 'z' )
-                        sRet.core->pFirst->pData[j] += 'A'-'a';
-        }
-        
-        return sRet;
+    for( long j = 0; j < sRet.core->nLength; j++ )
+    {
+        if( sRet.core->pFirst->pData[j] >= 'a' &&
+            sRet.core->pFirst->pData[j] <= 'z' )
+            sRet.core->pFirst->pData[j] += 'A'-'a';
+    }
+    
+    return sRet;
 }
 
 Bu::String::const_iterator Bu::String::find( const char cChar,
-                Bu::String::const_iterator iStart ) const
+        Bu::String::const_iterator iStart ) const
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( cChar == *iStart )
-                        return iStart;
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( cChar == *iStart )
+            return iStart;
+    }
+    return end();
 }
 
 Bu::String::const_iterator Bu::String::find( const char *sText, int nLen,
-                Bu::String::const_iterator iStart ) const
+        Bu::String::const_iterator iStart ) const
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( sText, nLen ) )
-                        return iStart;
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( sText, nLen ) )
+            return iStart;
+    }
+    return end();
 }
 
 Bu::String::const_iterator Bu::String::find( const String &rStr,
-                Bu::String::const_iterator iStart ) const
+        Bu::String::const_iterator iStart ) const
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( rStr ) )
-                        return iStart;
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( rStr ) )
+            return iStart;
+    }
+    return end();
 }
 
 Bu::String::const_iterator Bu::String::find( const String &rStr, int nLen,
-                Bu::String::const_iterator iStart ) const
+        Bu::String::const_iterator iStart ) const
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( rStr, nLen ) )
-                        return iStart;
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( rStr, nLen ) )
+            return iStart;
+    }
+    return end();
 }
 
 Bu::String::iterator Bu::String::find( const char cChar,
-                Bu::String::const_iterator iStart )
+        Bu::String::const_iterator iStart )
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( cChar == *iStart )
-                        return iterator( iStart.pChunk, iStart.iPos );
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( cChar == *iStart )
+            return iterator( iStart.pChunk, iStart.iPos );
+    }
+    return end();
 }
 
 Bu::String::iterator Bu::String::find( const char *sText, int nLen,
-                Bu::String::const_iterator iStart )
+        Bu::String::const_iterator iStart )
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( sText, nLen ) )
-                        return iterator( iStart.pChunk, iStart.iPos );
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( sText, nLen ) )
+            return iterator( iStart.pChunk, iStart.iPos );
+    }
+    return end();
 }
 
 Bu::String::iterator Bu::String::find( const String &rStr,
-                Bu::String::const_iterator iStart )
+        Bu::String::const_iterator iStart )
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( rStr ) )
-                        return iterator( iStart.pChunk, iStart.iPos );
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( rStr ) )
+            return iterator( iStart.pChunk, iStart.iPos );
+    }
+    return end();
 }
 
 Bu::String::iterator Bu::String::find( const String &rStr, int nLen,
-                Bu::String::const_iterator iStart )
+        Bu::String::const_iterator iStart )
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( rStr, nLen ) )
-                        return iterator( iStart.pChunk, iStart.iPos );
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( rStr, nLen ) )
+            return iterator( iStart.pChunk, iStart.iPos );
+    }
+    return end();
 }
 
 long Bu::String::findIdx( const char cChar, long iStart ) const
 {
-        flatten();
-        for( long j = iStart; j < core->pFirst->nLength; j++ )
-        {
-                if( core->pFirst->pData[j] == cChar )
-                        return j;
-        }
-        return -1;
+    flatten();
+    for( long j = iStart; j < core->pFirst->nLength; j++ )
+    {
+        if( core->pFirst->pData[j] == cChar )
+            return j;
+    }
+    return -1;
 }
 
 long Bu::String::findIdx( const char *sText, long iStart ) const
 {
-        long nTLen = strlen( sText );
-        flatten();
-        for( long j = iStart; j < core->pFirst->nLength-nTLen; j++ )
-        {
-                if( !strncmp( sText, core->pFirst->pData+j, nTLen ) )
-                        return j;
-        }
-        return -1;
+    long nTLen = strlen( sText );
+    flatten();
+    for( long j = iStart; j < core->pFirst->nLength-nTLen; j++ )
+    {
+        if( !strncmp( sText, core->pFirst->pData+j, nTLen ) )
+            return j;
+    }
+    return -1;
 }
 
 long Bu::String::rfindIdx( const char *sText ) const
 {
-        long nTLen = strlen( sText );
-        flatten();
-        for( long j = core->pFirst->nLength-nTLen-1; j >= 0; j-- )
-        {
-                if( !strncmp( sText, core->pFirst->pData+j, nTLen ) )
-                        return j;
-        }
-        return -1;
+    long nTLen = strlen( sText );
+    flatten();
+    for( long j = core->pFirst->nLength-nTLen-1; j >= 0; j-- )
+    {
+        if( !strncmp( sText, core->pFirst->pData+j, nTLen ) )
+            return j;
+    }
+    return -1;
 }
 
 void Bu::String::trimFront( long nAmnt )
 {
-        long nNewLen = core->nLength - nAmnt;
-        flatten();
-        Chunk *pNew = core->newChunk( nNewLen );
-        memcpy( pNew->pData, core->pFirst->pData+nAmnt, nNewLen );
-        _hardCopy();
-        core->clear();
-        core->appendChunk( pNew );
+    long nNewLen = core->nLength - nAmnt;
+    flatten();
+    Chunk *pNew = core->newChunk( nNewLen );
+    memcpy( pNew->pData, core->pFirst->pData+nAmnt, nNewLen );
+    _hardCopy();
+    core->clear();
+    core->appendChunk( pNew );
 }
 /*
 void Bu::String::trimBack( char c )
 {
-        if( core->pFirst == NULL || core->nLength == 0 )
-                return;
-        flatten();
-        for( ; core->pFirst->nLength > 0 &&
-                core->pFirst->pData[core->pFirst->nLength-1] == c;
-                core->pFirst->nLength--, core->nLength-- ) { }
+    if( core->pFirst == NULL || core->nLength == 0 )
+        return;
+    flatten();
+    for( ; core->pFirst->nLength > 0 &&
+        core->pFirst->pData[core->pFirst->nLength-1] == c;
+        core->pFirst->nLength--, core->nLength-- ) { }
 }
 */
 void Bu::String::trimBack( long iAmnt )
 {
-        if( iAmnt < 0 )
-                return;
-        if( core->nLength - iAmnt < 0 )
-        {
-                clear();
-                return;
-        }
-        if( core->pFirst == NULL || core->nLength == 0 )
-                return;
+    if( iAmnt < 0 )
+        return;
+    if( core->nLength - iAmnt < 0 )
+    {
+        clear();
+        return;
+    }
+    if( core->pFirst == NULL || core->nLength == 0 )
+        return;
 
-        flatten();
-        core->pFirst->nLength -= iAmnt;
-        core->nLength -= iAmnt;
+    flatten();
+    core->pFirst->nLength -= iAmnt;
+    core->nLength -= iAmnt;
 }
 
 Bu::String Bu::String::trimWhitespace() const
 {
-        if( core->nLength == 0 )
-                return "";
-        const_iterator i = begin();
-        for( ; i && (*i == ' ' || *i == '\t' || *i == '\n' || *i == '\r'); i++ ) { }
-        if( !i )
-                return "";
-
-        const_iterator e = i;
-        for( ; e; e++ )
-        {
-                if( *e == ' ' || *e == '\t' || *e == '\n' || *e == '\r' )
-                {
-                        const_iterator t = e;
-                        for( ; t && (*t == ' ' || *t == '\t' || *t == '\n' || *t == '\r'); t++ ) { }
-                        if( t )
-                        {
-                                e = t;
-                        }
-                        else
-                        {
-                                break;
-                        }
-                }
-        }
-
-        return Bu::String( i, e );
+    if( core->nLength == 0 )
+        return "";
+    const_iterator i = begin();
+    for( ; i && (*i == ' ' || *i == '\t' || *i == '\n' || *i == '\r'); i++ ) { }
+    if( !i )
+        return "";
+
+    const_iterator e = i;
+    for( ; e; e++ )
+    {
+        if( *e == ' ' || *e == '\t' || *e == '\n' || *e == '\r' )
+        {
+            const_iterator t = e;
+            for( ; t && (*t == ' ' || *t == '\t' || *t == '\n' || *t == '\r'); t++ ) { }
+            if( t )
+            {
+                e = t;
+            }
+            else
+            {
+                break;
+            }
+        }
+    }
+
+    return Bu::String( i, e );
 }
 
 Bu::String::iterator Bu::String::begin()
 {
-        if( core->nLength == 0 )
-                return iterator( NULL, 0 );
-        return iterator( core->pFirst, 0 );
+    if( core->nLength == 0 )
+        return iterator( NULL, 0 );
+    return iterator( core->pFirst, 0 );
 }
 
 Bu::String::const_iterator Bu::String::begin() const
 {
-        if( core->nLength == 0 )
-                return const_iterator( NULL, 0 );
-        return iterator( core->pFirst, 0 );
+    if( core->nLength == 0 )
+        return const_iterator( NULL, 0 );
+    return iterator( core->pFirst, 0 );
 }
 
 Bu::String::iterator Bu::String::end()
 {
-        return iterator( NULL, 0 );
+    return iterator( NULL, 0 );
 }
 
 Bu::String::const_iterator Bu::String::end() const
 {
-        return const_iterator( NULL, 0 );
+    return const_iterator( NULL, 0 );
 }
 
 bool Bu::String::isEmpty() const
 {
-        if( core->nLength == 0 )
-                return true;
-        return false;
+    if( core->nLength == 0 )
+        return true;
+    return false;
 }
 
 void Bu::String::flatten() const
 {
-        if( isFlat() )
-                return;
+    if( isFlat() )
+        return;
 
-        if( core->pFirst == NULL || core->nLength == 0 )
-                return;
+    if( core->pFirst == NULL || core->nLength == 0 )
+        return;
 
-        Chunk *pNew = core->newChunk( core->nLength );
-        char *pos = pNew->pData;
-        Chunk *i = core->pFirst;
-        for(;;)
-        {
-                memcpy( pos, i->pData, i->nLength );
-                pos += i->nLength;
-                i = i->pNext;
-                if( i == NULL )
-                        break;
-        }
-        core->clear();
+    Chunk *pNew = core->newChunk( core->nLength );
+    char *pos = pNew->pData;
+    Chunk *i = core->pFirst;
+    for(;;)
+    {
+        memcpy( pos, i->pData, i->nLength );
+        pos += i->nLength;
+        i = i->pNext;
+        if( i == NULL )
+            break;
+    }
+    core->clear();
 
-        core->pLast = core->pFirst = pNew;
-        core->nLength = pNew->nLength;
+    core->pLast = core->pFirst = pNew;
+    core->nLength = pNew->nLength;
 }
 
 bool Bu::String::isFlat() const
 {
-        return (core->pFirst == core->pLast);
+    return (core->pFirst == core->pLast);
 }
 
 //
@@ -1229,98 +1229,98 @@ bool Bu::String::isFlat() const
 //
 
 Bu::String::FormatProxy::FormatProxy( const String &rFmt,
-                String::FormatProxyEndAction *pAct ) :
-        rFmt( rFmt ),
-        pAct( pAct ),
-        bOpen( true )
+        String::FormatProxyEndAction *pAct ) :
+    rFmt( rFmt ),
+    pAct( pAct ),
+    bOpen( true )
 {
 }
 
 Bu::String::FormatProxy::~FormatProxy()
 {
-        if( pAct && bOpen )
-                end();
+    if( pAct && bOpen )
+        end();
 
-        delete pAct;
+    delete pAct;
 }
 
 Bu::String Bu::String::FormatProxy::end() const
 {
-        int iCount = lArgs.getSize();
-        ArgList::const_iterator *aArg =
-                new ArgList::const_iterator[iCount];
-        {
-                int j = 0;
-                for( ArgList::const_iterator i = lArgs.begin();
-                         i; i++, j++ )
-                {
-                        aArg[j] = i;
-                }
-        }
-        Bu::MemBuf mbOut;
-        Bu::Formatter f( mbOut );
-        for( String::const_iterator s = rFmt.begin(); s; )
-        {
-                if( *s == '%' )
-                {
-                        s++;
-                        if( *s == '%' )
-                                f << *s;
-                        else
-                        {
-                                String sNum;
-                                if( *s == '{' )
-                                {
-                                        s++;
-                                        while( s && *s >= '0' && *s <= '9' )
-                                        {
-                                                sNum += *s;
-                                                s++;
-                                        }
-                                        if( !s || *s != '}' )
-                                        {
-                                                delete[] aArg;
-                                                throw Bu::ExceptionBase(
-                                                        "Argument started with a '{' but terminated "
-                                                        "with a '%c' instead of '}'.", *s );
-                                        }
-                                        s++;
-                                }
-                                else
-                                {
-                                        while( s && *s >= '0' && *s <= '9' )
-                                        {
-                                                sNum += *s;
-                                                s++;
-                                        }
-                                }
-                                int iIndex = strtol( sNum.getStr(), 0, 10 )-1;
-                                if( iIndex < 0 || iIndex >= iCount )
-                                {
-                                        delete[] aArg;
-                                        throw Bu::ExceptionBase(
-                                                "Argument index %d is outside of "
-                                                "valid range (1-%d).", iIndex+1, iCount
-                                                );
-                                }
+    int iCount = lArgs.getSize();
+    ArgList::const_iterator *aArg =
+        new ArgList::const_iterator[iCount];
+    {
+        int j = 0;
+        for( ArgList::const_iterator i = lArgs.begin();
+             i; i++, j++ )
+        {
+            aArg[j] = i;
+        }
+    }
+    Bu::MemBuf mbOut;
+    Bu::Formatter f( mbOut );
+    for( String::const_iterator s = rFmt.begin(); s; )
+    {
+        if( *s == '%' )
+        {
+            s++;
+            if( *s == '%' )
+                f << *s;
+            else
+            {
+                String sNum;
+                if( *s == '{' )
+                {
+                    s++;
+                    while( s && *s >= '0' && *s <= '9' )
+                    {
+                        sNum += *s;
+                        s++;
+                    }
+                    if( !s || *s != '}' )
+                    {
+                        delete[] aArg;
+                        throw Bu::ExceptionBase(
+                            "Argument started with a '{' but terminated "
+                            "with a '%c' instead of '}'.", *s );
+                    }
+                    s++;
+                }
+                else
+                {
+                    while( s && *s >= '0' && *s <= '9' )
+                    {
+                        sNum += *s;
+                        s++;
+                    }
+                }
+                int iIndex = strtol( sNum.getStr(), 0, 10 )-1;
+                if( iIndex < 0 || iIndex >= iCount )
+                {
+                    delete[] aArg;
+                    throw Bu::ExceptionBase(
+                        "Argument index %d is outside of "
+                        "valid range (1-%d).", iIndex+1, iCount
+                        );
+                }
 
-                                f << (*aArg[iIndex]).format << (*aArg[iIndex]).value;
-                                continue;
-                        }
-                }
-                else
-                {
-                        f << *s;
-                }
-                s++;
-        }
-        
-        bOpen = false;
-        delete[] aArg;
+                f << (*aArg[iIndex]).format << (*aArg[iIndex]).value;
+                continue;
+            }
+        }
+        else
+        {
+            f << *s;
+        }
+        s++;
+    }
+    
+    bOpen = false;
+    delete[] aArg;
 
-        if( pAct )
-                (*pAct)( mbOut.getString() );
-        return mbOut.getString();
+    if( pAct )
+        (*pAct)( mbOut.getString() );
+    return mbOut.getString();
 }
 
 
@@ -1371,131 +1371,131 @@ Bu::String Bu::String::FormatProxy::end() const
 
 template<> uint32_t Bu::__calcHashCode<Bu::String>( const Bu::String &k )
 {
-        long j, sz = k.getSize();
-        const char *s = k.getStr();
+    long j, sz = k.getSize();
+    const char *s = k.getStr();
 
-        long nPos = 0;
-        for( j = 0; j < sz; j++, s++ )
-        {
-                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
-        }
+    long nPos = 0;
+    for( j = 0; j < sz; j++, s++ )
+    {
+        nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+    }
 
-        return nPos;
+    return nPos;
 }
 
 template<> bool Bu::__cmpHashKeys<Bu::String>(
-                const Bu::String &a, const Bu::String &b )
+        const Bu::String &a, const Bu::String &b )
 {
-        return a == b;
+    return a == b;
 }
 
 template<> void Bu::__tracer_format<Bu::String>( const Bu::String &v )
 {
-        printf("(%ld)\"%s\"", v.getSize(), v.getStr() );
+    printf("(%ld)\"%s\"", v.getSize(), v.getStr() );
 }
 
 bool &Bu::operator<<( bool &dst, const Bu::String &sIn )
 {
-        if( sIn == "true" || sIn == "yes" || sIn == "t" )
-                dst = true;
-        else
-                dst = false;
+    if( sIn == "true" || sIn == "yes" || sIn == "t" )
+        dst = true;
+    else
+        dst = false;
 
-        return dst;
+    return dst;
 }
 
 uint8_t &Bu::operator<<( uint8_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%hhu", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%hhu", &dst );
+    return dst;
 }
 
 int8_t &Bu::operator<<( int8_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%hhd", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%hhd", &dst );
+    return dst;
 }
 
 char &Bu::operator<<( char &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%hhd", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%hhd", &dst );
+    return dst;
 }
 
 uint16_t &Bu::operator<<( uint16_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%hu", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%hu", &dst );
+    return dst;
 }
 
 int16_t &Bu::operator<<( int16_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%hd", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%hd", &dst );
+    return dst;
 }
 
 uint32_t &Bu::operator<<( uint32_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%u", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%u", &dst );
+    return dst;
 }
 
 int32_t &Bu::operator<<( int32_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%d", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%d", &dst );
+    return dst;
 }
 
 uint64_t &Bu::operator<<( uint64_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%llu", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%llu", &dst );
+    return dst;
 }
 
 int64_t &Bu::operator<<( int64_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%lld", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%lld", &dst );
+    return dst;
 }
 
 float &Bu::operator<<( float &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%f", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%f", &dst );
+    return dst;
 }
 
 double &Bu::operator<<( double &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%lf", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%lf", &dst );
+    return dst;
 }
 
 long double &Bu::operator<<( long double &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%Lf", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%Lf", &dst );
+    return dst;
 }
 
 Bu::String &Bu::operator<<( Bu::String &dst, const Bu::String &sIn )
 {
-        dst = sIn;
-        return dst;
+    dst = sIn;
+    return dst;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, const Bu::String &s )
 {
-        long n = s.getSize();
-        ar << n;
-        ar.write( s.getConstStr(), n );
-        return ar;
+    long n = s.getSize();
+    ar << n;
+    ar.write( s.getConstStr(), n );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, Bu::String &s )
 {
-        long n;
-        ar >> n;
-        s.setSize( n );
-        ar.read( s.getStr(), n );
-        return ar;
+    long n;
+    ar >> n;
+    s.setSize( n );
+    ar.read( s.getStr(), n );
+    return ar;
 }
 
diff --git a/src/stable/string.h b/src/stable/string.h
index 197821d..3be5bb9 100644
--- a/src/stable/string.h
+++ b/src/stable/string.h
@@ -22,1055 +22,1055 @@
 
 namespace Bu
 {
-        class String;
-        class MemBuf;
-
-        /** @cond DEVEL */
-        class StringCore
-        {
-        friend class String;
-        friend class SharedCore<String, StringCore>;
-        private:
-                struct Chunk
-                {
-                        long nLength;
-                        char *pData;
-                        Chunk *pNext;
-                };
-
-                StringCore();
-                StringCore( const StringCore &rSrc );
-                virtual ~StringCore();
-
-                mutable long nLength;
-                mutable Chunk *pFirst;
-                mutable Chunk *pLast;
-
-                void clear() const;
-                Chunk *newChunk() const;
-                Chunk *newChunk( long nLen ) const;
-                Chunk *copyChunk( Chunk *pSrc ) const;
-                void appendChunk( Chunk *pNewChunk );
-                void prependChunk( Chunk *pNewChunk );
-        };
-        /** @endcond */
-
-        /**
-         */
-        class String : public SharedCore<String, StringCore>
-        {
-        protected:
-                using SharedCore<String, StringCore >::core;
-                using SharedCore<String, StringCore >::_hardCopy;
-
-        private:
-                typedef StringCore::Chunk Chunk;
-
-        public: // Iterators
-                struct iterator;
-                typedef struct const_iterator
-                {
-                        friend class String;
-                        friend struct iterator;
-                private:
-                        const_iterator( Chunk *pChunk, int iPos ) :
-                                pChunk( pChunk ),
-                                iPos( iPos )
-                        {
-                        }
-
-                        Chunk *pChunk;
-                        int iPos;
-
-                public:
-                        const_iterator( const const_iterator &i ) :
-                                pChunk( i.pChunk ),
-                                iPos( i.iPos )
-                        {
-                        }
-                        
-                        const_iterator( const struct iterator &i ) :
-                                pChunk( i.pChunk ),
-                                iPos( i.iPos )
-                        {
-                        }
-
-                        const_iterator() :
-                                pChunk( NULL ),
-                                iPos( 0 )
-                        {
-                        }
-
-                        bool operator==( const const_iterator &i ) const
-                        {
-                                return pChunk == i.pChunk && iPos == i.iPos;
-                        }
-
-                        bool operator!=( const const_iterator &i ) const
-                        {
-                                return !(*this == i);
-                        }
-
-                        const_iterator &operator=( const const_iterator &i )
-                        {
-                                pChunk = i.pChunk;
-                                iPos = i.iPos;
-                                return *this;
-                        }
-                        
-                        const_iterator &operator=( const iterator &i )
-                        {
-                                pChunk = i.pChunk;
-                                iPos = i.iPos;
-                                return *this;
-                        }
-
-                        const_iterator &operator++()
-                        {
-                                if( !pChunk ) return *this;
-                                iPos++;
-                                if( iPos >= pChunk->nLength )
-                                {
-                                        iPos = 0;
-                                        pChunk = pChunk->pNext;
-                                }
-                                return *this;
-                        }
-
-                        const_iterator &operator++( int )
-                        {
-                                if( !pChunk ) return *this;
-                                iPos++;
-                                if( iPos >= pChunk->nLength )
-                                {
-                                        iPos = 0;
-                                        pChunk = pChunk->pNext;
-                                }
-                                return *this;
-                        }
-
-                        const_iterator &operator+=( int iAmnt )
-                        {
-                                if( !pChunk ) return *this;
-                                iPos += iAmnt;
-                                while( iPos >= pChunk->nLength )
-                                {
-                                        iPos -= pChunk->nLength;
-                                        pChunk = pChunk->pNext;
-                                        if( pChunk == NULL )
-                                                break;
-                                }
-                                return *this;
-                        }
-
-                        const_iterator operator+( int iAmnt ) const
-                        {
-                                if( !pChunk ) return *this;
-                                const_iterator ret( *this );
-                                ret += iAmnt;
-                                return ret;
-                        }
-
-                        const char &operator *() const
-                        {
-                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid const_iterator.");
-                                return pChunk->pData[iPos];
-                        }
-
-                        bool operator==( const char &c ) const
-                        {
-                                if( !pChunk ) return false;
-                                return pChunk->pData[iPos] == c;
-                        }
-
-                        bool operator!=( const char &c ) const
-                        {
-                                if( !pChunk ) return false;
-                                return pChunk->pData[iPos] != c;
-                        }
-                        
-                        operator bool() const
-                        {
-                                return pChunk != NULL;
-                        }
-
-                        bool isValid() const
-                        {
-                                return pChunk != NULL;
-                        }
-
-                        bool compare( const const_iterator &c ) const
-                        {
-                                const_iterator a = *this;
-                                const_iterator b = c;
-                                if( a == b )
-                                        return true;
-                                for(; a && b; a++, b++ )
-                                {
-                                        if( *a != *b )
-                                                return false;
-                                }
-                                if( (bool)a != (bool)b )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const const_iterator &c, int nLen ) const
-                        {
-                                const_iterator a = *this;
-                                const_iterator b = c;
-                                if( a == b )
-                                        return true;
-                                for(int j = 0; j < nLen; a++, b++, j++ )
-                                {
-                                        if( !a || !b || *a != *b )
-                                                return false;
-                                }
-                                return true;
-                        }
-
-                        bool compare( const char *c ) const
-                        {
-                                if( !pChunk ) return false;
-                                const_iterator a = *this;
-                                for(; a && *c; a++, c++ )
-                                {
-                                        if( *a != *c )
-                                                return false;
-                                }
-                                if( a.isValid() != (*c!=(char)0) )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const char *c, int nLen ) const
-                        {
-                                if( !pChunk ) return false;
-                                const_iterator a = *this;
-                                int j = 0;
-                                for(; a && j < nLen; a++, c++, j++ )
-                                {
-                                        if( *a != *c )
-                                                return false;
-                                }
-                                if( j < nLen )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const String &s ) const
-                        {
-                                if( !pChunk ) return false;
-                                return compare( s.begin() );
-                        }
-
-                        bool compare( const String &s, int nLen ) const
-                        {
-                                if( !pChunk ) return false;
-                                return compare( s.begin(), nLen );
-                        }
-
-                        const_iterator find( const char c ) const
-                        {
-                                for( const_iterator i = *this; i; i++ )
-                                {
-                                        if( *i == c )
-                                                return i;
-                                }
-                                return const_iterator( NULL, 0 );
-                        }
-
-                        const_iterator find( const char *pStr, int nLen ) const
-                        {
-                                for( const_iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( pStr, nLen ) )
-                                                return i;
-                                }
-                                return const_iterator( NULL, 0 );
-                        }
-
-                        const_iterator find( const String &s ) const
-                        {
-                                for( const_iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( s ) )
-                                                return i;
-                                }
-                                return const_iterator( NULL, 0 );
-                        }
-
-                        const_iterator find( const String &s, int nLen ) const
-                        {
-                                for( const_iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( s, nLen ) )
-                                                return i;
-                                }
-                                return const_iterator( NULL, 0 );
-                        }
-                } const_iterator;
-                
-                typedef struct iterator
-                {
-                        friend class String;
-                        friend struct const_iterator;
-                private:
-                        iterator( Chunk *pChunk, int iPos ) :
-                                pChunk( pChunk ),
-                                iPos( iPos )
-                        {
-                        }
-
-                        Chunk *pChunk;
-                        int iPos;
-
-                public:
-                        iterator( const iterator &i ) :
-                                pChunk( i.pChunk ),
-                                iPos( i.iPos )
-                        {
-                        }
-
-                        iterator() :
-                                pChunk( NULL ),
-                                iPos( 0 )
-                        {
-                        }
-
-                        operator const_iterator() const
-                        {
-                                return const_iterator( pChunk, iPos );
-                        }
-
-                        bool operator==( const iterator &i ) const
-                        {
-                                return pChunk == i.pChunk && iPos == i.iPos;
-                        }
-
-                        bool operator!=( const iterator &i ) const
-                        {
-                                return !(*this == i);
-                        }
-
-                        iterator &operator=( const iterator &i )
-                        {
-                                pChunk = i.pChunk;
-                                iPos = i.iPos;
-                                return *this;
-                        }
-
-                        iterator &operator++()
-                        {
-                                if( !pChunk ) return *this;
-                                iPos++;
-                                if( iPos >= pChunk->nLength )
-                                {
-                                        iPos = 0;
-                                        pChunk = pChunk->pNext;
-                                }
-                                return *this;
-                        }
-
-                        iterator &operator++( int )
-                        {
-                                if( !pChunk ) return *this;
-                                iPos++;
-                                if( iPos >= pChunk->nLength )
-                                {
-                                        iPos = 0;
-                                        pChunk = pChunk->pNext;
-                                }
-                                return *this;
-                        }
-
-                        iterator &operator+=( int iAmnt )
-                        {
-                                if( !pChunk ) return *this;
-                                iPos += iAmnt;
-                                while( iPos >= pChunk->nLength )
-                                {
-                                        iPos -= pChunk->nLength;
-                                        pChunk = pChunk->pNext;
-                                        if( pChunk == NULL )
-                                                break;
-                                }
-                                return *this;
-                        }
-
-                        iterator operator+( int iAmnt ) const
-                        {
-                                if( !pChunk ) return *this;
-                                iterator ret( *this );
-                                ret += iAmnt;
-                                return ret;
-                        }
-
-                        char &operator*()
-                        {
-                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
-                                return pChunk->pData[iPos];
-                        }
-
-                        const char &operator*() const
-                        {
-                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
-                                return pChunk->pData[iPos];
-                        }
-
-                        bool operator==( const char &c ) const
-                        {
-                                if( !pChunk ) return false;
-                                return pChunk->pData[iPos] == c;
-                        }
-
-                        bool operator!=( const char &c ) const
-                        {
-                                if( !pChunk ) return false;
-                                return pChunk->pData[iPos] != c;
-                        }
-
-                        iterator &operator=( const char &c )
-                        {
-                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
-                                pChunk->pData[iPos] = c;
-                                return *this;
-                        }
-
-                        operator bool() const
-                        {
-                                return pChunk != NULL;
-                        }
-
-                        bool isValid() const
-                        {
-                                return pChunk != NULL;
-                        }
-
-                        bool compare( const const_iterator &c ) const
-                        {
-                                const_iterator a( *this );
-                                const_iterator b = c;
-                                if( a == b )
-                                        return true;
-                                for(; a && b; a++, b++ )
-                                {
-                                        if( *a != *b )
-                                                return false;
-                                }
-                                if( (bool)a != (bool)b )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const const_iterator &c, int nLen ) const
-                        {
-                                const_iterator a( *this );
-                                const_iterator b = c;
-                                if( a == b )
-                                        return true;
-                                for(int j = 0; j < nLen; a++, b++, j++ )
-                                {
-                                        if( !a || !b || *a != *b )
-                                                return false;
-                                }
-                                return true;
-                        }
-
-                        bool compare( const char *c ) const
-                        {
-                                if( !pChunk ) return false;
-                                iterator a = *this;
-                                for(; a && *c; a++, c++ )
-                                {
-                                        if( *a != *c )
-                                                return false;
-                                }
-                                if( a.isValid() != (*c!=(char)0) )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const char *c, int nLen ) const
-                        {
-                                if( !pChunk ) return false;
-                                iterator a = *this;
-                                int j = 0;
-                                for(; a && j < nLen; a++, c++, j++ )
-                                {
-                                        if( *a != *c )
-                                                return false;
-                                }
-                                if( j < nLen )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const String &s ) const
-                        {
-                                if( !pChunk ) return false;
-                                return compare( s.begin() );
-                        }
-
-                        bool compare( const String &s, int nLen ) const
-                        {
-                                if( !pChunk ) return false;
-                                return compare( s.begin(), nLen );
-                        }
-
-                        iterator find( const char c ) const
-                        {
-                                for( iterator i = *this; i; i++ )
-                                {
-                                        if( *i == c )
-                                                return i;
-                                }
-                                return iterator( NULL, 0 );
-                        }
-
-                        iterator find( const char *pStr, int nLen ) const
-                        {
-                                for( iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( pStr, nLen ) )
-                                                return i;
-                                }
-                                return iterator( NULL, 0 );
-                        }
-
-                        iterator find( const String &s ) const
-                        {
-                                for( iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( s ) )
-                                                return i;
-                                }
-                                return iterator( NULL, 0 );
-                        }
-
-                        iterator find( const String &s, int nLen ) const
-                        {
-                                for( iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( s, nLen ) )
-                                                return i;
-                                }
-                                return iterator( NULL, 0 );
-                        }
-                } iterator;
-
-        public:
-                String();
-                String( const char *pData );
-                String( const char *pData, long nLength );
-                String( const String &rSrc );
-                String( const String &rSrc, long nLength );
-                String( const String &rSrc, long nStart, long nLength );
-                String( long nSize );
-                String( const const_iterator &s );
-                String( const const_iterator &s, const const_iterator &e );
-                virtual ~String();
-
-                /**
-                 * Append data to your string.
-                 *@param pData (const char *) The data to append.
-                 */
-                void append( const char *pData );
-
-                /**
-                 * Append data to your string.
-                 *@param pData (const char *) The data to append.
-                 *@param nLen (long) The length of the data to append.
-                 */
-                void append( const char *pData, long nLen );
-                
-                /**
-                 * Append data to your string.
-                 *@param pData (const char *) The data to append.
-                 *@param nStart (long) The start position to copy from.
-                 *@param nLen (long) The length of the data to append.
-                 */
-                void append( const char *pData, long nStart, long nLen );
-
-                /**
-                 * Append a single char to your string.
-                 *@param cData (const char &) The character to append.
-                 */
-                void append( const char &cData );
-
-                /**
-                 * Append another String to this one.
-                 *@param sData (String &) The String to append.
-                 *@todo This function can be made much faster by not using getStr()
-                 */
-                void append( const String & sData );
-                
-                /**
-                 * Append another String to this one.
-                 *@param sData (String &) The String to append.
-                 *@param nLen How much data to append.
-                 *@todo This function can be made much faster by not using getStr()
-                 */
-                void append( const String & sData, long nLen );
-                
-                /**
-                 * Append another String to this one.
-                 *@param sData (String &) The String to append.
-                 *@param nStart Start position in sData to start copying from.
-                 *@param nLen How much data to append.
-                 *@todo This function can be made much faster by not using getStr()
-                 */
-                void append( const String & sData, long nStart, long nLen );
-                
-                /**
-                 * Append data to this String using the passed in iterator as a base.
-                 * The iterator is const, it is not changed.
-                 *@param s Iterator from any compatible String to copy data from.
-                 */
-                void append( const const_iterator &s );
-
-                /**
-                 * Append data to this String using the passed in iterator as a base.
-                 * The iterator is const, it is not changed.
-                 *@param s Iterator from any compatible String to copy data from.
-                 */
-                void append( const iterator &s );
-
-                /**
-                 * Append data to this String using the passed in iterator as a base,
-                 * and copy data until the ending iterator is reached.  The character
-                 * at the ending iterator is not copied.
-                 * The iterators are const, they are not changed.
-                 *@param s Iterator from any compatible String to copy data from.
-                 *@param e Iterator to stop copying at.
-                 */
-                void append( const const_iterator &s, const const_iterator &e );
-                
-                /**
-                 * Prepend another String to this one.
-                 *@param sData (String &) The String to prepend.
-                 *@todo This function can be made much faster by not using getStr()
-                 */
-                void prepend( const String & sData );
-
-                /**
-                 * Prepend data to your string.
-                 *@param pData (const char *) The data to prepend.
-                 */
-                void prepend( const char *pData );
-
-                /**
-                 * Prepend data to your string.
-                 *@param pData (const char *) The data to prepend.
-                 *@param nLen (long) The length of the data to prepend.
-                 */
-                void prepend( const char *pData, long nLen );
-
-                void prepend( const char c );
-
-                /**
-                 * Insert pData before byte nPos, that is, the first byte of pData will
-                 * start at nPos.  This could probably be made faster by avoiding
-                 * flattening.
-                 */
-                void insert( long nPos, const char *pData, long nLen );
-
-                void insert( long nPos, const String &str );
-
-                /**
-                 *@todo This function shouldn't use strlen, we should add our own to
-                 * this class, one that can be overridden in a specific implementation.
-                 */
-                void insert( long nPos, const char *pData );
-
-                void remove( long nPos, long nLen );
-
-                /**
-                 * Clear all data from the string.
-                 */
-                void clear();
-
-                String replace( const String &fnd, const String &rep ) const;
-
-                /**
-                 * Force the string to resize
-                 *@param nNewSize (long) The new size of the string.
-                 */
-                void resize( long nNewSize );
-
-                /**
-                 * Get the current size of the string.
-                 *@returns (long) The current size of the string.
-                 */
-                long getSize() const;
-                
-                /**
-                 * Get a pointer to the string array.
-                 *@returns (char *) The string data.
-                 */
-                char *getStr();
-                
-                /**
-                 * Get a const pointer to the string array.
-                 *@returns (const char *) The string data.
-                 */
-                const char *getStr() const;
-
-                /**
-                 * A convinience function, this one won't cause as much work as the
-                 * non-const getStr, so if you're not changing the data, consider it.
-                 */
-                const char *getConstStr() const;
-
-                String getSubStrIdx( long iStart, long iSize=-1 ) const;
-
-                String getSubStr( const_iterator iBegin,
-                                const_iterator iEnd=String::const_iterator() ) const;
-
-                Bu::List<String> split( const char c ) const;
-
-                /**
-                 * Plus equals operator for String.
-                 *@param pData (const char *) The data to append to your String.
-                 */
-                String &operator+=( const char *pData );
-                
-                /**
-                 * Plus equals operator for String.
-                 *@param rSrc (const String &) The String to append to your String.
-                 */
-                String &operator+=( const String &rSrc );
-
-                String &operator+=( const String::const_iterator &i );
-
-                /**
-                 * Plus equals operator for String.
-                 *@param cData (const char) The character to append to your String.
-                 */
-                String &operator+=( const char cData );
-
-                /**
-                 * Assignment operator.
-                 *@param pData (const char *) The character array to append to your
-                 *              String.
-                 */
-                String &operator=( const char *pData );
-
-                String operator+( const String &rRight ) const;
-
-                String operator+( const char *pRight ) const;
-
-                String operator+( char *pRight ) const;
-
-                /**
-                 * Reset your String to this character array.
-                 *@param pData (const char *) The character array to set your String to.
-                 */
-                void set( const char *pData );
-
-                /**
-                 * Reset your String to this character array.
-                 *@param pData (const char *) The character array to set your String to.
-                 *@param nSize (long) The length of the inputted character array.
-                 */
-                void set( const char *pData, long nSize );
-
-                void set( const char *pData, long nStart, long nSize );
-                
-                void set( const String &rData );
-
-                void set( const String &rData, long nSize );
-
-                void set( const String &rData, long nStart, long nSize );
-
-                void set( const_iterator s );
-
-                void set( const_iterator s, const_iterator e );
-
-                /**
-                 * Resize the string, possibly to make room for a copy.  At the moment
-                 * this operation *is* destructive.  What was in the string will in no
-                 * way be preserved.  This is, however, very fast.  If you want to
-                 * keep your data check out resize.
-                 *@param iSize the new size in bytes.  The string is guranteed to have
-                 * at least this much contiguous space available when done.
-                 */
-                void setSize( long iSize );
-
-                /**
-                 * Equals comparison operator.
-                 *@param pData (const char *) The character array to compare your String
-                 *              to.
-                 */
-                bool operator==( const char *pData ) const;
-                
-                /**
-                 * Equals comparison operator.
-                 *@param pData (const String &) The String to compare your String to.
-                 */
-                bool operator==( const String &pData ) const;
-
-                /**
-                 * Not equals comparison operator.
-                 *@param pData (const char *) The character array to compare your String
-                 *              to.
-                 */
-                bool operator!=(const char *pData ) const;
-                
-                /**
-                 * Not equals comparison operator.
-                 *@param pData (const String &) The String to compare your String to.
-                 */
-                bool operator!=(const String &pData ) const;
-
-                bool operator<(const String &pData ) const;
-                
-                bool operator<=(const String &pData ) const;
-
-                bool operator>(const String &pData ) const;
-
-                bool operator>=(const String &pData ) const;
-
-                /**
-                 * Indexing operator
-                 *@param nIndex (long) The index of the character you want.
-                 *@returns (char &) The character at position (nIndex).
-                 */
-                char &operator[]( long nIndex );
-                
-                /**
-                 * Const indexing operator
-                 *@param nIndex (long) The index of the character you want.
-                 *@returns (const char &) The character at position (nIndex).
-                 */
-                const char &operator[]( long nIndex ) const;
-
-                bool isSet() const;
-
-                bool compareSub( const char *pData, long nIndex, long nLen ) const;
-
-                bool compareSub( const String &rData, long nIndex, long nLen ) const;
-                
-                /**
-                 * Is the character at index (nIndex) white space?
-                 *@param nIndex (long) The index of the character you want to check.
-                 *@returns (bool) Is it white space?
-                 */
-                bool isWS( long nIndex ) const;
-
-                /**
-                 * Is the character at index (nIndex) a letter?
-                 *@param nIndex (long) The index of the character you want to check.
-                 *@returns (bool) Is it a letter?
-                 */
-                bool isAlpha( long nIndex ) const;
-
-                /**
-                 * Convert your alpha characters to lower case.
-                 */
-                String toLower() const;
-
-                /**
-                 * Convert your alpha characters to upper case.
-                 */
-                String toUpper() const;
-
-                const_iterator find( const char cChar,
-                                const_iterator iStart=const_iterator() ) const;
-
-                const_iterator find( const char *sText, int nLen,
-                                const_iterator iStart=const_iterator() ) const;
-
-                const_iterator find( const String &rStr,
-                                const_iterator iStart=const_iterator() ) const;
-
-                const_iterator find( const String &rStr, int nLen,
-                                const_iterator iStart=const_iterator() ) const;
-
-                iterator find( const char cChar,
-                                const_iterator iStart=const_iterator() );
-
-                iterator find( const char *sText, int nLen,
-                                const_iterator iStart=const_iterator() );
-
-                iterator find( const String &rStr,
-                                const_iterator iStart=const_iterator() );
-
-                iterator find( const String &rStr, int nLen,
-                                const_iterator iStart=const_iterator() );
-
-                /**
-                 * Find the index of the first occurrance of cChar
-                 *@param cChar The character to search for.
-                 *@param iStart The position in the string to start searching from.
-                 *@returns (long) The index of the first occurrance. -1 for not found.
-                 */
-                long findIdx( const char cChar, long iStart=0 ) const;
-                
-                /**
-                 * Find the index of the first occurrance of sText
-                 *@param sText The null-terminated string to search for.
-                 *@param iStart The position in the string to start searching from.
-                 *@returns The index of the first occurrance. -1 for not found.
-                 */
-                long findIdx( const char *sText, long iStart=0 ) const;
-
-                /**
-                 * Do a reverse search for (sText)
-                 *@param sText (const char *) The string to search for.
-                 *@returns (long) The index of the last occurrance. -1 for not found.
-                 */
-                long rfindIdx( const char *sText ) const;
-
-                /**
-                 * Remove nAmnt bytes from the front of the string.  This function
-                 * operates in O(n) time and should be used sparingly.
-                 */
-                void trimFront( long nAmnt );
-
-                void trimBack( long iAmnt );
-
-                Bu::String trimWhitespace() const;
-                
-                iterator begin();
-
-                const_iterator begin() const;
-
-                iterator end();
-
-                const_iterator end() const;
-
-                bool isEmpty() const;
-
-        private:
-                void flatten() const;
-                bool isFlat() const;
-
-        public:
-                class FormatProxyEndAction
-                {
-                public:
-                        virtual ~FormatProxyEndAction() { };
-                        virtual void operator()( const Bu::String &sFinal )=0;
-                };
-
-                class FormatProxy
-                {
-                friend class Bu::String;
-                private:
-                        FormatProxy( const String &rFmt, FormatProxyEndAction *pAct=NULL );
-
-                public:
-                        virtual ~FormatProxy();
-                        template<typename T>
-                        FormatProxy &arg( const T &x )
-                        {
-                                lArgs.append( Arg( x ) );
-
-                                return *this;
-                        }
-
-                        template<typename T>
-                        FormatProxy &arg( const T &x, const Bu::Fmt &f )
-                        {
-                                lArgs.append( Arg( x, f ) );
-
-                                return *this;
-                        }
-
-                        String end() const;
-                        operator String() const { return end(); }
-
-                private:
-                        const String &rFmt;
-                        class Arg
-                        {
-                        public:
-                                template<typename T>
-                                Arg( const T &v ) :
-                                        value( v )
-                                {
-                                }
-
-                                template<typename T>
-                                Arg( const T &v, const Bu::Fmt &f ) :
-                                        value( v ),
-                                        format( f )
-                                {
-                                }
-
-                                Bu::Variant value;
-                                Bu::Fmt format;
-                        };
-                        typedef Bu::List<Arg> ArgList;
-                        ArgList lArgs;
-                        FormatProxyEndAction *pAct;
-                        mutable bool bOpen;
-                };
-
-        public:
-                template<typename ArgType>
-                FormatProxy arg( const ArgType &x ) const
-                {
-                        return FormatProxy( *this ).arg( x );
-                }
-
-                template<typename ArgType>
-                FormatProxy arg( const ArgType &x, const Bu::Fmt &f ) const
-                {
-                        return FormatProxy( *this ).arg( x, f );
-                }
-                
-                FormatProxy format() const
-                {
-                        return FormatProxy( *this );
-                }
-
-                FormatProxy format( FormatProxyEndAction *pEndAction ) const
-                {
-                        return FormatProxy( *this, pEndAction );
-                }
-        };
-        
-        template<class T> String operator+( const T *pLeft, const String &rRight )
-        {
-                Bu::String ret( pLeft );
-                ret.append( rRight );
-                return ret;
-        }
-
-        ArchiveBase &operator<<( ArchiveBase &ar, const String &s );
-        ArchiveBase &operator>>( ArchiveBase &ar, String &s );
-
-        template<typename T>
-        uint32_t __calcHashCode( const T &k );
-
-        template<typename T>
-        bool __cmpHashKeys( const T &a, const T &b );
-
-        template<> uint32_t __calcHashCode<String>( const String &k );
-        template<> bool __cmpHashKeys<String>(
-                const String &a, const String &b );
-        
-        template<typename t> void __tracer_format( const t &v );
-        template<> void __tracer_format<String>( const String &v );
-
-        bool &operator<<( bool &dst, const String &sIn );
-        uint8_t &operator<<( uint8_t &dst, const String &sIn );
-        int8_t &operator<<( int8_t &dst, const String &sIn );
-        char &operator<<( char &dst, const String &sIn );
-        uint16_t &operator<<( uint16_t &dst, const String &sIn );
-        int16_t &operator<<( int16_t &dst, const String &sIn );
-        uint32_t &operator<<( uint32_t &dst, const String &sIn );
-        int32_t &operator<<( int32_t &dst, const String &sIn );
-        uint64_t &operator<<( uint64_t &dst, const String &sIn );
-        int64_t &operator<<( int64_t &dst, const String &sIn );
-        float &operator<<( float &dst, const String &sIn );
-        double &operator<<( double &dst, const String &sIn );
-        long double &operator<<( long double &dst, const String &sIn );
-        Bu::String &operator<<( Bu::String &dst, const String &sIn );
-
-        typedef Bu::List<String> StringList;
+    class String;
+    class MemBuf;
+
+    /** @cond DEVEL */
+    class StringCore
+    {
+    friend class String;
+    friend class SharedCore<String, StringCore>;
+    private:
+        struct Chunk
+        {
+            long nLength;
+            char *pData;
+            Chunk *pNext;
+        };
+
+        StringCore();
+        StringCore( const StringCore &rSrc );
+        virtual ~StringCore();
+
+        mutable long nLength;
+        mutable Chunk *pFirst;
+        mutable Chunk *pLast;
+
+        void clear() const;
+        Chunk *newChunk() const;
+        Chunk *newChunk( long nLen ) const;
+        Chunk *copyChunk( Chunk *pSrc ) const;
+        void appendChunk( Chunk *pNewChunk );
+        void prependChunk( Chunk *pNewChunk );
+    };
+    /** @endcond */
+
+    /**
+     */
+    class String : public SharedCore<String, StringCore>
+    {
+    protected:
+        using SharedCore<String, StringCore >::core;
+        using SharedCore<String, StringCore >::_hardCopy;
+
+    private:
+        typedef StringCore::Chunk Chunk;
+
+    public: // Iterators
+        struct iterator;
+        typedef struct const_iterator
+        {
+            friend class String;
+            friend struct iterator;
+        private:
+            const_iterator( Chunk *pChunk, int iPos ) :
+                pChunk( pChunk ),
+                iPos( iPos )
+            {
+            }
+
+            Chunk *pChunk;
+            int iPos;
+
+        public:
+            const_iterator( const const_iterator &i ) :
+                pChunk( i.pChunk ),
+                iPos( i.iPos )
+            {
+            }
+            
+            const_iterator( const struct iterator &i ) :
+                pChunk( i.pChunk ),
+                iPos( i.iPos )
+            {
+            }
+
+            const_iterator() :
+                pChunk( NULL ),
+                iPos( 0 )
+            {
+            }
+
+            bool operator==( const const_iterator &i ) const
+            {
+                return pChunk == i.pChunk && iPos == i.iPos;
+            }
+
+            bool operator!=( const const_iterator &i ) const
+            {
+                return !(*this == i);
+            }
+
+            const_iterator &operator=( const const_iterator &i )
+            {
+                pChunk = i.pChunk;
+                iPos = i.iPos;
+                return *this;
+            }
+            
+            const_iterator &operator=( const iterator &i )
+            {
+                pChunk = i.pChunk;
+                iPos = i.iPos;
+                return *this;
+            }
+
+            const_iterator &operator++()
+            {
+                if( !pChunk ) return *this;
+                iPos++;
+                if( iPos >= pChunk->nLength )
+                {
+                    iPos = 0;
+                    pChunk = pChunk->pNext;
+                }
+                return *this;
+            }
+
+            const_iterator &operator++( int )
+            {
+                if( !pChunk ) return *this;
+                iPos++;
+                if( iPos >= pChunk->nLength )
+                {
+                    iPos = 0;
+                    pChunk = pChunk->pNext;
+                }
+                return *this;
+            }
+
+            const_iterator &operator+=( int iAmnt )
+            {
+                if( !pChunk ) return *this;
+                iPos += iAmnt;
+                while( iPos >= pChunk->nLength )
+                {
+                    iPos -= pChunk->nLength;
+                    pChunk = pChunk->pNext;
+                    if( pChunk == NULL )
+                        break;
+                }
+                return *this;
+            }
+
+            const_iterator operator+( int iAmnt ) const
+            {
+                if( !pChunk ) return *this;
+                const_iterator ret( *this );
+                ret += iAmnt;
+                return ret;
+            }
+
+            const char &operator *() const
+            {
+                if( !pChunk ) throw Bu::ExceptionBase("Not a valid const_iterator.");
+                return pChunk->pData[iPos];
+            }
+
+            bool operator==( const char &c ) const
+            {
+                if( !pChunk ) return false;
+                return pChunk->pData[iPos] == c;
+            }
+
+            bool operator!=( const char &c ) const
+            {
+                if( !pChunk ) return false;
+                return pChunk->pData[iPos] != c;
+            }
+            
+            operator bool() const
+            {
+                return pChunk != NULL;
+            }
+
+            bool isValid() const
+            {
+                return pChunk != NULL;
+            }
+
+            bool compare( const const_iterator &c ) const
+            {
+                const_iterator a = *this;
+                const_iterator b = c;
+                if( a == b )
+                    return true;
+                for(; a && b; a++, b++ )
+                {
+                    if( *a != *b )
+                        return false;
+                }
+                if( (bool)a != (bool)b )
+                    return false;
+                return true;
+            }
+
+            bool compare( const const_iterator &c, int nLen ) const
+            {
+                const_iterator a = *this;
+                const_iterator b = c;
+                if( a == b )
+                    return true;
+                for(int j = 0; j < nLen; a++, b++, j++ )
+                {
+                    if( !a || !b || *a != *b )
+                        return false;
+                }
+                return true;
+            }
+
+            bool compare( const char *c ) const
+            {
+                if( !pChunk ) return false;
+                const_iterator a = *this;
+                for(; a && *c; a++, c++ )
+                {
+                    if( *a != *c )
+                        return false;
+                }
+                if( a.isValid() != (*c!=(char)0) )
+                    return false;
+                return true;
+            }
+
+            bool compare( const char *c, int nLen ) const
+            {
+                if( !pChunk ) return false;
+                const_iterator a = *this;
+                int j = 0;
+                for(; a && j < nLen; a++, c++, j++ )
+                {
+                    if( *a != *c )
+                        return false;
+                }
+                if( j < nLen )
+                    return false;
+                return true;
+            }
+
+            bool compare( const String &s ) const
+            {
+                if( !pChunk ) return false;
+                return compare( s.begin() );
+            }
+
+            bool compare( const String &s, int nLen ) const
+            {
+                if( !pChunk ) return false;
+                return compare( s.begin(), nLen );
+            }
+
+            const_iterator find( const char c ) const
+            {
+                for( const_iterator i = *this; i; i++ )
+                {
+                    if( *i == c )
+                        return i;
+                }
+                return const_iterator( NULL, 0 );
+            }
+
+            const_iterator find( const char *pStr, int nLen ) const
+            {
+                for( const_iterator i = *this; i; i++ )
+                {
+                    if( i.compare( pStr, nLen ) )
+                        return i;
+                }
+                return const_iterator( NULL, 0 );
+            }
+
+            const_iterator find( const String &s ) const
+            {
+                for( const_iterator i = *this; i; i++ )
+                {
+                    if( i.compare( s ) )
+                        return i;
+                }
+                return const_iterator( NULL, 0 );
+            }
+
+            const_iterator find( const String &s, int nLen ) const
+            {
+                for( const_iterator i = *this; i; i++ )
+                {
+                    if( i.compare( s, nLen ) )
+                        return i;
+                }
+                return const_iterator( NULL, 0 );
+            }
+        } const_iterator;
+        
+        typedef struct iterator
+        {
+            friend class String;
+            friend struct const_iterator;
+        private:
+            iterator( Chunk *pChunk, int iPos ) :
+                pChunk( pChunk ),
+                iPos( iPos )
+            {
+            }
+
+            Chunk *pChunk;
+            int iPos;
+
+        public:
+            iterator( const iterator &i ) :
+                pChunk( i.pChunk ),
+                iPos( i.iPos )
+            {
+            }
+
+            iterator() :
+                pChunk( NULL ),
+                iPos( 0 )
+            {
+            }
+
+            operator const_iterator() const
+            {
+                return const_iterator( pChunk, iPos );
+            }
+
+            bool operator==( const iterator &i ) const
+            {
+                return pChunk == i.pChunk && iPos == i.iPos;
+            }
+
+            bool operator!=( const iterator &i ) const
+            {
+                return !(*this == i);
+            }
+
+            iterator &operator=( const iterator &i )
+            {
+                pChunk = i.pChunk;
+                iPos = i.iPos;
+                return *this;
+            }
+
+            iterator &operator++()
+            {
+                if( !pChunk ) return *this;
+                iPos++;
+                if( iPos >= pChunk->nLength )
+                {
+                    iPos = 0;
+                    pChunk = pChunk->pNext;
+                }
+                return *this;
+            }
+
+            iterator &operator++( int )
+            {
+                if( !pChunk ) return *this;
+                iPos++;
+                if( iPos >= pChunk->nLength )
+                {
+                    iPos = 0;
+                    pChunk = pChunk->pNext;
+                }
+                return *this;
+            }
+
+            iterator &operator+=( int iAmnt )
+            {
+                if( !pChunk ) return *this;
+                iPos += iAmnt;
+                while( iPos >= pChunk->nLength )
+                {
+                    iPos -= pChunk->nLength;
+                    pChunk = pChunk->pNext;
+                    if( pChunk == NULL )
+                        break;
+                }
+                return *this;
+            }
+
+            iterator operator+( int iAmnt ) const
+            {
+                if( !pChunk ) return *this;
+                iterator ret( *this );
+                ret += iAmnt;
+                return ret;
+            }
+
+            char &operator*()
+            {
+                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
+                return pChunk->pData[iPos];
+            }
+
+            const char &operator*() const
+            {
+                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
+                return pChunk->pData[iPos];
+            }
+
+            bool operator==( const char &c ) const
+            {
+                if( !pChunk ) return false;
+                return pChunk->pData[iPos] == c;
+            }
+
+            bool operator!=( const char &c ) const
+            {
+                if( !pChunk ) return false;
+                return pChunk->pData[iPos] != c;
+            }
+
+            iterator &operator=( const char &c )
+            {
+                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
+                pChunk->pData[iPos] = c;
+                return *this;
+            }
+
+            operator bool() const
+            {
+                return pChunk != NULL;
+            }
+
+            bool isValid() const
+            {
+                return pChunk != NULL;
+            }
+
+            bool compare( const const_iterator &c ) const
+            {
+                const_iterator a( *this );
+                const_iterator b = c;
+                if( a == b )
+                    return true;
+                for(; a && b; a++, b++ )
+                {
+                    if( *a != *b )
+                        return false;
+                }
+                if( (bool)a != (bool)b )
+                    return false;
+                return true;
+            }
+
+            bool compare( const const_iterator &c, int nLen ) const
+            {
+                const_iterator a( *this );
+                const_iterator b = c;
+                if( a == b )
+                    return true;
+                for(int j = 0; j < nLen; a++, b++, j++ )
+                {
+                    if( !a || !b || *a != *b )
+                        return false;
+                }
+                return true;
+            }
+
+            bool compare( const char *c ) const
+            {
+                if( !pChunk ) return false;
+                iterator a = *this;
+                for(; a && *c; a++, c++ )
+                {
+                    if( *a != *c )
+                        return false;
+                }
+                if( a.isValid() != (*c!=(char)0) )
+                    return false;
+                return true;
+            }
+
+            bool compare( const char *c, int nLen ) const
+            {
+                if( !pChunk ) return false;
+                iterator a = *this;
+                int j = 0;
+                for(; a && j < nLen; a++, c++, j++ )
+                {
+                    if( *a != *c )
+                        return false;
+                }
+                if( j < nLen )
+                    return false;
+                return true;
+            }
+
+            bool compare( const String &s ) const
+            {
+                if( !pChunk ) return false;
+                return compare( s.begin() );
+            }
+
+            bool compare( const String &s, int nLen ) const
+            {
+                if( !pChunk ) return false;
+                return compare( s.begin(), nLen );
+            }
+
+            iterator find( const char c ) const
+            {
+                for( iterator i = *this; i; i++ )
+                {
+                    if( *i == c )
+                        return i;
+                }
+                return iterator( NULL, 0 );
+            }
+
+            iterator find( const char *pStr, int nLen ) const
+            {
+                for( iterator i = *this; i; i++ )
+                {
+                    if( i.compare( pStr, nLen ) )
+                        return i;
+                }
+                return iterator( NULL, 0 );
+            }
+
+            iterator find( const String &s ) const
+            {
+                for( iterator i = *this; i; i++ )
+                {
+                    if( i.compare( s ) )
+                        return i;
+                }
+                return iterator( NULL, 0 );
+            }
+
+            iterator find( const String &s, int nLen ) const
+            {
+                for( iterator i = *this; i; i++ )
+                {
+                    if( i.compare( s, nLen ) )
+                        return i;
+                }
+                return iterator( NULL, 0 );
+            }
+        } iterator;
+
+    public:
+        String();
+        String( const char *pData );
+        String( const char *pData, long nLength );
+        String( const String &rSrc );
+        String( const String &rSrc, long nLength );
+        String( const String &rSrc, long nStart, long nLength );
+        String( long nSize );
+        String( const const_iterator &s );
+        String( const const_iterator &s, const const_iterator &e );
+        virtual ~String();
+
+        /**
+         * Append data to your string.
+         *@param pData (const char *) The data to append.
+         */
+        void append( const char *pData );
+
+        /**
+         * Append data to your string.
+         *@param pData (const char *) The data to append.
+         *@param nLen (long) The length of the data to append.
+         */
+        void append( const char *pData, long nLen );
+        
+        /**
+         * Append data to your string.
+         *@param pData (const char *) The data to append.
+         *@param nStart (long) The start position to copy from.
+         *@param nLen (long) The length of the data to append.
+         */
+        void append( const char *pData, long nStart, long nLen );
+
+        /**
+         * Append a single char to your string.
+         *@param cData (const char &) The character to append.
+         */
+        void append( const char &cData );
+
+        /**
+         * Append another String to this one.
+         *@param sData (String &) The String to append.
+         *@todo This function can be made much faster by not using getStr()
+         */
+        void append( const String & sData );
+        
+        /**
+         * Append another String to this one.
+         *@param sData (String &) The String to append.
+         *@param nLen How much data to append.
+         *@todo This function can be made much faster by not using getStr()
+         */
+        void append( const String & sData, long nLen );
+        
+        /**
+         * Append another String to this one.
+         *@param sData (String &) The String to append.
+         *@param nStart Start position in sData to start copying from.
+         *@param nLen How much data to append.
+         *@todo This function can be made much faster by not using getStr()
+         */
+        void append( const String & sData, long nStart, long nLen );
+        
+        /**
+         * Append data to this String using the passed in iterator as a base.
+         * The iterator is const, it is not changed.
+         *@param s Iterator from any compatible String to copy data from.
+         */
+        void append( const const_iterator &s );
+
+        /**
+         * Append data to this String using the passed in iterator as a base.
+         * The iterator is const, it is not changed.
+         *@param s Iterator from any compatible String to copy data from.
+         */
+        void append( const iterator &s );
+
+        /**
+         * Append data to this String using the passed in iterator as a base,
+         * and copy data until the ending iterator is reached.  The character
+         * at the ending iterator is not copied.
+         * The iterators are const, they are not changed.
+         *@param s Iterator from any compatible String to copy data from.
+         *@param e Iterator to stop copying at.
+         */
+        void append( const const_iterator &s, const const_iterator &e );
+        
+        /**
+         * Prepend another String to this one.
+         *@param sData (String &) The String to prepend.
+         *@todo This function can be made much faster by not using getStr()
+         */
+        void prepend( const String & sData );
+
+        /**
+         * Prepend data to your string.
+         *@param pData (const char *) The data to prepend.
+         */
+        void prepend( const char *pData );
+
+        /**
+         * Prepend data to your string.
+         *@param pData (const char *) The data to prepend.
+         *@param nLen (long) The length of the data to prepend.
+         */
+        void prepend( const char *pData, long nLen );
+
+        void prepend( const char c );
+
+        /**
+         * Insert pData before byte nPos, that is, the first byte of pData will
+         * start at nPos.  This could probably be made faster by avoiding
+         * flattening.
+         */
+        void insert( long nPos, const char *pData, long nLen );
+
+        void insert( long nPos, const String &str );
+
+        /**
+         *@todo This function shouldn't use strlen, we should add our own to
+         * this class, one that can be overridden in a specific implementation.
+         */
+        void insert( long nPos, const char *pData );
+
+        void remove( long nPos, long nLen );
+
+        /**
+         * Clear all data from the string.
+         */
+        void clear();
+
+        String replace( const String &fnd, const String &rep ) const;
+
+        /**
+         * Force the string to resize
+         *@param nNewSize (long) The new size of the string.
+         */
+        void resize( long nNewSize );
+
+        /**
+         * Get the current size of the string.
+         *@returns (long) The current size of the string.
+         */
+        long getSize() const;
+        
+        /**
+         * Get a pointer to the string array.
+         *@returns (char *) The string data.
+         */
+        char *getStr();
+        
+        /**
+         * Get a const pointer to the string array.
+         *@returns (const char *) The string data.
+         */
+        const char *getStr() const;
+
+        /**
+         * A convinience function, this one won't cause as much work as the
+         * non-const getStr, so if you're not changing the data, consider it.
+         */
+        const char *getConstStr() const;
+
+        String getSubStrIdx( long iStart, long iSize=-1 ) const;
+
+        String getSubStr( const_iterator iBegin,
+                const_iterator iEnd=String::const_iterator() ) const;
+
+        Bu::List<String> split( const char c ) const;
+
+        /**
+         * Plus equals operator for String.
+         *@param pData (const char *) The data to append to your String.
+         */
+        String &operator+=( const char *pData );
+        
+        /**
+         * Plus equals operator for String.
+         *@param rSrc (const String &) The String to append to your String.
+         */
+        String &operator+=( const String &rSrc );
+
+        String &operator+=( const String::const_iterator &i );
+
+        /**
+         * Plus equals operator for String.
+         *@param cData (const char) The character to append to your String.
+         */
+        String &operator+=( const char cData );
+
+        /**
+         * Assignment operator.
+         *@param pData (const char *) The character array to append to your
+         *      String.
+         */
+        String &operator=( const char *pData );
+
+        String operator+( const String &rRight ) const;
+
+        String operator+( const char *pRight ) const;
+
+        String operator+( char *pRight ) const;
+
+        /**
+         * Reset your String to this character array.
+         *@param pData (const char *) The character array to set your String to.
+         */
+        void set( const char *pData );
+
+        /**
+         * Reset your String to this character array.
+         *@param pData (const char *) The character array to set your String to.
+         *@param nSize (long) The length of the inputted character array.
+         */
+        void set( const char *pData, long nSize );
+
+        void set( const char *pData, long nStart, long nSize );
+        
+        void set( const String &rData );
+
+        void set( const String &rData, long nSize );
+
+        void set( const String &rData, long nStart, long nSize );
+
+        void set( const_iterator s );
+
+        void set( const_iterator s, const_iterator e );
+
+        /**
+         * Resize the string, possibly to make room for a copy.  At the moment
+         * this operation *is* destructive.  What was in the string will in no
+         * way be preserved.  This is, however, very fast.  If you want to
+         * keep your data check out resize.
+         *@param iSize the new size in bytes.  The string is guranteed to have
+         * at least this much contiguous space available when done.
+         */
+        void setSize( long iSize );
+
+        /**
+         * Equals comparison operator.
+         *@param pData (const char *) The character array to compare your String
+         *      to.
+         */
+        bool operator==( const char *pData ) const;
+        
+        /**
+         * Equals comparison operator.
+         *@param pData (const String &) The String to compare your String to.
+         */
+        bool operator==( const String &pData ) const;
+
+        /**
+         * Not equals comparison operator.
+         *@param pData (const char *) The character array to compare your String
+         *      to.
+         */
+        bool operator!=(const char *pData ) const;
+        
+        /**
+         * Not equals comparison operator.
+         *@param pData (const String &) The String to compare your String to.
+         */
+        bool operator!=(const String &pData ) const;
+
+        bool operator<(const String &pData ) const;
+        
+        bool operator<=(const String &pData ) const;
+
+        bool operator>(const String &pData ) const;
+
+        bool operator>=(const String &pData ) const;
+
+        /**
+         * Indexing operator
+         *@param nIndex (long) The index of the character you want.
+         *@returns (char &) The character at position (nIndex).
+         */
+        char &operator[]( long nIndex );
+        
+        /**
+         * Const indexing operator
+         *@param nIndex (long) The index of the character you want.
+         *@returns (const char &) The character at position (nIndex).
+         */
+        const char &operator[]( long nIndex ) const;
+
+        bool isSet() const;
+
+        bool compareSub( const char *pData, long nIndex, long nLen ) const;
+
+        bool compareSub( const String &rData, long nIndex, long nLen ) const;
+        
+        /**
+         * Is the character at index (nIndex) white space?
+         *@param nIndex (long) The index of the character you want to check.
+         *@returns (bool) Is it white space?
+         */
+        bool isWS( long nIndex ) const;
+
+        /**
+         * Is the character at index (nIndex) a letter?
+         *@param nIndex (long) The index of the character you want to check.
+         *@returns (bool) Is it a letter?
+         */
+        bool isAlpha( long nIndex ) const;
+
+        /**
+         * Convert your alpha characters to lower case.
+         */
+        String toLower() const;
+
+        /**
+         * Convert your alpha characters to upper case.
+         */
+        String toUpper() const;
+
+        const_iterator find( const char cChar,
+                const_iterator iStart=const_iterator() ) const;
+
+        const_iterator find( const char *sText, int nLen,
+                const_iterator iStart=const_iterator() ) const;
+
+        const_iterator find( const String &rStr,
+                const_iterator iStart=const_iterator() ) const;
+
+        const_iterator find( const String &rStr, int nLen,
+                const_iterator iStart=const_iterator() ) const;
+
+        iterator find( const char cChar,
+                const_iterator iStart=const_iterator() );
+
+        iterator find( const char *sText, int nLen,
+                const_iterator iStart=const_iterator() );
+
+        iterator find( const String &rStr,
+                const_iterator iStart=const_iterator() );
+
+        iterator find( const String &rStr, int nLen,
+                const_iterator iStart=const_iterator() );
+
+        /**
+         * Find the index of the first occurrance of cChar
+         *@param cChar The character to search for.
+         *@param iStart The position in the string to start searching from.
+         *@returns (long) The index of the first occurrance. -1 for not found.
+         */
+        long findIdx( const char cChar, long iStart=0 ) const;
+        
+        /**
+         * Find the index of the first occurrance of sText
+         *@param sText The null-terminated string to search for.
+         *@param iStart The position in the string to start searching from.
+         *@returns The index of the first occurrance. -1 for not found.
+         */
+        long findIdx( const char *sText, long iStart=0 ) const;
+
+        /**
+         * Do a reverse search for (sText)
+         *@param sText (const char *) The string to search for.
+         *@returns (long) The index of the last occurrance. -1 for not found.
+         */
+        long rfindIdx( const char *sText ) const;
+
+        /**
+         * Remove nAmnt bytes from the front of the string.  This function
+         * operates in O(n) time and should be used sparingly.
+         */
+        void trimFront( long nAmnt );
+
+        void trimBack( long iAmnt );
+
+        Bu::String trimWhitespace() const;
+        
+        iterator begin();
+
+        const_iterator begin() const;
+
+        iterator end();
+
+        const_iterator end() const;
+
+        bool isEmpty() const;
+
+    private:
+        void flatten() const;
+        bool isFlat() const;
+
+    public:
+        class FormatProxyEndAction
+        {
+        public:
+            virtual ~FormatProxyEndAction() { };
+            virtual void operator()( const Bu::String &sFinal )=0;
+        };
+
+        class FormatProxy
+        {
+        friend class Bu::String;
+        private:
+            FormatProxy( const String &rFmt, FormatProxyEndAction *pAct=NULL );
+
+        public:
+            virtual ~FormatProxy();
+            template<typename T>
+            FormatProxy &arg( const T &x )
+            {
+                lArgs.append( Arg( x ) );
+
+                return *this;
+            }
+
+            template<typename T>
+            FormatProxy &arg( const T &x, const Bu::Fmt &f )
+            {
+                lArgs.append( Arg( x, f ) );
+
+                return *this;
+            }
+
+            String end() const;
+            operator String() const { return end(); }
+
+        private:
+            const String &rFmt;
+            class Arg
+            {
+            public:
+                template<typename T>
+                Arg( const T &v ) :
+                    value( v )
+                {
+                }
+
+                template<typename T>
+                Arg( const T &v, const Bu::Fmt &f ) :
+                    value( v ),
+                    format( f )
+                {
+                }
+
+                Bu::Variant value;
+                Bu::Fmt format;
+            };
+            typedef Bu::List<Arg> ArgList;
+            ArgList lArgs;
+            FormatProxyEndAction *pAct;
+            mutable bool bOpen;
+        };
+
+    public:
+        template<typename ArgType>
+        FormatProxy arg( const ArgType &x ) const
+        {
+            return FormatProxy( *this ).arg( x );
+        }
+
+        template<typename ArgType>
+        FormatProxy arg( const ArgType &x, const Bu::Fmt &f ) const
+        {
+            return FormatProxy( *this ).arg( x, f );
+        }
+        
+        FormatProxy format() const
+        {
+            return FormatProxy( *this );
+        }
+
+        FormatProxy format( FormatProxyEndAction *pEndAction ) const
+        {
+            return FormatProxy( *this, pEndAction );
+        }
+    };
+    
+    template<class T> String operator+( const T *pLeft, const String &rRight )
+    {
+        Bu::String ret( pLeft );
+        ret.append( rRight );
+        return ret;
+    }
+
+    ArchiveBase &operator<<( ArchiveBase &ar, const String &s );
+    ArchiveBase &operator>>( ArchiveBase &ar, String &s );
+
+    template<typename T>
+    uint32_t __calcHashCode( const T &k );
+
+    template<typename T>
+    bool __cmpHashKeys( const T &a, const T &b );
+
+    template<> uint32_t __calcHashCode<String>( const String &k );
+    template<> bool __cmpHashKeys<String>(
+        const String &a, const String &b );
+    
+    template<typename t> void __tracer_format( const t &v );
+    template<> void __tracer_format<String>( const String &v );
+
+    bool &operator<<( bool &dst, const String &sIn );
+    uint8_t &operator<<( uint8_t &dst, const String &sIn );
+    int8_t &operator<<( int8_t &dst, const String &sIn );
+    char &operator<<( char &dst, const String &sIn );
+    uint16_t &operator<<( uint16_t &dst, const String &sIn );
+    int16_t &operator<<( int16_t &dst, const String &sIn );
+    uint32_t &operator<<( uint32_t &dst, const String &sIn );
+    int32_t &operator<<( int32_t &dst, const String &sIn );
+    uint64_t &operator<<( uint64_t &dst, const String &sIn );
+    int64_t &operator<<( int64_t &dst, const String &sIn );
+    float &operator<<( float &dst, const String &sIn );
+    double &operator<<( double &dst, const String &sIn );
+    long double &operator<<( long double &dst, const String &sIn );
+    Bu::String &operator<<( Bu::String &dst, const String &sIn );
+
+    typedef Bu::List<String> StringList;
 };
 
 #endif
diff --git a/src/stable/substream.cpp b/src/stable/substream.cpp
index 7e3729b..c55dc04 100644
--- a/src/stable/substream.cpp
+++ b/src/stable/substream.cpp
@@ -8,12 +8,12 @@
 #include "bu/substream.h"
 
 Bu::SubStream::SubStream( Bu::Stream &rNext, Bu::size iSize ) :
-        Bu::Filter( rNext ),
-        iStart( 0 ),
-        iPos( 0 ),
-        iSize( iSize )
+    Bu::Filter( rNext ),
+    iStart( 0 ),
+    iPos( 0 ),
+    iSize( iSize )
 {
-        iStart = rNext.tell();
+    iStart = rNext.tell();
 }
 
 Bu::SubStream::~SubStream()
@@ -22,88 +22,88 @@ Bu::SubStream::~SubStream()
 
 Bu::size Bu::SubStream::read( void *pBuf, Bu::size nBytes )
 {
-        if( (Bu::size)nBytes > iSize-iPos )
-                nBytes = iSize-iPos;
-        nBytes = rNext.read( pBuf, nBytes );
-        iPos += nBytes;
-        return nBytes;
+    if( (Bu::size)nBytes > iSize-iPos )
+        nBytes = iSize-iPos;
+    nBytes = rNext.read( pBuf, nBytes );
+    iPos += nBytes;
+    return nBytes;
 }
 
 Bu::size Bu::SubStream::write( const void *pBuf, Bu::size nBytes )
 {
-        if( (Bu::size)nBytes > iSize-iPos )
-                nBytes = iSize-iPos;
-        nBytes = rNext.write( pBuf, nBytes );
-        iPos += nBytes;
-        return nBytes;
+    if( (Bu::size)nBytes > iSize-iPos )
+        nBytes = iSize-iPos;
+    nBytes = rNext.write( pBuf, nBytes );
+    iPos += nBytes;
+    return nBytes;
 }
 
 void Bu::SubStream::start()
 {
-        // doesn't mean anything...
+    // doesn't mean anything...
 }
 
 Bu::size Bu::SubStream::stop()
 {
-        // doesn't mean anything...
-        return 0;
+    // doesn't mean anything...
+    return 0;
 }
 
 void Bu::SubStream::close()
 {
-        // don't do anything?  maybe...
+    // don't do anything?  maybe...
 }
 
 Bu::size Bu::SubStream::tell()
 {
-        return iPos;
+    return iPos;
 }
 
 void Bu::SubStream::seek( Bu::size offset )
 {
-        if( iPos+offset < 0 )
-                offset = -iPos;
-        else if( iPos+offset > iSize )
-                offset = iSize-iPos;
-        rNext.seek( offset );
-        iPos += offset;
+    if( iPos+offset < 0 )
+        offset = -iPos;
+    else if( iPos+offset > iSize )
+        offset = iSize-iPos;
+    rNext.seek( offset );
+    iPos += offset;
 }
 
 void Bu::SubStream::setPos( Bu::size pos )
 {
-        if( pos < 0 )
-                pos = 0;
-        else if( pos > iSize )
-                pos = iSize;
-        iPos = pos;
-        pos += iStart;
-        rNext.setPos( pos );
+    if( pos < 0 )
+        pos = 0;
+    else if( pos > iSize )
+        pos = iSize;
+    iPos = pos;
+    pos += iStart;
+    rNext.setPos( pos );
 }
 
 void Bu::SubStream::setPosEnd( Bu::size pos )
 {
-        if( iSize-pos < 0 )
-                pos = 0;
-        else if( iSize-pos > iSize )
-                pos = iSize;
-        else
-                pos = iSize-pos;
-        iPos = pos;
-        rNext.setPos( iStart+pos );
+    if( iSize-pos < 0 )
+        pos = 0;
+    else if( iSize-pos > iSize )
+        pos = iSize;
+    else
+        pos = iSize-pos;
+    iPos = pos;
+    rNext.setPos( iStart+pos );
 }
 
 bool Bu::SubStream::isEos()
 {
-        return rNext.isEos() || iPos == iSize;
+    return rNext.isEos() || iPos == iSize;
 }
 
 bool Bu::SubStream::canRead()
 {
-        return rNext.canRead() && (iPos < iSize);
+    return rNext.canRead() && (iPos < iSize);
 }
 
 bool Bu::SubStream::canWrite()
 {
-        return rNext.canWrite() && (iPos < iSize);
+    return rNext.canWrite() && (iPos < iSize);
 }
 
diff --git a/src/stable/substream.h b/src/stable/substream.h
index 5905043..f79ed0b 100644
--- a/src/stable/substream.h
+++ b/src/stable/substream.h
@@ -12,52 +12,52 @@
 
 namespace Bu
 {
-        /**
-         * Creates a sub-stream of a given stream.  This allows you to read and
-         * write safely to a section of another stream, keeping all data within
-         * the given bounds.  The substream acts exactly like a top level stream
-         * when you reach the bounds of either the containing stream or the
-         * artificial bounds of the substream, except that unlike many stream types,
-         * when writing you cannot move beyond the bounds of the substream.  Reads,
-         * on the other hand, work exactly the same way, returning less data than
-         * requested when the end of the stream is reached.
-         *
-         * The substream always begins at the current position in the base stream,
-         * if you would like to skip some data first, simply seek.
-         *
-         * The substream class is safe to use with all blocking and non-blocking
-         * base streams, including sockets, however it can have unpredictable
-         * results when used on a buffering stream that may read more data than
-         * requested in order to complete a request such as the buffer or bzip2
-         * filters.
-         */
-        class SubStream : public Bu::Filter
-        {
-        public:
-                SubStream( Bu::Stream &rNext, Bu::size iSize );
-                virtual ~SubStream();
-
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Bu::Stream::write;
-
-                virtual void start();
-                virtual Bu::size stop();
-                virtual void close();
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-
-                virtual bool canRead();
-                virtual bool canWrite();
-
-        protected:
-                Bu::size iStart;
-                Bu::size iPos;
-                Bu::size iSize;
-        };
+    /**
+     * Creates a sub-stream of a given stream.  This allows you to read and
+     * write safely to a section of another stream, keeping all data within
+     * the given bounds.  The substream acts exactly like a top level stream
+     * when you reach the bounds of either the containing stream or the
+     * artificial bounds of the substream, except that unlike many stream types,
+     * when writing you cannot move beyond the bounds of the substream.  Reads,
+     * on the other hand, work exactly the same way, returning less data than
+     * requested when the end of the stream is reached.
+     *
+     * The substream always begins at the current position in the base stream,
+     * if you would like to skip some data first, simply seek.
+     *
+     * The substream class is safe to use with all blocking and non-blocking
+     * base streams, including sockets, however it can have unpredictable
+     * results when used on a buffering stream that may read more data than
+     * requested in order to complete a request such as the buffer or bzip2
+     * filters.
+     */
+    class SubStream : public Bu::Filter
+    {
+    public:
+        SubStream( Bu::Stream &rNext, Bu::size iSize );
+        virtual ~SubStream();
+
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Bu::Stream::write;
+
+        virtual void start();
+        virtual Bu::size stop();
+        virtual void close();
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+
+        virtual bool canRead();
+        virtual bool canWrite();
+
+    protected:
+        Bu::size iStart;
+        Bu::size iPos;
+        Bu::size iSize;
+    };
 };
 
 #endif
diff --git a/src/stable/synchroatom.h b/src/stable/synchroatom.h
index 2822b20..1d996b6 100644
--- a/src/stable/synchroatom.h
+++ b/src/stable/synchroatom.h
@@ -14,50 +14,50 @@
 
 namespace Bu
 {
-        /**
-         * A thread-safe wrapper class.
-         *@ingroup Threading
-         */
-        template <class T>
-        class SynchroAtom
-        {
-        public:
-                /**
-                 * Construct an empty queue.
-                 */
-                SynchroAtom()
-                {
-                }
-
-                SynchroAtom( const T &src ) :
-                        data( src )
-                {
-                }
-                
-                ~SynchroAtom()
-                {
-                }
-
-                T get()
-                {
-                        mOperate.lock();
-                        T ret = data;
-                        mOperate.unlock();
-                        return ret;
-                }
-
-                void set( const T &val )
-                {
-                        mOperate.lock();
-                        data = val;
-                        mOperate.unlock();
-                }
-
-        private:
-                T data;
-
-                Mutex mOperate; /**< The master mutex, used on all operations. */
-        };
+    /**
+     * A thread-safe wrapper class.
+     *@ingroup Threading
+     */
+    template <class T>
+    class SynchroAtom
+    {
+    public:
+        /**
+         * Construct an empty queue.
+         */
+        SynchroAtom()
+        {
+        }
+
+        SynchroAtom( const T &src ) :
+            data( src )
+        {
+        }
+        
+        ~SynchroAtom()
+        {
+        }
+
+        T get()
+        {
+            mOperate.lock();
+            T ret = data;
+            mOperate.unlock();
+            return ret;
+        }
+
+        void set( const T &val )
+        {
+            mOperate.lock();
+            data = val;
+            mOperate.unlock();
+        }
+
+    private:
+        T data;
+
+        Mutex mOperate; /**< The master mutex, used on all operations. */
+    };
 };
 
 #endif
diff --git a/src/stable/synchrocounter.h b/src/stable/synchrocounter.h
index ef86445..17de890 100644
--- a/src/stable/synchrocounter.h
+++ b/src/stable/synchrocounter.h
@@ -12,38 +12,38 @@
 
 namespace Bu
 {
-        /**
-         * A simple thread-safe counter class.  This is handy for assigning unique
-         * IDs to objects that are being created in different threads.
-         *@ingroup Threading Containers
-         */
-        template <class T>
-        class SynchroCounter
-        {
-        public:
-                SynchroCounter() :
-                        tCounter( 0 )
-                {
-                }
-                
-                virtual ~SynchroCounter()
-                {
-                }
+    /**
+     * A simple thread-safe counter class.  This is handy for assigning unique
+     * IDs to objects that are being created in different threads.
+     *@ingroup Threading Containers
+     */
+    template <class T>
+    class SynchroCounter
+    {
+    public:
+        SynchroCounter() :
+            tCounter( 0 )
+        {
+        }
+        
+        virtual ~SynchroCounter()
+        {
+        }
 
-                T next()
-                {
-                        mOperate.lock();
-                        T tRet = tCounter;
-                        tCounter++;
-                        mOperate.unlock();
+        T next()
+        {
+            mOperate.lock();
+            T tRet = tCounter;
+            tCounter++;
+            mOperate.unlock();
 
-                        return tRet;
-                }
+            return tRet;
+        }
 
-        private:
-                T tCounter;                             /**< The counter itself. */
-                Mutex mOperate; /**< The master mutex, used on all operations. */
-        };
+    private:
+        T tCounter;             /**< The counter itself. */
+        Mutex mOperate; /**< The master mutex, used on all operations. */
+    };
 }
 
 #endif
diff --git a/src/stable/synchroheap.h b/src/stable/synchroheap.h
index 9448625..f5216bf 100644
--- a/src/stable/synchroheap.h
+++ b/src/stable/synchroheap.h
@@ -14,137 +14,137 @@
 
 namespace Bu
 {
-        template<typename item, typename cmpfunc=__basicLTCmp<item>,
-                typename itemalloc=std::allocator<item> >
-        class SynchroHeap
-        {
-        public:
-                SynchroHeap()
-                {
-                }
-
-                virtual ~SynchroHeap()
-                {
-                }
-
-                void enqueue( item i )
-                {
-                        imData.lock();
-                        hData.enqueue( i );
-                        icBlock.signal();
-                        imData.unlock();
-                }
-
-                item dequeue( bool bBlock=false )
-                {
-                        imData.lock();
-                        if( hData.isEmpty() )
-                        {
-                                imData.unlock();
-
-                                if( bBlock )
-                                {
-                                        icBlock.lock();
-
-                                        while( hData.isEmpty() )
-                                                icBlock.wait();
-
-                                        imData.lock();
-                                        try
-                                        {
-                                                item iRet = hData.dequeue();
-                                                imData.unlock();
-                                                icBlock.unlock();
-                                                return iRet;
-                                        }
-                                        catch(...)
-                                        {
-                                                imData.unlock();
-                                                icBlock.unlock();
-                                                throw;
-                                        }
-                                }
-                                throw HeapException("Heap empty.");
-                        }
-                        else
-                        {
-                                try
-                                {
-                                        item iRet = hData.dequeue();
-                                        imData.unlock();
-                                        return iRet;
-                                }
-                                catch(...)
-                                {
-                                        imData.unlock();
-                                        throw;
-                                }
-                        }
-                }
-
-                item dequeue( int iSec, int iUSec )
-                {
-                        imData.lock();
-                        if( hData.isEmpty() )
-                        {
-                                imData.unlock();
-
-                                icBlock.lock();
-
-                                icBlock.wait( iSec, iUSec );
-
-                                imData.lock();
-                                try
-                                {
-                                        item iRet = hData.dequeue();
-                                        imData.unlock();
-                                        icBlock.unlock();
-                                        return iRet;
-                                }
-                                catch(...)
-                                {
-                                        imData.unlock();
-                                        icBlock.unlock();
-                                        throw;
-                                }
-                        }
-                        else
-                        {
-                                try
-                                {
-                                        item iRet = hData.dequeue();
-                                        imData.unlock();
-                                        return iRet;
-                                }
-                                catch(...)
-                                {
-                                        imData.unlock();
-                                        throw;
-                                }
-                        }
-                }
-                
-                bool isEmpty()
-                {
-                        imData.lock();
-                        bool bRet = hData.isEmpty();
-                        imData.unlock();
-                        return bRet;
-                }
-
-                int getSize()
-                {
-                        imData.lock();
-                        int iRet = hData.getSize();
-                        imData.unlock();
-                        return iRet;
-                }
-
-        private:
-                Heap< item, cmpfunc, itemalloc > hData;
-                Mutex imData;
-                Condition icBlock;
-        };
+    template<typename item, typename cmpfunc=__basicLTCmp<item>,
+        typename itemalloc=std::allocator<item> >
+    class SynchroHeap
+    {
+    public:
+        SynchroHeap()
+        {
+        }
+
+        virtual ~SynchroHeap()
+        {
+        }
+
+        void enqueue( item i )
+        {
+            imData.lock();
+            hData.enqueue( i );
+            icBlock.signal();
+            imData.unlock();
+        }
+
+        item dequeue( bool bBlock=false )
+        {
+            imData.lock();
+            if( hData.isEmpty() )
+            {
+                imData.unlock();
+
+                if( bBlock )
+                {
+                    icBlock.lock();
+
+                    while( hData.isEmpty() )
+                        icBlock.wait();
+
+                    imData.lock();
+                    try
+                    {
+                        item iRet = hData.dequeue();
+                        imData.unlock();
+                        icBlock.unlock();
+                        return iRet;
+                    }
+                    catch(...)
+                    {
+                        imData.unlock();
+                        icBlock.unlock();
+                        throw;
+                    }
+                }
+                throw HeapException("Heap empty.");
+            }
+            else
+            {
+                try
+                {
+                    item iRet = hData.dequeue();
+                    imData.unlock();
+                    return iRet;
+                }
+                catch(...)
+                {
+                    imData.unlock();
+                    throw;
+                }
+            }
+        }
+
+        item dequeue( int iSec, int iUSec )
+        {
+            imData.lock();
+            if( hData.isEmpty() )
+            {
+                imData.unlock();
+
+                icBlock.lock();
+
+                icBlock.wait( iSec, iUSec );
+
+                imData.lock();
+                try
+                {
+                    item iRet = hData.dequeue();
+                    imData.unlock();
+                    icBlock.unlock();
+                    return iRet;
+                }
+                catch(...)
+                {
+                    imData.unlock();
+                    icBlock.unlock();
+                    throw;
+                }
+            }
+            else
+            {
+                try
+                {
+                    item iRet = hData.dequeue();
+                    imData.unlock();
+                    return iRet;
+                }
+                catch(...)
+                {
+                    imData.unlock();
+                    throw;
+                }
+            }
+        }
+        
+        bool isEmpty()
+        {
+            imData.lock();
+            bool bRet = hData.isEmpty();
+            imData.unlock();
+            return bRet;
+        }
+
+        int getSize()
+        {
+            imData.lock();
+            int iRet = hData.getSize();
+            imData.unlock();
+            return iRet;
+        }
+
+    private:
+        Heap< item, cmpfunc, itemalloc > hData;
+        Mutex imData;
+        Condition icBlock;
+    };
 };
 
 #endif
diff --git a/src/stable/synchroqueue.h b/src/stable/synchroqueue.h
index 1c16e15..8dbedba 100644
--- a/src/stable/synchroqueue.h
+++ b/src/stable/synchroqueue.h
@@ -15,233 +15,233 @@
 
 namespace Bu
 {
-        /**
-         * A thread-safe queue class.  This class is a very simple queue with some
-         * cool extra functionality for use with the Synchro system.  The main extra
-         * that it provides is the option to either dequeue without blocking, with
-         * infinite blocking, or with timed blocking, which will return a value if
-         * something is enqueued within the specified time limit, or NULL if the
-         * time limit is exceded.
-         *@ingroup Threading Containers
-         */
-        template <class T>
-        class SynchroQueue
-        {
-        private:
-                /**
-                 * Helper struct.  Keeps track of linked-list items for the queue data.
-                 */
-                typedef struct Item
-                {
-                        T pData;
-                        Item *pNext;
-                } Item;
-
-        public:
-                /**
-                 * Construct an empty queue.
-                 */
-                SynchroQueue() :
-                        pStart( NULL ),
-                        pEnd( NULL ),
-                        nSize( 0 )
-                {
-                }
-                
-                /**
-                 * Destroy the queue.  This function will simply free all contained
-                 * structures.  If you stored pointers in the queue, this will lose the
-                 * pointers without cleaning up the memory they pointed to.  Make sure
-                 * you're queue is empty before allowing it to be destroyed!
-                 */
-                ~SynchroQueue()
-                {
-                        cBlock.lock();
-                        Item *pCur = pStart;
-                        while( pCur )
-                        {
-                                Item *pTmp = pCur->pNext;
-                                delete pCur;
-                                pCur = pTmp;
-                        }
-                        cBlock.unlock();
-                }
-
-                /**
-                 * Enqueue a pieces of data.  The new data will go at the end of the
-                 * queue, and unless another piece of data is enqueued, will be the
-                 * last piece of data to be dequeued.
-                 *@param pData The data to enqueue.  If this is not a primitive data
-                 * type it's probably best to use a pointer type.
-                 */
-                void enqueue( T pData )
-                {
-                        cBlock.lock();
-
-                        if( pStart == NULL )
-                        {
-                                pStart = pEnd = new Item;
-                                pStart->pData = pData;
-                                pStart->pNext = NULL;
-                                nSize++;
-                        }
-                        else
-                        {
-                                pEnd->pNext = new Item;
-                                pEnd = pEnd->pNext;
-                                pEnd->pData = pData;
-                                pEnd->pNext = NULL;
-                                nSize++;
-                        }
-
-                        cBlock.signal();
-
-                        cBlock.unlock();
-                }
-
-                /**
-                 * Dequeue the first item from the queue.  This function can operate in
-                 * two different modes, blocking and non-blocking.  In non-blocking
-                 * mode it will return immediately weather there was data in the queue
-                 * or not.  If there was data it will remove it from the queue and
-                 * return it to the caller.
-                 *
-                 * In blocking mode it will block forever wating for data to be
-                 * enqueued.  When data finally is enqueued this function will return
-                 * immediately with the new data.  The only way this function should
-                 * ever return a null in blocking mode is if the calling thread was
-                 * cancelled.  It's probably a good idea to check for NULL return
-                 * values even if you use blocking, just to be on the safe side.
-                 *@param bBlock Set to true to enable blocking, leave as false to work
-                 * in non-blocking mode.
-                 *@returns The next piece of data in the queue, or NULL if no data was
-                 * in the queue.
-                 */
-                T dequeue( bool bBlock=false )
-                {
-                        cBlock.lock();
-                        if( pStart == NULL )
-                        {
-                                if( bBlock )
-                                {
-                                        cBlock.wait();
-
-                                        if( pStart == NULL )
-                                        {
-                                                cBlock.unlock();
-                                                return NULL;
-                                        }
-                                        T pTmp = pStart->pData;
-                                        Item *pDel = pStart;
-                                        pStart = pStart->pNext;
-                                        delete pDel;
-                                        nSize--;
-                                        
-                                        cBlock.unlock();
-                                        return pTmp;
-
-                                }
-
-                                cBlock.unlock();
-                                return NULL;
-                        }
-                        else
-                        {
-                                T pTmp = pStart->pData;
-                                Item *pDel = pStart;
-                                pStart = pStart->pNext;
-                                delete pDel;
-                                nSize--;
-                        
-                                cBlock.unlock();
-                                return pTmp;
-                        }
-                }
-
-                /**
-                 * Operates just like the other dequeue function in blocking mode with
-                 * one twist.  This function will block for at most nSec seconds and
-                 * nUSec micro-seconds.  If the timer is up and no data is available,
-                 * this will just return NULL.  If data is enqueued before the timeout
-                 * expires, it will dequeue and exit immediately.
-                 *@param nSec The number of seconds to wait, max.
-                 *@param nUSec The number of micro-seconds to wait, max.
-                 *@returns The next piece of data in the queue, or NULL if the timeout
-                 * was exceeded.
-                 */
-                T dequeue( int nSec, int nUSec )
-                {
-                        cBlock.lock();
-                        if( pStart == NULL )
-                        {
-                                cBlock.wait( nSec, nUSec );
-
-                                if( pStart == NULL )
-                                {
-                                        cBlock.unlock();
-                                        return NULL;
-                                }
-                        
-                                T pTmp = pStart->pData;
-                                Item *pDel = pStart;
-                                pStart = pStart->pNext;
-                                delete pDel;
-                                nSize--;
-                                        
-                                cBlock.unlock();
-                                return pTmp;
-                        }
-                        else
-                        {
-                                T pTmp = pStart->pData;
-                                Item *pDel = pStart;
-                                pStart = pStart->pNext;
-                                delete pDel;
-                                nSize--;
-                        
-                                cBlock.unlock();
-                                return pTmp;
-                        }
-                }
-
-                /**
-                 * Checks to see if the queue has data in it or not.  Note that there
-                 * is no function to determine the length of the queue.  This data
-                 * isn't kept track of.  If you really need to know, fix this.
-                 *@returns True if the queue is empty, false if it has data in it.
-                 */
-                bool isEmpty()
-                {
-                        cBlock.lock();
-                        bool bEmpty = (pStart == NULL );
-                        cBlock.unlock();
-
-                        return bEmpty;
-                }
-
-                long getSize()
-                {
-                        cBlock.lock();
-                        long nRet = nSize;
-                        cBlock.unlock();
-
-                        return nRet;
-                }
-
-                void unblockAll()
-                {
-                        cBlock.lock();
-                        cBlock.broadcast();
-                        cBlock.unlock();
-                }
-
-        private:
-                Item *pStart;   /**< The start of the queue, the next element to dequeue. */
-                Item *pEnd;             /**< The end of the queue, the last element to dequeue. */
-                long nSize;             /**< The number of items in the queue. */
-
-                Condition cBlock;       /**< The condition for blocking dequeues. */
-        };
+    /**
+     * A thread-safe queue class.  This class is a very simple queue with some
+     * cool extra functionality for use with the Synchro system.  The main extra
+     * that it provides is the option to either dequeue without blocking, with
+     * infinite blocking, or with timed blocking, which will return a value if
+     * something is enqueued within the specified time limit, or NULL if the
+     * time limit is exceded.
+     *@ingroup Threading Containers
+     */
+    template <class T>
+    class SynchroQueue
+    {
+    private:
+        /**
+         * Helper struct.  Keeps track of linked-list items for the queue data.
+         */
+        typedef struct Item
+        {
+            T pData;
+            Item *pNext;
+        } Item;
+
+    public:
+        /**
+         * Construct an empty queue.
+         */
+        SynchroQueue() :
+            pStart( NULL ),
+            pEnd( NULL ),
+            nSize( 0 )
+        {
+        }
+        
+        /**
+         * Destroy the queue.  This function will simply free all contained
+         * structures.  If you stored pointers in the queue, this will lose the
+         * pointers without cleaning up the memory they pointed to.  Make sure
+         * you're queue is empty before allowing it to be destroyed!
+         */
+        ~SynchroQueue()
+        {
+            cBlock.lock();
+            Item *pCur = pStart;
+            while( pCur )
+            {
+                Item *pTmp = pCur->pNext;
+                delete pCur;
+                pCur = pTmp;
+            }
+            cBlock.unlock();
+        }
+
+        /**
+         * Enqueue a pieces of data.  The new data will go at the end of the
+         * queue, and unless another piece of data is enqueued, will be the
+         * last piece of data to be dequeued.
+         *@param pData The data to enqueue.  If this is not a primitive data
+         * type it's probably best to use a pointer type.
+         */
+        void enqueue( T pData )
+        {
+            cBlock.lock();
+
+            if( pStart == NULL )
+            {
+                pStart = pEnd = new Item;
+                pStart->pData = pData;
+                pStart->pNext = NULL;
+                nSize++;
+            }
+            else
+            {
+                pEnd->pNext = new Item;
+                pEnd = pEnd->pNext;
+                pEnd->pData = pData;
+                pEnd->pNext = NULL;
+                nSize++;
+            }
+
+            cBlock.signal();
+
+            cBlock.unlock();
+        }
+
+        /**
+         * Dequeue the first item from the queue.  This function can operate in
+         * two different modes, blocking and non-blocking.  In non-blocking
+         * mode it will return immediately weather there was data in the queue
+         * or not.  If there was data it will remove it from the queue and
+         * return it to the caller.
+         *
+         * In blocking mode it will block forever wating for data to be
+         * enqueued.  When data finally is enqueued this function will return
+         * immediately with the new data.  The only way this function should
+         * ever return a null in blocking mode is if the calling thread was
+         * cancelled.  It's probably a good idea to check for NULL return
+         * values even if you use blocking, just to be on the safe side.
+         *@param bBlock Set to true to enable blocking, leave as false to work
+         * in non-blocking mode.
+         *@returns The next piece of data in the queue, or NULL if no data was
+         * in the queue.
+         */
+        T dequeue( bool bBlock=false )
+        {
+            cBlock.lock();
+            if( pStart == NULL )
+            {
+                if( bBlock )
+                {
+                    cBlock.wait();
+
+                    if( pStart == NULL )
+                    {
+                        cBlock.unlock();
+                        return NULL;
+                    }
+                    T pTmp = pStart->pData;
+                    Item *pDel = pStart;
+                    pStart = pStart->pNext;
+                    delete pDel;
+                    nSize--;
+                    
+                    cBlock.unlock();
+                    return pTmp;
+
+                }
+
+                cBlock.unlock();
+                return NULL;
+            }
+            else
+            {
+                T pTmp = pStart->pData;
+                Item *pDel = pStart;
+                pStart = pStart->pNext;
+                delete pDel;
+                nSize--;
+            
+                cBlock.unlock();
+                return pTmp;
+            }
+        }
+
+        /**
+         * Operates just like the other dequeue function in blocking mode with
+         * one twist.  This function will block for at most nSec seconds and
+         * nUSec micro-seconds.  If the timer is up and no data is available,
+         * this will just return NULL.  If data is enqueued before the timeout
+         * expires, it will dequeue and exit immediately.
+         *@param nSec The number of seconds to wait, max.
+         *@param nUSec The number of micro-seconds to wait, max.
+         *@returns The next piece of data in the queue, or NULL if the timeout
+         * was exceeded.
+         */
+        T dequeue( int nSec, int nUSec )
+        {
+            cBlock.lock();
+            if( pStart == NULL )
+            {
+                cBlock.wait( nSec, nUSec );
+
+                if( pStart == NULL )
+                {
+                    cBlock.unlock();
+                    return NULL;
+                }
+            
+                T pTmp = pStart->pData;
+                Item *pDel = pStart;
+                pStart = pStart->pNext;
+                delete pDel;
+                nSize--;
+                    
+                cBlock.unlock();
+                return pTmp;
+            }
+            else
+            {
+                T pTmp = pStart->pData;
+                Item *pDel = pStart;
+                pStart = pStart->pNext;
+                delete pDel;
+                nSize--;
+            
+                cBlock.unlock();
+                return pTmp;
+            }
+        }
+
+        /**
+         * Checks to see if the queue has data in it or not.  Note that there
+         * is no function to determine the length of the queue.  This data
+         * isn't kept track of.  If you really need to know, fix this.
+         *@returns True if the queue is empty, false if it has data in it.
+         */
+        bool isEmpty()
+        {
+            cBlock.lock();
+            bool bEmpty = (pStart == NULL );
+            cBlock.unlock();
+
+            return bEmpty;
+        }
+
+        long getSize()
+        {
+            cBlock.lock();
+            long nRet = nSize;
+            cBlock.unlock();
+
+            return nRet;
+        }
+
+        void unblockAll()
+        {
+            cBlock.lock();
+            cBlock.broadcast();
+            cBlock.unlock();
+        }
+
+    private:
+        Item *pStart;   /**< The start of the queue, the next element to dequeue. */
+        Item *pEnd;     /**< The end of the queue, the last element to dequeue. */
+        long nSize;     /**< The number of items in the queue. */
+
+        Condition cBlock;   /**< The condition for blocking dequeues. */
+    };
 }
 
 #endif
diff --git a/src/stable/tafcomment.cpp b/src/stable/tafcomment.cpp
index ceda8e3..5168685 100644
--- a/src/stable/tafcomment.cpp
+++ b/src/stable/tafcomment.cpp
@@ -8,16 +8,16 @@
 #include "bu/tafcomment.h"
 
 Bu::TafComment::TafComment( const Bu::TafComment &rSrc ) :
-        TafNode( typeComment ),
-        sText( rSrc.sText ),
-        bEOL( rSrc.bEOL )
+    TafNode( typeComment ),
+    sText( rSrc.sText ),
+    bEOL( rSrc.bEOL )
 {
 }
 
 Bu::TafComment::TafComment( const Bu::String &sText, bool bEOL ) :
-        TafNode( typeComment ),
-        sText( sText ),
-        bEOL( bEOL )
+    TafNode( typeComment ),
+    sText( sText ),
+    bEOL( bEOL )
 {
 }
 
@@ -27,11 +27,11 @@ Bu::TafComment::~TafComment()
 
 const Bu::String &Bu::TafComment::getText() const
 {
-        return sText;
+    return sText;
 }
 
 bool Bu::TafComment::isEOLStyle() const
 {
-        return bEOL;
+    return bEOL;
 }
 
diff --git a/src/stable/tafcomment.h b/src/stable/tafcomment.h
index 80c6399..2f403e7 100644
--- a/src/stable/tafcomment.h
+++ b/src/stable/tafcomment.h
@@ -13,24 +13,24 @@
 
 namespace Bu
 {
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafComment : public TafNode
-        {
-        public:
-                TafComment( const Bu::TafComment &rSrc );
-                TafComment( const Bu::String &sText, bool bEOL=false );
-                virtual ~TafComment();
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafComment : public TafNode
+    {
+    public:
+        TafComment( const Bu::TafComment &rSrc );
+        TafComment( const Bu::String &sText, bool bEOL=false );
+        virtual ~TafComment();
 
-                const Bu::String &getText() const;
-                bool isEOLStyle() const;
+        const Bu::String &getText() const;
+        bool isEOLStyle() const;
 
-        private:
-                Bu::String sText;
-                bool bEOL;
-        };
+    private:
+        Bu::String sText;
+        bool bEOL;
+    };
 }
 
 #endif
diff --git a/src/stable/tafgroup.cpp b/src/stable/tafgroup.cpp
index 27af09e..7e15b26 100644
--- a/src/stable/tafgroup.cpp
+++ b/src/stable/tafgroup.cpp
@@ -10,215 +10,215 @@
 #include "bu/tafcomment.h"
 
 Bu::TafGroup::TafGroup( const TafGroup &rSrc ) :
-        TafNode( typeGroup ),
-        sName( rSrc.sName )
+    TafNode( typeGroup ),
+    sName( rSrc.sName )
 {
-        for( NodeList::const_iterator i = rSrc.lChildren.begin(); i; i++ )
-        {
-                switch( (*i)->getType() )
-                {
-                        case typeGroup:
-                                addChild( new TafGroup( *dynamic_cast<const TafGroup *>(*i) ) );
-                                break;
+    for( NodeList::const_iterator i = rSrc.lChildren.begin(); i; i++ )
+    {
+        switch( (*i)->getType() )
+        {
+            case typeGroup:
+                addChild( new TafGroup( *dynamic_cast<const TafGroup *>(*i) ) );
+                break;
 
-                        case typeProperty:
-                                addChild( new TafProperty( *dynamic_cast<const TafProperty *>(*i) ) );
-                                break;
+            case typeProperty:
+                addChild( new TafProperty( *dynamic_cast<const TafProperty *>(*i) ) );
+                break;
 
-                        case typeComment:
-                                addChild( new TafComment( *dynamic_cast<const TafComment *>(*i) ) );
-                                break;
-                }
-        }
+            case typeComment:
+                addChild( new TafComment( *dynamic_cast<const TafComment *>(*i) ) );
+                break;
+        }
+    }
 }
 
 Bu::TafGroup::TafGroup( const Bu::String &sName ) :
-        TafNode( typeGroup ),
-        sName( sName )
+    TafNode( typeGroup ),
+    sName( sName )
 {
 }
 
 Bu::TafGroup::~TafGroup()
 {
-        for( NodeList::iterator i = lChildren.begin(); i != lChildren.end(); i++ )
-        {
-                delete (*i);
-        }
+    for( NodeList::iterator i = lChildren.begin(); i != lChildren.end(); i++ )
+    {
+        delete (*i);
+    }
 }
 
 const Bu::String &Bu::TafGroup::getName() const
 {
-        return sName;
+    return sName;
 }
 
 void Bu::TafGroup::setName( const Bu::String &sName )
 {
-        this->sName = sName;
+    this->sName = sName;
 }
 
 Bu::TafNode *Bu::TafGroup::addChild( Bu::TafNode *pNode )
 {
-        switch( pNode->getType() )
-        {
-                case typeGroup:
-                        addChild( (Bu::TafGroup *)pNode );
-                        break;
+    switch( pNode->getType() )
+    {
+        case typeGroup:
+            addChild( (Bu::TafGroup *)pNode );
+            break;
 
-                case typeProperty:
-                        addChild( (Bu::TafProperty *)pNode );
-                        break;
+        case typeProperty:
+            addChild( (Bu::TafProperty *)pNode );
+            break;
 
-                case typeComment:
-                        addChild( (Bu::TafComment *)pNode );
-                        break;
-        }
+        case typeComment:
+            addChild( (Bu::TafComment *)pNode );
+            break;
+    }
 
-        return pNode;
+    return pNode;
 }
 
 Bu::TafGroup *Bu::TafGroup::addChild( TafGroup *pNode )
 {
-        TafGroup *pGroup = (TafGroup *)pNode;
-        if( !hChildren.has( pGroup->getName() ) )
-                hChildren.insert( pGroup->getName(), GroupList() );
-        hChildren.get( pGroup->getName() ).append( pGroup );
-        lChildren.append( pNode );
-        return pNode;
+    TafGroup *pGroup = (TafGroup *)pNode;
+    if( !hChildren.has( pGroup->getName() ) )
+        hChildren.insert( pGroup->getName(), GroupList() );
+    hChildren.get( pGroup->getName() ).append( pGroup );
+    lChildren.append( pNode );
+    return pNode;
 }
 
 Bu::TafProperty *Bu::TafGroup::addChild( TafProperty *pNode )
 {
-        TafProperty *pProperty = (TafProperty *)pNode;
-        if( !hProp.has( pProperty->getName() ) )
-                hProp.insert( pProperty->getName(), PropList() );
-        hProp.get( pProperty->getName() ).append( pProperty->getValue() );
-        lChildren.append( pNode );
-        return pNode;
+    TafProperty *pProperty = (TafProperty *)pNode;
+    if( !hProp.has( pProperty->getName() ) )
+        hProp.insert( pProperty->getName(), PropList() );
+    hProp.get( pProperty->getName() ).append( pProperty->getValue() );
+    lChildren.append( pNode );
+    return pNode;
 }
 
 Bu::TafComment *Bu::TafGroup::addChild( TafComment *pNode )
 {
-        lChildren.append( pNode );
-        return pNode;
+    lChildren.append( pNode );
+    return pNode;
 }
 
 Bu::TafGroup *Bu::TafGroup::addGroup( const Bu::String &sName )
 {
-        return addChild( new TafGroup( sName ) );
+    return addChild( new TafGroup( sName ) );
 }
 
 Bu::TafProperty *Bu::TafGroup::addProperty(
-        const Bu::String &sName, const Bu::String &sValue )
+    const Bu::String &sName, const Bu::String &sValue )
 {
-        return addChild( new TafProperty( sName, sValue ) );
+    return addChild( new TafProperty( sName, sValue ) );
 }
 
 bool Bu::TafGroup::hasChild( const Bu::String &sName ) const
 {
-        return hChildren.has( sName );
+    return hChildren.has( sName );
 }
 
 const Bu::TafGroup::GroupList &Bu::TafGroup::getChildren( const Bu::String &sName ) const
 {
-        try {
-                return hChildren.get( sName );
-        } catch( Bu::HashException &e )
-        {
-                throw Bu::TafException("No children of group \"%s\" match \"%s\".",
-                        this->sName.getStr(), sName.getStr() );
-        }
+    try {
+        return hChildren.get( sName );
+    } catch( Bu::HashException &e )
+    {
+        throw Bu::TafException("No children of group \"%s\" match \"%s\".",
+            this->sName.getStr(), sName.getStr() );
+    }
 }
 
 const Bu::TafGroup::NodeList &Bu::TafGroup::getChildren() const
 {
-        return lChildren;
+    return lChildren;
 }
 
 const Bu::TafGroup *Bu::TafGroup::getChild( const Bu::String &sName ) const
 {
-        try {
-                return hChildren.get( sName ).first();
-        } catch( Bu::HashException &e )
-        {
-                throw Bu::TafException("No children of group \"%s\" match \"%s\".",
-                        this->sName.getStr(), sName.getStr() );
-        }
+    try {
+        return hChildren.get( sName ).first();
+    } catch( Bu::HashException &e )
+    {
+        throw Bu::TafException("No children of group \"%s\" match \"%s\".",
+            this->sName.getStr(), sName.getStr() );
+    }
 }
 
 bool Bu::TafGroup::hasProperty( const Bu::String &sName ) const
 {
-        return hProp.has( sName );
+    return hProp.has( sName );
 }
 
 const Bu::TafGroup::PropList &Bu::TafGroup::getProperties( const Bu::String &sName ) const
 {
-        try {
-                return hProp.get( sName );
-        } catch( Bu::HashException &e )
-        {
-                throw Bu::TafException("No properties of group \"%s\" match \"%s\".",
-                        this->sName.getStr(), sName.getStr() );
-        }
+    try {
+        return hProp.get( sName );
+    } catch( Bu::HashException &e )
+    {
+        throw Bu::TafException("No properties of group \"%s\" match \"%s\".",
+            this->sName.getStr(), sName.getStr() );
+    }
 }
 
 const Bu::String &Bu::TafGroup::getProperty( const Bu::String &sName ) const
 {
-        try {
-                return hProp.get( sName ).first();
-        } catch( Bu::HashException &e )
-        {
-                throw Bu::TafException("No properties of group \"%s\" match \"%s\".",
-                        this->sName.getStr(), sName.getStr() );
-        }       
+    try {
+        return hProp.get( sName ).first();
+    } catch( Bu::HashException &e )
+    {
+        throw Bu::TafException("No properties of group \"%s\" match \"%s\".",
+            this->sName.getStr(), sName.getStr() );
+    }   
 }
 
 const Bu::String &Bu::TafGroup::getProperty( const Bu::String &sName,
-        const Bu::String &sDef ) const
+    const Bu::String &sDef ) const
 {
-        try
-        {
-                return hProp.get( sName ).first();
-        }
-        catch( Bu::HashException &e )
-        {
-                return sDef;
-        }
+    try
+    {
+        return hProp.get( sName ).first();
+    }
+    catch( Bu::HashException &e )
+    {
+        return sDef;
+    }
 }
 
 const Bu::TafGroup *Bu::TafGroup::getChildByPath(
-                const Bu::String &sPath ) const
+        const Bu::String &sPath ) const
 {
-        return getChildByPath( sPath.split('/') );
+    return getChildByPath( sPath.split('/') );
 }
 
 const Bu::TafGroup *Bu::TafGroup::getChildByPath( Bu::StrList lPath ) const
 {
-        const Bu::TafGroup *cur = this;
+    const Bu::TafGroup *cur = this;
 
-        for( Bu::StrList::const_iterator i = lPath.begin(); i; i++ )
-        {
-                cur = cur->getChild( *i );
-        }
+    for( Bu::StrList::const_iterator i = lPath.begin(); i; i++ )
+    {
+        cur = cur->getChild( *i );
+    }
 
-        return cur;
+    return cur;
 }
 
 const Bu::String &Bu::TafGroup::getByPath( const Bu::String &sPath ) const
 {
-        return getByPath( sPath.split('/') );
+    return getByPath( sPath.split('/') );
 }
 
 const Bu::String &Bu::TafGroup::getByPath( Bu::StrList lPath ) const
 {
-        const Bu::TafGroup *cur = this;
+    const Bu::TafGroup *cur = this;
 
-        for( Bu::StrList::const_iterator i = lPath.begin(); i; i++ )
-        {
-                if( !(i+1) )
-                        break;
-                cur = cur->getChild( *i );
-        }
+    for( Bu::StrList::const_iterator i = lPath.begin(); i; i++ )
+    {
+        if( !(i+1) )
+            break;
+        cur = cur->getChild( *i );
+    }
 
-        return cur->getProperty( lPath.last() );
+    return cur->getProperty( lPath.last() );
 }
 
diff --git a/src/stable/tafgroup.h b/src/stable/tafgroup.h
index 3f52ab3..a22059e 100644
--- a/src/stable/tafgroup.h
+++ b/src/stable/tafgroup.h
@@ -16,56 +16,56 @@
 
 namespace Bu
 {
-        typedef Bu::List<Bu::String> StrList;
-        class TafProperty;
-        class TafComment;
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafGroup : public TafNode
-        {
-        public:
-                typedef Bu::List<Bu::String> PropList;
-                typedef Bu::Hash<Bu::String, PropList> PropHash;
-                typedef Bu::List<class Bu::TafGroup *> GroupList;
-                typedef Bu::Hash<Bu::String, GroupList> GroupHash;
-                typedef Bu::List<class Bu::TafNode *> NodeList;
+    typedef Bu::List<Bu::String> StrList;
+    class TafProperty;
+    class TafComment;
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafGroup : public TafNode
+    {
+    public:
+        typedef Bu::List<Bu::String> PropList;
+        typedef Bu::Hash<Bu::String, PropList> PropHash;
+        typedef Bu::List<class Bu::TafGroup *> GroupList;
+        typedef Bu::Hash<Bu::String, GroupList> GroupHash;
+        typedef Bu::List<class Bu::TafNode *> NodeList;
 
-                TafGroup( const TafGroup &rSrc );
-                TafGroup( const Bu::String &sName );
-                virtual ~TafGroup();
+        TafGroup( const TafGroup &rSrc );
+        TafGroup( const Bu::String &sName );
+        virtual ~TafGroup();
 
-                const Bu::String &getName() const;
-                void setName( const Bu::String &sName );
+        const Bu::String &getName() const;
+        void setName( const Bu::String &sName );
 
-                bool hasProperty( const Bu::String &sName ) const;
-                const Bu::String &getProperty( const Bu::String &sName ) const;
-                const Bu::String &getProperty( const Bu::String &sName,
-                        const Bu::String &sDef ) const;
-                const PropList &getProperties( const Bu::String &sName ) const;
-                bool hasChild( const Bu::String &sName ) const;
-                const TafGroup *getChild( const Bu::String &sName ) const;
-                const GroupList &getChildren( const Bu::String &sName ) const;
-                TafNode *addChild( TafNode *pNode );
-                TafGroup *addChild( TafGroup *pNode );
-                TafProperty *addChild( TafProperty *pNode );
-                TafComment *addChild( TafComment *pNode );
-                TafGroup *addGroup( const Bu::String &sName );
-                TafProperty *addProperty(
-                        const Bu::String &sName, const Bu::String &sValue );
-                const NodeList &getChildren() const;
-                const TafGroup *getChildByPath( const Bu::String &sPath ) const;
-                const TafGroup *getChildByPath( StrList lPath ) const;
-                const Bu::String &getByPath( const Bu::String &sPath ) const;
-                const Bu::String &getByPath( StrList lPath ) const;
+        bool hasProperty( const Bu::String &sName ) const;
+        const Bu::String &getProperty( const Bu::String &sName ) const;
+        const Bu::String &getProperty( const Bu::String &sName,
+            const Bu::String &sDef ) const;
+        const PropList &getProperties( const Bu::String &sName ) const;
+        bool hasChild( const Bu::String &sName ) const;
+        const TafGroup *getChild( const Bu::String &sName ) const;
+        const GroupList &getChildren( const Bu::String &sName ) const;
+        TafNode *addChild( TafNode *pNode );
+        TafGroup *addChild( TafGroup *pNode );
+        TafProperty *addChild( TafProperty *pNode );
+        TafComment *addChild( TafComment *pNode );
+        TafGroup *addGroup( const Bu::String &sName );
+        TafProperty *addProperty(
+            const Bu::String &sName, const Bu::String &sValue );
+        const NodeList &getChildren() const;
+        const TafGroup *getChildByPath( const Bu::String &sPath ) const;
+        const TafGroup *getChildByPath( StrList lPath ) const;
+        const Bu::String &getByPath( const Bu::String &sPath ) const;
+        const Bu::String &getByPath( StrList lPath ) const;
 
-        private:
-                Bu::String sName;
-                PropHash hProp;
-                GroupHash hChildren;
-                NodeList lChildren;
-        };
+    private:
+        Bu::String sName;
+        PropHash hProp;
+        GroupHash hChildren;
+        NodeList lChildren;
+    };
 }
 
 #endif
diff --git a/src/stable/tafnode.cpp b/src/stable/tafnode.cpp
index 630bcce..10ba89a 100644
--- a/src/stable/tafnode.cpp
+++ b/src/stable/tafnode.cpp
@@ -10,7 +10,7 @@
 namespace Bu { subExceptionDef( TafException ) }
 
 Bu::TafNode::TafNode( NodeType eType ) :
-        eType( eType )
+    eType( eType )
 {
 }
 
@@ -20,6 +20,6 @@ Bu::TafNode::~TafNode()
 
 Bu::TafNode::NodeType Bu::TafNode::getType() const
 {
-        return eType;
+    return eType;
 }
 
diff --git a/src/stable/tafnode.h b/src/stable/tafnode.h
index 9c0e0b9..923ee24 100644
--- a/src/stable/tafnode.h
+++ b/src/stable/tafnode.h
@@ -15,30 +15,30 @@
 
 namespace Bu
 {
-        subExceptionDecl( TafException );
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafNode
-        {
-        public:
-                enum NodeType
-                {
-                        typeGroup,
-                        typeProperty,
-                        typeComment
-                };
+    subExceptionDecl( TafException );
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafNode
+    {
+    public:
+        enum NodeType
+        {
+            typeGroup,
+            typeProperty,
+            typeComment
+        };
 
-        public:
-                TafNode( NodeType eType );
-                virtual ~TafNode();
+    public:
+        TafNode( NodeType eType );
+        virtual ~TafNode();
 
-                NodeType getType() const;
+        NodeType getType() const;
 
-        private:
-                NodeType eType;
-        };
+    private:
+        NodeType eType;
+    };
 }
 
 #endif
diff --git a/src/stable/tafproperty.cpp b/src/stable/tafproperty.cpp
index 017b294..2b3e338 100644
--- a/src/stable/tafproperty.cpp
+++ b/src/stable/tafproperty.cpp
@@ -8,16 +8,16 @@
 #include "bu/tafproperty.h"
 
 Bu::TafProperty::TafProperty( const Bu::TafProperty &rSrc ) :
-        TafNode( typeProperty ),
-        sName( rSrc.sName ),
-        sValue( rSrc.sValue )
+    TafNode( typeProperty ),
+    sName( rSrc.sName ),
+    sValue( rSrc.sValue )
 {
 }
 
 Bu::TafProperty::TafProperty( const Bu::String &sName, const Bu::String &sValue ) :
-        TafNode( typeProperty ),
-        sName( sName ),
-        sValue( sValue )
+    TafNode( typeProperty ),
+    sName( sName ),
+    sValue( sValue )
 {
 }
 
@@ -27,11 +27,11 @@ Bu::TafProperty::~TafProperty()
 
 const Bu::String &Bu::TafProperty::getName() const
 {
-        return sName;
+    return sName;
 }
 
 const Bu::String &Bu::TafProperty::getValue() const
 {
-        return sValue;
+    return sValue;
 }
 
diff --git a/src/stable/tafproperty.h b/src/stable/tafproperty.h
index b7c6983..b9834e1 100644
--- a/src/stable/tafproperty.h
+++ b/src/stable/tafproperty.h
@@ -13,24 +13,24 @@
 
 namespace Bu
 {
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafProperty : public TafNode
-        {
-        public:
-                TafProperty( const Bu::TafProperty &rSrc );
-                TafProperty( const Bu::String &sName, const Bu::String &sValue );
-                virtual ~TafProperty();
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafProperty : public TafNode
+    {
+    public:
+        TafProperty( const Bu::TafProperty &rSrc );
+        TafProperty( const Bu::String &sName, const Bu::String &sValue );
+        virtual ~TafProperty();
 
-                const Bu::String &getName() const;
-                const Bu::String &getValue() const;
+        const Bu::String &getName() const;
+        const Bu::String &getValue() const;
 
-        private:
-                Bu::String sName;
-                Bu::String sValue;
-        };
+    private:
+        Bu::String sName;
+        Bu::String sValue;
+    };
 }
 
 #endif
diff --git a/src/stable/tafreader.cpp b/src/stable/tafreader.cpp
index fb17aea..f21505e 100644
--- a/src/stable/tafreader.cpp
+++ b/src/stable/tafreader.cpp
@@ -14,12 +14,12 @@
 using namespace Bu;
 
 Bu::TafReader::TafReader( Bu::Stream &sIn ) :
-        c( 0 ),
-        la( 0 ),
-        sIn( sIn ),
-        iLine( 1 ), iCol( -1 )
+    c( 0 ),
+    la( 0 ),
+    sIn( sIn ),
+    iLine( 1 ), iCol( -1 )
 {
-        next(); next();
+    next(); next();
 }
 
 Bu::TafReader::~TafReader()
@@ -29,122 +29,122 @@ Bu::TafReader::~TafReader()
 
 Bu::TafGroup *Bu::TafReader::readGroup()
 {
-        ws();
-        if( c != '{' )
-                throw TafException("%d:%d: Expected '{' got '%c'.", iLine, iCol, c );
-        next();
-        ws();
-        String sName = readStr();
-        TafGroup *pGroup = new TafGroup( sName );
-        try
-        {
-                ws();
-                if( c != ':' )
-                        throw TafException("%d:%d: Expected ':' got '%c'.",
-                                iLine, iCol, c );
-                next();
-                //printf("Node[%s]:\n", sName.getStr() );
-
-                groupContent( pGroup );
-
-                if( c != '}' )
-                        throw TafException("%d:%d: Expected '}' got '%c'.",
-                                iLine, iCol, c );
-
-                //next();
-
-                return pGroup;
-        }
-        catch(...)
-        {
-                delete pGroup;
-                throw;
-        }
+    ws();
+    if( c != '{' )
+        throw TafException("%d:%d: Expected '{' got '%c'.", iLine, iCol, c );
+    next();
+    ws();
+    String sName = readStr();
+    TafGroup *pGroup = new TafGroup( sName );
+    try
+    {
+        ws();
+        if( c != ':' )
+            throw TafException("%d:%d: Expected ':' got '%c'.",
+                iLine, iCol, c );
+        next();
+        //printf("Node[%s]:\n", sName.getStr() );
+
+        groupContent( pGroup );
+
+        if( c != '}' )
+            throw TafException("%d:%d: Expected '}' got '%c'.",
+                iLine, iCol, c );
+
+        //next();
+
+        return pGroup;
+    }
+    catch(...)
+    {
+        delete pGroup;
+        throw;
+    }
 }
 
 void Bu::TafReader::groupContent( Bu::TafGroup *pGroup )
 {
-        for(;;)
-        {
-                ws();
-                if( c == '{' )
-                {
-                        pGroup->addChild( readGroup() );
-                        next();
-                }
-                else if( c == '}' )
-                        return;
-                else if( c == '/' && la == '*' )
-                        pGroup->addChild( readComment() );
-                else if( c == '/' && la == '/' )
-                        pGroup->addChild( readComment( true ) );
-                else if( c == ':' )
-                        throw TafException("%d:%d: Encountered stray ':' in taf stream.",
-                                iLine, iCol );
-                else
-                        pGroup->addChild( readProperty() );
-        }
+    for(;;)
+    {
+        ws();
+        if( c == '{' )
+        {
+            pGroup->addChild( readGroup() );
+            next();
+        }
+        else if( c == '}' )
+            return;
+        else if( c == '/' && la == '*' )
+            pGroup->addChild( readComment() );
+        else if( c == '/' && la == '/' )
+            pGroup->addChild( readComment( true ) );
+        else if( c == ':' )
+            throw TafException("%d:%d: Encountered stray ':' in taf stream.",
+                iLine, iCol );
+        else
+            pGroup->addChild( readProperty() );
+    }
 }
 
 Bu::TafProperty *Bu::TafReader::readProperty()
 {
-        String sName = readStr();
-        ws();
-        if( c != '=' )
-        {
-                //printf("  %s (true)\n", sName.getStr() );
-                return new Bu::TafProperty( "", sName );
-        }
-        next();
-        String sValue = readStr();
-        return new Bu::TafProperty( sName, sValue );
-        //printf("  %s = %s\n", sName.getStr(), sValue.getStr() );
+    String sName = readStr();
+    ws();
+    if( c != '=' )
+    {
+        //printf("  %s (true)\n", sName.getStr() );
+        return new Bu::TafProperty( "", sName );
+    }
+    next();
+    String sValue = readStr();
+    return new Bu::TafProperty( sName, sValue );
+    //printf("  %s = %s\n", sName.getStr(), sValue.getStr() );
 }
 
 Bu::TafComment *Bu::TafReader::readComment( bool bEOL )
 {
-        String sCmnt;
-        next();
-        if( bEOL )
-        {
-                for(;;)
-                {
-                        next();
-                        if( c == '\n' && la == '\r' )
-                        {
-                                next(); next();
-                                break;
-                        }
-                        else if( c == '\n' || c == '\r' )
-                        {
-                                next();
-                                break;
-                        }
-                        sCmnt += c;
-                }
-        }
-        else
-        {
-                for(;;)
-                {
-                        next();
-                        if( c == '*' && la == '/' )
-                        {
-                                next(); next();
-                                break;
-                        }
-                        sCmnt += c;
-                }
-        }
-
-        return new TafComment( sCmnt, bEOL );
+    String sCmnt;
+    next();
+    if( bEOL )
+    {
+        for(;;)
+        {
+            next();
+            if( c == '\n' && la == '\r' )
+            {
+                next(); next();
+                break;
+            }
+            else if( c == '\n' || c == '\r' )
+            {
+                next();
+                break;
+            }
+            sCmnt += c;
+        }
+    }
+    else
+    {
+        for(;;)
+        {
+            next();
+            if( c == '*' && la == '/' )
+            {
+                next(); next();
+                break;
+            }
+            sCmnt += c;
+        }
+    }
+
+    return new TafComment( sCmnt, bEOL );
 }
 
 Bu::String Bu::TafReader::readStr()
 {
-        ws();
-        String s;
-        if( c == '"' )
+    ws();
+    String s;
+    if( c == '"' )
         {
                 next();
                 for(;;)
@@ -162,7 +162,7 @@ Bu::String Bu::TafReader::readStr()
                                         c = (unsigned char)strtol( code, NULL, 16 );
                                 }
                                 else if( c == '"' )
-                                        c = '"';
+                    c = '"';
                                 else if( c == '\\' )
                                         c = '\\';
                                 else if( c == 'n' )
@@ -174,79 +174,79 @@ Bu::String Bu::TafReader::readStr()
                                                 iLine, iCol, c );
                         }
                         else if( c == '"' )
-                                break;
-                        s += c;
-                        next();
-                }
-                next();
-        }
-        else
-        {
-                for(;;)
-                {
-                        if( isws() || c == '}' || c == '{' || c == ':' || c == '=' )
-                                break;
-                        s += c;
-                        next();
-                }
-        }
-
-        return s;
+                break;
+            s += c;
+            next();
+        }
+        next();
+    }
+    else
+    {
+        for(;;)
+        {
+            if( isws() || c == '}' || c == '{' || c == ':' || c == '=' )
+                break;
+            s += c;
+            next();
+        }
+    }
+
+    return s;
 }
 
 void Bu::TafReader::ws()
 {
-        for(;;)
-        {
-                if( !isws() )
-                        return;
+    for(;;)
+    {
+        if( !isws() )
+            return;
 
-                next();
-        }
+        next();
+    }
 }
 
 bool Bu::TafReader::isws()
 {
-        return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
+    return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
 }
 
 void Bu::TafReader::next()
 {
-        if( c == '\n' )
-        {
-                iLine++;
-                iCol = 1;
-        }
-        else
-                iCol++;
-        if( c == '}' )
-        {
-                rawread( &c );
-                if( c != '}' )
-                        rawread( &la );
-        }
-        else
-        {
-                c = la;
-                if( c != '}' )
-                        rawread( &la );
-        }
+    if( c == '\n' )
+    {
+        iLine++;
+        iCol = 1;
+    }
+    else
+        iCol++;
+    if( c == '}' )
+    {
+        rawread( &c );
+        if( c != '}' )
+            rawread( &la );
+    }
+    else
+    {
+        c = la;
+        if( c != '}' )
+            rawread( &la );
+    }
 }
 
 void Bu::TafReader::rawread( char *c )
 {
-        if( sIn.read( c, 1 ) < 1 )
-        {
-                if( sIn.isEos() )
-                {
-                        throw TafException("%d:%d: Premature end of stream.",
-                                iLine, iCol, c );
-                }
-                else
-                {
-                        throw TafException("%d:%d: No data read, but not end of stream?",
-                                iLine, iCol, c );
-                }
-        }
+    if( sIn.read( c, 1 ) < 1 )
+    {
+        if( sIn.isEos() )
+        {
+            throw TafException("%d:%d: Premature end of stream.",
+                iLine, iCol, c );
+        }
+        else
+        {
+            throw TafException("%d:%d: No data read, but not end of stream?",
+                iLine, iCol, c );
+        }
+    }
 }
 
diff --git a/src/stable/tafreader.h b/src/stable/tafreader.h
index 0cf00a9..b3ced1b 100644
--- a/src/stable/tafreader.h
+++ b/src/stable/tafreader.h
@@ -13,37 +13,37 @@
 
 namespace Bu
 {
-        class TafNode;
-        class TafGroup;
-        class TafProperty;
-        class TafComment;
-        class Stream;
+    class TafNode;
+    class TafGroup;
+    class TafProperty;
+    class TafComment;
+    class Stream;
 
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafReader
-        {
-        public:
-                TafReader( Bu::Stream &sIn );
-                virtual ~TafReader();
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafReader
+    {
+    public:
+        TafReader( Bu::Stream &sIn );
+        virtual ~TafReader();
 
-                Bu::TafGroup *readGroup();
+        Bu::TafGroup *readGroup();
 
-        private:
-                void groupContent( Bu::TafGroup *pNode );
-                Bu::TafProperty *readProperty();
-                Bu::TafComment *readComment( bool bEOL=false );
-                void ws();
-                bool isws();
-                void next();
-                Bu::String readStr();
-                void rawread( char *c );
-                char c, la;
-                Bu::Stream &sIn;
-                int iLine, iCol;
-        };
+    private:
+        void groupContent( Bu::TafGroup *pNode );
+        Bu::TafProperty *readProperty();
+        Bu::TafComment *readComment( bool bEOL=false );
+        void ws();
+        bool isws();
+        void next();
+        Bu::String readStr();
+        void rawread( char *c );
+        char c, la;
+        Bu::Stream &sIn;
+        int iLine, iCol;
+    };
 }
 
 #endif
diff --git a/src/stable/tafwriter.cpp b/src/stable/tafwriter.cpp
index 00d9f68..f17a237 100644
--- a/src/stable/tafwriter.cpp
+++ b/src/stable/tafwriter.cpp
@@ -9,8 +9,8 @@
 #include "bu/stream.h"
 
 Bu::TafWriter::TafWriter( Bu::Stream &sOut ) :
-        sOut( sOut ),
-        iDepth( 0 )
+    sOut( sOut ),
+    iDepth( 0 )
 {
 }
 
@@ -20,81 +20,81 @@ Bu::TafWriter::~TafWriter()
 
 void Bu::TafWriter::ident()
 {
-        for( int j = 0; j < iDepth; j++ )
-                sOut.write("    ", 4 );
+    for( int j = 0; j < iDepth; j++ )
+        sOut.write("    ", 4 );
 }
 
 void Bu::TafWriter::writeGroup( const Bu::TafGroup *pRoot )
 {
-        ident();
-        sOut.write("{", 1 );
-        if( pRoot->getName().isSet() )
-                writeString( pRoot->getName() );
-        sOut.write(":\n", 2 );
-        iDepth++;
-        const Bu::TafGroup::NodeList &nl = pRoot->getChildren();
-        for( Bu::TafGroup::NodeList::const_iterator i = nl.begin(); i != nl.end(); i++ )
-        {
-                switch( (*i)->getType() )
-                {
-                        case Bu::TafNode::typeGroup:
-                                writeGroup( (Bu::TafGroup *)(*i) );
-                                break;
+    ident();
+    sOut.write("{", 1 );
+    if( pRoot->getName().isSet() )
+        writeString( pRoot->getName() );
+    sOut.write(":\n", 2 );
+    iDepth++;
+    const Bu::TafGroup::NodeList &nl = pRoot->getChildren();
+    for( Bu::TafGroup::NodeList::const_iterator i = nl.begin(); i != nl.end(); i++ )
+    {
+        switch( (*i)->getType() )
+        {
+            case Bu::TafNode::typeGroup:
+                writeGroup( (Bu::TafGroup *)(*i) );
+                break;
 
-                        case Bu::TafNode::typeProperty:
-                                writeProperty( (Bu::TafProperty *)(*i) );
-                                break;
+            case Bu::TafNode::typeProperty:
+                writeProperty( (Bu::TafProperty *)(*i) );
+                break;
 
-                        case Bu::TafNode::typeComment:
-                                writeComment( (Bu::TafComment *)(*i) );
-                                break;
-                }
-        }
-        iDepth--;
-        ident();
-        sOut.write("}\n", 2 );
+            case Bu::TafNode::typeComment:
+                writeComment( (Bu::TafComment *)(*i) );
+                break;
+        }
+    }
+    iDepth--;
+    ident();
+    sOut.write("}\n", 2 );
 }
 
 void Bu::TafWriter::writeProperty( const Bu::TafProperty *pProp )
 {
-        ident();
-        if( !pProp->getName().isEmpty() )
-        {
-                writeString( pProp->getName() );
-                sOut.write("=", 1 );
-                writeString( pProp->getValue() );
-        }
-        else
-        {
-                writeString( pProp->getValue() );
-        }
-        sOut.write("\n", 1 );
+    ident();
+    if( !pProp->getName().isEmpty() )
+    {
+        writeString( pProp->getName() );
+        sOut.write("=", 1 );
+        writeString( pProp->getValue() );
+    }
+    else
+    {
+        writeString( pProp->getValue() );
+    }
+    sOut.write("\n", 1 );
 }
 
 void Bu::TafWriter::writeComment( const Bu::TafComment *pComment )
 {
-        ident();
-        if( pComment->isEOLStyle() )
-        {
-                sOut.write("//", 2 );
-                sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
-                sOut.write("\n", 1 );
-        }
-        else
-        {
-                sOut.write("/*", 2 );
-                sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
-                sOut.write("*/ ", 3 );
-        }
+    ident();
+    if( pComment->isEOLStyle() )
+    {
+        sOut.write("//", 2 );
+        sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
+        sOut.write("\n", 1 );
+    }
+    else
+    {
+        sOut.write("/*", 2 );
+        sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
+        sOut.write("*/ ", 3 );
+    }
 }
 
 void Bu::TafWriter::writeString( const Bu::String &str )
 {
-        sOut.write("\"", 1 );
+    sOut.write("\"", 1 );
         for( Bu::String::const_iterator s = str.begin(); s != str.end(); s++ )
         {
                 if( *s == '\"' )
-                        sOut.write("\\\"", 2 );
+            sOut.write("\\\"", 2 );
                 else if( *s == '\\' )
                         sOut.write("\\\\", 2 );
                 else if( *s < 32 || *s > 126 )
diff --git a/src/stable/tafwriter.h b/src/stable/tafwriter.h
index 7e43d64..48787ab 100644
--- a/src/stable/tafwriter.h
+++ b/src/stable/tafwriter.h
@@ -14,32 +14,32 @@
 
 namespace Bu
 {
-        class Stream;
-        class TafNode;
-        class TafGroup;
-        class TafProperty;
-        class TafComment;
-
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafWriter
-        {
-        public:
-                TafWriter( Bu::Stream &sOut );
-                virtual ~TafWriter();
-
-                void writeGroup( const Bu::TafGroup *pRoot );
-
-        private:
-                void writeProperty( const Bu::TafProperty *pProp );
-                void writeComment( const Bu::TafComment *pComment );
-                void writeString( const Bu::String &str );
-                void ident();
-                Bu::Stream &sOut;
-                int iDepth;
-        };
+    class Stream;
+    class TafNode;
+    class TafGroup;
+    class TafProperty;
+    class TafComment;
+
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafWriter
+    {
+    public:
+        TafWriter( Bu::Stream &sOut );
+        virtual ~TafWriter();
+
+        void writeGroup( const Bu::TafGroup *pRoot );
+
+    private:
+        void writeProperty( const Bu::TafProperty *pProp );
+        void writeComment( const Bu::TafComment *pComment );
+        void writeString( const Bu::String &str );
+        void ident();
+        Bu::Stream &sOut;
+        int iDepth;
+    };
 }
 
 #endif
diff --git a/src/stable/tcpserversocket.cpp b/src/stable/tcpserversocket.cpp
index 91da199..aed7699 100644
--- a/src/stable/tcpserversocket.cpp
+++ b/src/stable/tcpserversocket.cpp
@@ -28,230 +28,230 @@
 namespace Bu { subExceptionDef( TcpServerSocketException ) }
 
 Bu::TcpServerSocket::TcpServerSocket( int nPort, int nPoolSize ) :
-        nPort( nPort )
+    nPort( nPort )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
-        
-        /* Create the socket and set it up to accept connections. */
-        struct sockaddr_in name;
+    
+    /* Create the socket and set it up to accept connections. */
+    struct sockaddr_in name;
 
-        /* Give the socket a name. */
-        name.sin_family = AF_INET;
-        name.sin_port = bu_htons( nPort );
+    /* Give the socket a name. */
+    name.sin_family = AF_INET;
+    name.sin_port = bu_htons( nPort );
 
-        // I think this specifies who we will accept connections from,
-        // a good thing to make configurable later on
-        name.sin_addr.s_addr = bu_htonl( INADDR_ANY );
+    // I think this specifies who we will accept connections from,
+    // a good thing to make configurable later on
+    name.sin_addr.s_addr = bu_htonl( INADDR_ANY );
 
-        startServer( name, nPoolSize );
+    startServer( name, nPoolSize );
 }
 
 Bu::TcpServerSocket::TcpServerSocket(const String &sAddr,int nPort, int nPoolSize) :
-        nPort( nPort )
+    nPort( nPort )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
 
-        /* Create the socket and set it up to accept connections. */
-        struct sockaddr_in name;
+    /* Create the socket and set it up to accept connections. */
+    struct sockaddr_in name;
 
-        /* Give the socket a name. */
-        name.sin_family = AF_INET;
+    /* Give the socket a name. */
+    name.sin_family = AF_INET;
 
-        name.sin_port = bu_htons( nPort );
+    name.sin_port = bu_htons( nPort );
 
 #ifdef WIN32
-        name.sin_addr.s_addr = bu_inet_addr( sAddr.getStr() );
+    name.sin_addr.s_addr = bu_inet_addr( sAddr.getStr() );
 #else
-        inet_aton( sAddr.getStr(), &name.sin_addr );
+    inet_aton( sAddr.getStr(), &name.sin_addr );
 #endif
 
-        startServer( name, nPoolSize );
+    startServer( name, nPoolSize );
 }
 
 Bu::TcpServerSocket::TcpServerSocket( socket_t nServer, bool bInit, int nPoolSize ) :
-        nServer( nServer ),
-        nPort( 0 )
+    nServer( nServer ),
+    nPort( 0 )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
-        
-        if( bInit )
-        {
-                struct sockaddr name;
-                socklen_t namelen = sizeof(name);
-                getpeername( nServer, &name, &namelen );
-
-                initServer( *((sockaddr_in *)&name), nPoolSize );
-        }
-        else
-        {
-                FD_ZERO( &fdActive );
-                FD_SET( nServer, &fdActive );
-        }
+    
+    if( bInit )
+    {
+        struct sockaddr name;
+        socklen_t namelen = sizeof(name);
+        getpeername( nServer, &name, &namelen );
+
+        initServer( *((sockaddr_in *)&name), nPoolSize );
+    }
+    else
+    {
+        FD_ZERO( &fdActive );
+        FD_SET( nServer, &fdActive );
+    }
 }
 
 Bu::TcpServerSocket::TcpServerSocket( const TcpServerSocket &rSrc )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
 
-        nServer = dup( rSrc.nServer );
-        nPort = rSrc.nPort;
-        FD_ZERO( &fdActive );
-        FD_SET( nServer, &fdActive );
+    nServer = dup( rSrc.nServer );
+    nPort = rSrc.nPort;
+    FD_ZERO( &fdActive );
+    FD_SET( nServer, &fdActive );
 }
 
 Bu::TcpServerSocket::~TcpServerSocket()
 {
 #ifdef WIN32
-        if( nServer != INVALID_SOCKET )
+    if( nServer != INVALID_SOCKET )
 #else
-        if( nServer > -1 )
+    if( nServer > -1 )
 #endif
-                ::close( nServer );
+        ::close( nServer );
 }
 
 void Bu::TcpServerSocket::startServer( struct sockaddr_in &name, int nPoolSize )
 {
-        /* Create the socket. */
-        nServer = bu_socket( PF_INET, SOCK_STREAM, 0 );
+    /* Create the socket. */
+    nServer = bu_socket( PF_INET, SOCK_STREAM, 0 );
 
 #ifdef WIN32
-        if( nServer == INVALID_SOCKET )
+    if( nServer == INVALID_SOCKET )
 #else
-        if( nServer < 0 )
+    if( nServer < 0 )
 #endif
-        {
-                throw Bu::TcpServerSocketException("Couldn't create a listen socket.");
-        }
-        
-        int opt = 1;
-        bu_setsockopt(
-                        nServer,
-                        SOL_SOCKET,
-                        SO_REUSEADDR,
-                        (char *)&opt,
-                        sizeof( opt )
-                        );
-
-        initServer( name, nPoolSize );
+    {
+        throw Bu::TcpServerSocketException("Couldn't create a listen socket.");
+    }
+    
+    int opt = 1;
+    bu_setsockopt(
+            nServer,
+            SOL_SOCKET,
+            SO_REUSEADDR,
+            (char *)&opt,
+            sizeof( opt )
+            );
+
+    initServer( name, nPoolSize );
 }
 
 void Bu::TcpServerSocket::initServer( struct sockaddr_in &name, int nPoolSize )
 {
-        if( bu_bind( nServer, (struct sockaddr *) &name, sizeof(name) ) < 0 )
-        {
-                throw Bu::TcpServerSocketException("Couldn't bind to the listen socket.");
-        }
-
-        if( bu_listen( nServer, nPoolSize ) < 0 )
-        {
-                throw Bu::TcpServerSocketException(
-                        "Couldn't begin listening to the server socket."
-                        );
-        }
-
-        FD_ZERO( &fdActive );
-        /* Initialize the set of active sockets. */
-        FD_SET( nServer, &fdActive );
+    if( bu_bind( nServer, (struct sockaddr *) &name, sizeof(name) ) < 0 )
+    {
+        throw Bu::TcpServerSocketException("Couldn't bind to the listen socket.");
+    }
+
+    if( bu_listen( nServer, nPoolSize ) < 0 )
+    {
+        throw Bu::TcpServerSocketException(
+            "Couldn't begin listening to the server socket."
+            );
+    }
+
+    FD_ZERO( &fdActive );
+    /* Initialize the set of active sockets. */
+    FD_SET( nServer, &fdActive );
 }
 
 int Bu::TcpServerSocket::getSocket()
 {
-        return nServer;
+    return nServer;
 }
 
 int Bu::TcpServerSocket::accept( int nTimeoutSec, int nTimeoutUSec )
 {
-        fd_set fdRead = fdActive;
+    fd_set fdRead = fdActive;
 
-        struct timeval xT;
+    struct timeval xT;
 
-        xT.tv_sec = nTimeoutSec;
-        xT.tv_usec = nTimeoutUSec;      
+    xT.tv_sec = nTimeoutSec;
+    xT.tv_usec = nTimeoutUSec;  
 
-        if( TEMP_FAILURE_RETRY(
-                bu_select( nServer+1, &fdRead, NULL, NULL, &xT )) < 0 )
-        {
-                throw Bu::TcpServerSocketException(
-                        "Error scanning for new connections: %s", strerror( errno )
-                        );
-        }
+    if( TEMP_FAILURE_RETRY(
+        bu_select( nServer+1, &fdRead, NULL, NULL, &xT )) < 0 )
+    {
+        throw Bu::TcpServerSocketException(
+            "Error scanning for new connections: %s", strerror( errno )
+            );
+    }
 
-        if( FD_ISSET( nServer, &fdRead ) )
-        {
-                struct sockaddr_in clientname;
-                socklen_t size;
-                int nClient;
+    if( FD_ISSET( nServer, &fdRead ) )
+    {
+        struct sockaddr_in clientname;
+        socklen_t size;
+        int nClient;
 
-                size = sizeof( clientname );
+        size = sizeof( clientname );
 #ifdef WIN32
-                nClient = bu_accept( nServer, (struct sockaddr *)&clientname, &size);
+        nClient = bu_accept( nServer, (struct sockaddr *)&clientname, &size);
 #else /* not-WIN32 */
 #ifdef __CYGWIN__
-                nClient = ::accept( nServer, (struct sockaddr *)&clientname,
-                                (int *)&size
-                                );
+        nClient = ::accept( nServer, (struct sockaddr *)&clientname,
+                (int *)&size
+                );
 #else /* not-cygwin */
 #ifdef __APPLE__
-                nClient = ::accept( nServer, (struct sockaddr *)&clientname, (socklen_t*)&size );
+        nClient = ::accept( nServer, (struct sockaddr *)&clientname, (socklen_t*)&size );
 #else /* linux */
-                nClient = ::accept( nServer, (struct sockaddr *)&clientname, &size );
+        nClient = ::accept( nServer, (struct sockaddr *)&clientname, &size );
 #endif /* __APPLE__ */
 #endif /* __CYGWIN__ */
 #endif /* WIN32 */
-                if( nClient < 0 )
-                {
-                        throw Bu::TcpServerSocketException(
-                                "Error accepting a new connection: %s", strerror( errno )
-                                );
-                }
+        if( nClient < 0 )
+        {
+            throw Bu::TcpServerSocketException(
+                "Error accepting a new connection: %s", strerror( errno )
+                );
+        }
 
 #ifndef WIN32
-                char tmpa[20];
-                inet_ntop( AF_INET, (void *)&clientname.sin_addr, tmpa, 20 );
-                //"New connection from host %s, port %hd.",
-                //  tmpa, ntohs (clientname.sin_port) );
+        char tmpa[20];
+        inet_ntop( AF_INET, (void *)&clientname.sin_addr, tmpa, 20 );
+        //"New connection from host %s, port %hd.",
+        //  tmpa, ntohs (clientname.sin_port) );
 #endif
-                
-                {
+        
+        {
 #ifndef WIN32
-                        int flags;
-                        flags = fcntl( nClient, F_GETFL, 0 );
-                        flags |= O_NONBLOCK;
-                        if( fcntl( nClient, F_SETFL, flags ) < 0)
-                        {
-                                throw Bu::TcpServerSocketException(
-                                        "Error setting option on client socket: %s",
-                                        strerror( errno )
-                                        );
-                        }
+            int flags;
+            flags = fcntl( nClient, F_GETFL, 0 );
+            flags |= O_NONBLOCK;
+            if( fcntl( nClient, F_SETFL, flags ) < 0)
+            {
+                throw Bu::TcpServerSocketException(
+                    "Error setting option on client socket: %s",
+                    strerror( errno )
+                    );
+            }
 #else
-                        //-------------------------
-                        // Set the socket I/O mode: In this case FIONBIO
-                        // enables or disables the blocking mode for the 
-                        // socket based on the numerical value of iMode.
-                        // If iMode = 0, blocking is enabled; 
-                        // If iMode != 0, non-blocking mode is enabled.
-                        u_long iMode = 1;
-                        bu_ioctlsocket(nClient, FIONBIO, &iMode);                       
+            //-------------------------
+            // Set the socket I/O mode: In this case FIONBIO
+            // enables or disables the blocking mode for the 
+            // socket based on the numerical value of iMode.
+            // If iMode = 0, blocking is enabled; 
+            // If iMode != 0, non-blocking mode is enabled.
+            u_long iMode = 1;
+            bu_ioctlsocket(nClient, FIONBIO, &iMode);           
 #endif
-                }
+        }
 
-                return nClient;
-        }
+        return nClient;
+    }
 
-        return -1;
+    return -1;
 }
 
 int Bu::TcpServerSocket::getPort()
 {
-        return nPort;
+    return nPort;
 }
 
diff --git a/src/stable/tcpserversocket.h b/src/stable/tcpserversocket.h
index 9776668..fd1d547 100644
--- a/src/stable/tcpserversocket.h
+++ b/src/stable/tcpserversocket.h
@@ -20,46 +20,46 @@
 
 namespace Bu
 {
-        subExceptionDecl( TcpServerSocketException );
+    subExceptionDecl( TcpServerSocketException );
 
-        /**
-         * A single tcp/ip server socket.  When created the server socket will bind
-         * to the specified interface and port, and immediately begin listening for
-         * connections.  When connections come in they are pooled by the networking
-         * drivers in the kernel until they are accepted, this means that failure
-         * to keep space in the connection pool will result in connection refusals.
-         *
-         * Although the accept function returns an integral file descriptor, it is
-         * designed to be used with the Socket class.
-         *
-         *@ingroup Serving
-         */
-        class TcpServerSocket
-        {
-        public:
+    /**
+     * A single tcp/ip server socket.  When created the server socket will bind
+     * to the specified interface and port, and immediately begin listening for
+     * connections.  When connections come in they are pooled by the networking
+     * drivers in the kernel until they are accepted, this means that failure
+     * to keep space in the connection pool will result in connection refusals.
+     *
+     * Although the accept function returns an integral file descriptor, it is
+     * designed to be used with the Socket class.
+     *
+     *@ingroup Serving
+     */
+    class TcpServerSocket
+    {
+    public:
 #ifdef WIN32
-                typedef unsigned int socket_t;
+        typedef unsigned int socket_t;
 #else
-                typedef int socket_t;
+        typedef int socket_t;
 #endif
-                TcpServerSocket( int nPort, int nPoolSize=40 );
-                TcpServerSocket( const String &sAddr, int nPort, int nPoolSize=40 );
-                TcpServerSocket( socket_t nSocket, bool bInit, int nPoolSize=40 );
-                TcpServerSocket( const TcpServerSocket &rSrc );
-                virtual ~TcpServerSocket();
+        TcpServerSocket( int nPort, int nPoolSize=40 );
+        TcpServerSocket( const String &sAddr, int nPort, int nPoolSize=40 );
+        TcpServerSocket( socket_t nSocket, bool bInit, int nPoolSize=40 );
+        TcpServerSocket( const TcpServerSocket &rSrc );
+        virtual ~TcpServerSocket();
 
-                int accept( int nTimeoutSec=0, int nTimeoutUSec=0 );
-                int getSocket();
-                int getPort();
+        int accept( int nTimeoutSec=0, int nTimeoutUSec=0 );
+        int getSocket();
+        int getPort();
 
-        private:
-                void startServer( struct sockaddr_in &name, int nPoolSize );
-                void initServer( struct sockaddr_in &name, int nPoolSize );
+    private:
+        void startServer( struct sockaddr_in &name, int nPoolSize );
+        void initServer( struct sockaddr_in &name, int nPoolSize );
 
-                fd_set fdActive;
-                socket_t nServer;
-                int nPort;
-        };
+        fd_set fdActive;
+        socket_t nServer;
+        int nPort;
+    };
 }
 
 #endif
diff --git a/src/stable/tcpsocket.cpp b/src/stable/tcpsocket.cpp
index fa79a36..b77f439 100644
--- a/src/stable/tcpsocket.cpp
+++ b/src/stable/tcpsocket.cpp
@@ -32,392 +32,392 @@
 namespace Bu { subExceptionDef( TcpSocketException ) }
 
 Bu::TcpSocket::TcpSocket( handle nTcpSocket ) :
-        nTcpSocket( nTcpSocket ),
-        bActive( true ),
-        bBlocking( true )
+    nTcpSocket( nTcpSocket ),
+    bActive( true ),
+    bBlocking( true )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
-        setAddress();
+    setAddress();
 }
 
 Bu::TcpSocket::TcpSocket( const Bu::String &sAddr, int nPort, int nTimeout,
-                bool bBlocking ) :
-        nTcpSocket( 0 ),
-        bActive( false ),
-        bBlocking( true )
+        bool bBlocking ) :
+    nTcpSocket( 0 ),
+    bActive( false ),
+    bBlocking( true )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
 
-        /* Create the socket. */
-        nTcpSocket = bu_socket( PF_INET, SOCK_STREAM, 0 );
-        
+    /* Create the socket. */
+    nTcpSocket = bu_socket( PF_INET, SOCK_STREAM, 0 );
+    
 #ifdef WIN32
-        if( nTcpSocket == INVALID_SOCKET )
+    if( nTcpSocket == INVALID_SOCKET )
 #else
-        if( nTcpSocket < 0 )
+    if( nTcpSocket < 0 )
 #endif
-        {
-                throw ExceptionBase("Couldn't create socket.\n");
-        }
+    {
+        throw ExceptionBase("Couldn't create socket.\n");
+    }
 
-        setBlocking( false );
+    setBlocking( false );
      
-        /* Connect to the server. */
-        //printf("Resolving hostname (%s)...\n", sAddr );
-        {
-                struct addrinfo *pAddr = NULL;
-                struct addrinfo aiHints;
-                memset( &aiHints, 0, sizeof(addrinfo) );
-                aiHints.ai_flags = AI_CANONNAME;
-                aiHints.ai_family = AF_INET;
-                aiHints.ai_socktype = SOCK_STREAM;
-                char ibuf[10]; 
-                sprintf( ibuf, "%d", nPort );
+    /* Connect to the server. */
+    //printf("Resolving hostname (%s)...\n", sAddr );
+    {
+        struct addrinfo *pAddr = NULL;
+        struct addrinfo aiHints;
+        memset( &aiHints, 0, sizeof(addrinfo) );
+        aiHints.ai_flags = AI_CANONNAME;
+        aiHints.ai_family = AF_INET;
+        aiHints.ai_socktype = SOCK_STREAM;
+        char ibuf[10]; 
+        sprintf( ibuf, "%d", nPort );
      
-                int ret;
-                if( (ret = bu_getaddrinfo(
-                        sAddr.getStr(), ibuf, &aiHints, &pAddr )) != 0 )
-                {
-                        close();
-                        throw Bu::TcpSocketException("Couldn't resolve hostname %s (%s).\n",
-                                sAddr.getStr(), bu_gai_strerror(ret));
-                }
-
-                bu_connect(
-                        nTcpSocket,
-                        pAddr->ai_addr,
-                        pAddr->ai_addrlen
-                        );
-
-                sAddress = pAddr->ai_canonname;
-
-                bu_freeaddrinfo( pAddr );
-        }
-
-        bActive = true;
-
-        if( nTimeout > 0 )
-        {
-                fd_set rfds, wfds, efds;
-                int retval;
-                
-                FD_ZERO(&rfds);
-                FD_SET(nTcpSocket, &rfds);
-                FD_ZERO(&wfds);
-                FD_SET(nTcpSocket, &wfds);
-                FD_ZERO(&efds);
-                FD_SET(nTcpSocket, &efds);
-
-                struct timeval tv;
-                tv.tv_sec = nTimeout;
-                tv.tv_usec = 0;
-                
-                retval = bu_select( nTcpSocket+1, &rfds, &wfds, &efds, &tv );
-
-                if( retval == 0 )
-                {
-                        close();
-                        throw ExceptionBase("Connection timeout.\n");
-                }
-                read( NULL, 0 ); // See if we can get any errors out of the way early.
-        }
-
-        if( bBlocking )
-                setBlocking( bBlocking );
+        int ret;
+        if( (ret = bu_getaddrinfo(
+            sAddr.getStr(), ibuf, &aiHints, &pAddr )) != 0 )
+        {
+            close();
+            throw Bu::TcpSocketException("Couldn't resolve hostname %s (%s).\n",
+                sAddr.getStr(), bu_gai_strerror(ret));
+        }
+
+        bu_connect(
+            nTcpSocket,
+            pAddr->ai_addr,
+            pAddr->ai_addrlen
+            );
+
+        sAddress = pAddr->ai_canonname;
+
+        bu_freeaddrinfo( pAddr );
+    }
+
+    bActive = true;
+
+    if( nTimeout > 0 )
+    {
+        fd_set rfds, wfds, efds;
+        int retval;
+        
+        FD_ZERO(&rfds);
+        FD_SET(nTcpSocket, &rfds);
+        FD_ZERO(&wfds);
+        FD_SET(nTcpSocket, &wfds);
+        FD_ZERO(&efds);
+        FD_SET(nTcpSocket, &efds);
+
+        struct timeval tv;
+        tv.tv_sec = nTimeout;
+        tv.tv_usec = 0;
+        
+        retval = bu_select( nTcpSocket+1, &rfds, &wfds, &efds, &tv );
+
+        if( retval == 0 )
+        {
+            close();
+            throw ExceptionBase("Connection timeout.\n");
+        }
+        read( NULL, 0 ); // See if we can get any errors out of the way early.
+    }
+
+    if( bBlocking )
+        setBlocking( bBlocking );
 }
 
 Bu::TcpSocket::~TcpSocket()
 {
-        close();
+    close();
 }
 
 void Bu::TcpSocket::close()
 {
-        if( bActive )
-        {
+    if( bActive )
+    {
 #ifndef WIN32
-                fsync( nTcpSocket );
+        fsync( nTcpSocket );
 #endif
 #ifdef WIN32
  #ifndef SHUT_RDWR
   #define SHUT_RDWR (SD_BOTH)
  #endif
 #endif
-                bu_shutdown( nTcpSocket, SHUT_RDWR );
-                ::close( nTcpSocket );
-        }
-        bActive = false;
+        bu_shutdown( nTcpSocket, SHUT_RDWR );
+        ::close( nTcpSocket );
+    }
+    bActive = false;
 }
 
 Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes )
 {
-        fd_set rfds;
-        FD_ZERO(&rfds);
-        FD_SET(nTcpSocket, &rfds);
-        struct timeval tv = {0, 0};
-        if( bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv ) < 0 )
-        {
-                int iErr = errno;
-                close();
-                throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
-        }
-        if( FD_ISSET( nTcpSocket, &rfds ) || bBlocking )
-        {
-                int nRead = TEMP_FAILURE_RETRY( 
-                        bu_recv( nTcpSocket, (char *) pBuf, nBytes, 0 ) );
-                if( nRead == 0 && nBytes > 0 )
-                {
-                        close();
-                        throw TcpSocketException( TcpSocketException::cClosed, "TcpSocket closed.");
-                }
-                if( nRead < 0 )
-                {
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(nTcpSocket, &rfds);
+    struct timeval tv = {0, 0};
+    if( bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv ) < 0 )
+    {
+        int iErr = errno;
+        close();
+        throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
+    }
+    if( FD_ISSET( nTcpSocket, &rfds ) || bBlocking )
+    {
+        int nRead = TEMP_FAILURE_RETRY( 
+            bu_recv( nTcpSocket, (char *) pBuf, nBytes, 0 ) );
+        if( nRead == 0 && nBytes > 0 )
+        {
+            close();
+            throw TcpSocketException( TcpSocketException::cClosed, "TcpSocket closed.");
+        }
+        if( nRead < 0 )
+        {
 #ifdef WIN32
-                        int iWSAError = bu_WSAGetLastError();
-                        if( iWSAError == WSAEWOULDBLOCK )
-                                return 0;
+            int iWSAError = bu_WSAGetLastError();
+            if( iWSAError == WSAEWOULDBLOCK )
+                return 0;
 #else
-                        if( errno == ENETRESET || errno == ECONNRESET )
-                        {
-                                close();
-                                throw TcpSocketException( TcpSocketException::cClosed,
-                                        strerror(errno) );
-                        }
-                        if( errno == EAGAIN )
-                                return 0;
-                        int iErr = errno;
-                        close();
-                        throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
+            if( errno == ENETRESET || errno == ECONNRESET )
+            {
+                close();
+                throw TcpSocketException( TcpSocketException::cClosed,
+                    strerror(errno) );
+            }
+            if( errno == EAGAIN )
+                return 0;
+            int iErr = errno;
+            close();
+            throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
 #endif
-                }
-                return nRead;
-        }
-        return 0;
+        }
+        return nRead;
+    }
+    return 0;
 }
 
 Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes,
-                uint32_t nSec, uint32_t nUSec )
+        uint32_t nSec, uint32_t nUSec )
 {
-        struct timeval tv;
-        Bu::size nRead = 0;
-        
-        fd_set rfds;
-        FD_ZERO(&rfds);
-        FD_SET(nTcpSocket, &rfds);
+    struct timeval tv;
+    Bu::size nRead = 0;
+    
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(nTcpSocket, &rfds);
 
 #ifdef WIN32
-        DWORD dwStart = GetTickCount();
-        uint64_t uOver = dwStart + ((nUSec / 1000) * (nSec * 1000));
-        DWORD dwEnd = uOver>4294967295U?uOver-4294967295U:uOver;
+    DWORD dwStart = GetTickCount();
+    uint64_t uOver = dwStart + ((nUSec / 1000) * (nSec * 1000));
+    DWORD dwEnd = uOver>4294967295U?uOver-4294967295U:uOver;
 #else
-        struct timeval nt, ct;
-        gettimeofday( &nt, NULL );
-        nt.tv_sec += nSec;
-        nt.tv_usec += nUSec;
+    struct timeval nt, ct;
+    gettimeofday( &nt, NULL );
+    nt.tv_sec += nSec;
+    nt.tv_usec += nUSec;
 #endif
 
-        for(;;)
-        {
-                tv.tv_sec = nSec;
-                tv.tv_usec = nUSec;
-                bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
-                nRead += read( ((char *)pBuf)+nRead, nBytes-nRead );
-                if( nRead >= nBytes )
-                        break;
+    for(;;)
+    {
+        tv.tv_sec = nSec;
+        tv.tv_usec = nUSec;
+        bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
+        nRead += read( ((char *)pBuf)+nRead, nBytes-nRead );
+        if( nRead >= nBytes )
+            break;
 #ifdef WIN32
-                DWORD dwNow = GetTickCount();
-                if( dwNow > dwEnd )
-                        break;
+        DWORD dwNow = GetTickCount();
+        if( dwNow > dwEnd )
+            break;
 #else
-                gettimeofday( &ct, NULL );
-                if( (ct.tv_sec > nt.tv_sec) ||
-                        (ct.tv_sec == nt.tv_sec &&
-                        ct.tv_usec >= nt.tv_usec) )
-                        break;
+        gettimeofday( &ct, NULL );
+        if( (ct.tv_sec > nt.tv_sec) ||
+            (ct.tv_sec == nt.tv_sec &&
+            ct.tv_usec >= nt.tv_usec) )
+            break;
 #endif
-        }
-        return nRead;
+    }
+    return nRead;
 }
 
 Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes )
 {
 //#ifdef WIN32
-        int nWrote = TEMP_FAILURE_RETRY( 
-                bu_send( nTcpSocket, (const char *) pBuf, nBytes, 0 ) );
+    int nWrote = TEMP_FAILURE_RETRY( 
+        bu_send( nTcpSocket, (const char *) pBuf, nBytes, 0 ) );
 //#else
-//      int nWrote = TEMP_FAILURE_RETRY( ::write( nTcpSocket, pBuf, nBytes ) );
+//  int nWrote = TEMP_FAILURE_RETRY( ::write( nTcpSocket, pBuf, nBytes ) );
 //#endif
-        if( nWrote < 0 )
-        {
+    if( nWrote < 0 )
+    {
 #ifdef WIN32
-                int iWSAError = bu_WSAGetLastError();
-                if( iWSAError == WSAEWOULDBLOCK )
-                        return 0;
+        int iWSAError = bu_WSAGetLastError();
+        if( iWSAError == WSAEWOULDBLOCK )
+            return 0;
 #else
-                if( errno == EAGAIN ) return 0;
+        if( errno == EAGAIN ) return 0;
 #endif
-                throw TcpSocketException( TcpSocketException::cWrite, strerror(errno) );
-        }
-        return nWrote;
+        throw TcpSocketException( TcpSocketException::cWrite, strerror(errno) );
+    }
+    return nWrote;
 }
 
 Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes, uint32_t nSec, uint32_t nUSec )
 {
-        struct timeval tv;
-        Bu::size nWrote = 0;
-        
-        fd_set wfds;
-        FD_ZERO(&wfds);
-        FD_SET(nTcpSocket, &wfds);
+    struct timeval tv;
+    Bu::size nWrote = 0;
+    
+    fd_set wfds;
+    FD_ZERO(&wfds);
+    FD_SET(nTcpSocket, &wfds);
 
 #ifdef WIN32
-        DWORD dwStart = GetTickCount();
-        uint64_t uOver = dwStart + ((nUSec / 1000) * (nSec * 1000));
-        DWORD dwEnd = uOver>4294967295U?uOver-4294967295U:uOver;
+    DWORD dwStart = GetTickCount();
+    uint64_t uOver = dwStart + ((nUSec / 1000) * (nSec * 1000));
+    DWORD dwEnd = uOver>4294967295U?uOver-4294967295U:uOver;
 #else
-        struct timeval nt, ct;
-        gettimeofday( &nt, NULL );
-        nt.tv_sec += nSec;
-        nt.tv_usec += nUSec;
+    struct timeval nt, ct;
+    gettimeofday( &nt, NULL );
+    nt.tv_sec += nSec;
+    nt.tv_usec += nUSec;
 #endif
 
-        for(;;)
-        {
-                tv.tv_sec = nSec;
-                tv.tv_usec = nUSec;
-                bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
-                nWrote += write( ((char *)pBuf)+nWrote, nBytes-nWrote );
-                if( nWrote >= nBytes )
-                        break;
+    for(;;)
+    {
+        tv.tv_sec = nSec;
+        tv.tv_usec = nUSec;
+        bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
+        nWrote += write( ((char *)pBuf)+nWrote, nBytes-nWrote );
+        if( nWrote >= nBytes )
+            break;
 #ifdef WIN32
-                DWORD dwNow = GetTickCount();
-                if( dwNow > dwEnd )
-                        break;
+        DWORD dwNow = GetTickCount();
+        if( dwNow > dwEnd )
+            break;
 #else
-                gettimeofday( &ct, NULL );
-                if( (ct.tv_sec > nt.tv_sec) ||
-                        (ct.tv_sec == nt.tv_sec &&
-                        ct.tv_usec >= nt.tv_usec) )
-                        break;
+        gettimeofday( &ct, NULL );
+        if( (ct.tv_sec > nt.tv_sec) ||
+            (ct.tv_sec == nt.tv_sec &&
+            ct.tv_usec >= nt.tv_usec) )
+            break;
 #endif
-        }
-        return nWrote;
+    }
+    return nWrote;
 }
 
 Bu::size Bu::TcpSocket::tell()
 {
-        throw UnsupportedException();
+    throw UnsupportedException();
 }
 
 void Bu::TcpSocket::seek( Bu::size )
 {
-        throw UnsupportedException();
+    throw UnsupportedException();
 }
 
 void Bu::TcpSocket::setPos( Bu::size )
 {
-        throw UnsupportedException();
+    throw UnsupportedException();
 }
 
 void Bu::TcpSocket::setPosEnd( Bu::size )
 {
-        throw UnsupportedException();
+    throw UnsupportedException();
 }
 
 bool Bu::TcpSocket::isEos()
 {
-        return !bActive;
+    return !bActive;
 }
 
 bool Bu::TcpSocket::canRead()
 {
-        fd_set rfds;
-        FD_ZERO(&rfds);
-        FD_SET(nTcpSocket, &rfds);
-        struct timeval tv = { 0, 0 };
-        int retval = bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
-        if( retval == -1 )
-                throw TcpSocketException(
-                        TcpSocketException::cBadRead,
-                        "Bad Read error"
-                        );
-
-        if( !FD_ISSET( nTcpSocket, &rfds ) )
-                return false;
-        return true;
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(nTcpSocket, &rfds);
+    struct timeval tv = { 0, 0 };
+    int retval = bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
+    if( retval == -1 )
+        throw TcpSocketException(
+            TcpSocketException::cBadRead,
+            "Bad Read error"
+            );
+
+    if( !FD_ISSET( nTcpSocket, &rfds ) )
+        return false;
+    return true;
 }
 
 bool Bu::TcpSocket::canWrite()
 {
-        fd_set wfds;
-        FD_ZERO(&wfds);
-        FD_SET(nTcpSocket, &wfds);
-        struct timeval tv = { 0, 0 };
-        int retval = bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
-        if( retval == -1 )
-                throw TcpSocketException(
-                        TcpSocketException::cBadRead,
-                        "Bad Read error"
-                        );
-        if( !FD_ISSET( nTcpSocket, &wfds ) )
-                return false;
-        return true;
+    fd_set wfds;
+    FD_ZERO(&wfds);
+    FD_SET(nTcpSocket, &wfds);
+    struct timeval tv = { 0, 0 };
+    int retval = bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
+    if( retval == -1 )
+        throw TcpSocketException(
+            TcpSocketException::cBadRead,
+            "Bad Read error"
+            );
+    if( !FD_ISSET( nTcpSocket, &wfds ) )
+        return false;
+    return true;
 }
 
 bool Bu::TcpSocket::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::TcpSocket::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::TcpSocket::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::TcpSocket::isBlocking()
 {
 #ifndef WIN32
-        return ((fcntl( nTcpSocket, F_GETFL, 0 ) & O_NONBLOCK) != O_NONBLOCK);
+    return ((fcntl( nTcpSocket, F_GETFL, 0 ) & O_NONBLOCK) != O_NONBLOCK);
 #else
-        return false;
+    return false;
 #endif
 }
 
 void Bu::TcpSocket::setBlocking( bool bBlocking )
 {
-        this->bBlocking = bBlocking;
+    this->bBlocking = bBlocking;
 #ifndef WIN32
-        if( bBlocking )
-        {
-                fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) & (~O_NONBLOCK) );
-        }
-        else
-        {
-                fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) | O_NONBLOCK );
-        }
+    if( bBlocking )
+    {
+        fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) & (~O_NONBLOCK) );
+    }
+    else
+    {
+        fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) | O_NONBLOCK );
+    }
 #else
-        u_long iMode;
-        if( bBlocking )
-                iMode = 0;
-        else
-                iMode = 1;
-        //-------------------------
-        // Set the socket I/O mode: In this case FIONBIO
-        // enables or disables the blocking mode for the 
-        // socket based on the numerical value of iMode.
-        // If iMode = 0, blocking is enabled; 
-        // If iMode != 0, non-blocking mode is enabled.
-        bu_ioctlsocket(nTcpSocket, FIONBIO, &iMode);
-#endif  
+    u_long iMode;
+    if( bBlocking )
+        iMode = 0;
+    else
+        iMode = 1;
+    //-------------------------
+    // Set the socket I/O mode: In this case FIONBIO
+    // enables or disables the blocking mode for the 
+    // socket based on the numerical value of iMode.
+    // If iMode = 0, blocking is enabled; 
+    // If iMode != 0, non-blocking mode is enabled.
+    bu_ioctlsocket(nTcpSocket, FIONBIO, &iMode);
+#endif  
 }
 
 void Bu::TcpSocket::setSize( Bu::size )
@@ -430,53 +430,53 @@ void Bu::TcpSocket::flush()
 
 bool Bu::TcpSocket::isOpen()
 {
-        return bActive;
+    return bActive;
 }
 
 void Bu::TcpSocket::setAddress()
 {
-        struct sockaddr_in addr;
-        socklen_t len = sizeof(addr);
-        addr.sin_family = AF_INET;
-        bu_getpeername( nTcpSocket, (sockaddr *)(&addr), &len );
-        sAddress = bu_inet_ntoa( addr.sin_addr );
+    struct sockaddr_in addr;
+    socklen_t len = sizeof(addr);
+    addr.sin_family = AF_INET;
+    bu_getpeername( nTcpSocket, (sockaddr *)(&addr), &len );
+    sAddress = bu_inet_ntoa( addr.sin_addr );
 }
 
 Bu::String Bu::TcpSocket::getAddress() const
 {
-        return sAddress;
+    return sAddress;
 }
 
 Bu::TcpSocket::operator Bu::TcpSocket::handle() const
 {
-        return nTcpSocket;
+    return nTcpSocket;
 }
 
 Bu::TcpSocket::handle Bu::TcpSocket::getHandle() const
 {
-        return nTcpSocket;
+    return nTcpSocket;
 }
 
 Bu::TcpSocket::handle Bu::TcpSocket::takeHandle()
 {
-        handle nRet = nTcpSocket;
-        bActive = false;
-        nTcpSocket = 0;
-        return nRet;
+    handle nRet = nTcpSocket;
+    bActive = false;
+    nTcpSocket = 0;
+    return nRet;
 }
 
 Bu::size Bu::TcpSocket::getSize() const
 {
-        throw UnsupportedException();
+    throw UnsupportedException();
 }
 
 Bu::size Bu::TcpSocket::getBlockSize() const
 {
-        return 1500; //TODO: Fix this, it's stupid.
+    return 1500; //TODO: Fix this, it's stupid.
 }
 
 Bu::String Bu::TcpSocket::getLocation() const
 {
-        return getAddress();
+    return getAddress();
 }
 
diff --git a/src/stable/tcpsocket.h b/src/stable/tcpsocket.h
index 92b3c1f..16eca12 100644
--- a/src/stable/tcpsocket.h
+++ b/src/stable/tcpsocket.h
@@ -17,110 +17,110 @@
 
 namespace Bu
 {
-        subExceptionDeclBegin( TcpSocketException );
-                enum {
-                        cRead,
-                        cWrite,
-                        cBadRead,
-                        cClosed,
-                        cTimeout
-                };
-        subExceptionDeclEnd();
-
-        /**
-         * Network socket stream class.  This class provides a mechanism for
-         * communicating over a network using TCP/IP.  It will provide other low
-         * level protocol and addressing support later on, but for now it's just
-         * standard STREAM TCP/IP sockets.
-         *
-         * Unlike system sockets, these sockets are opened by default in
-         * non-blocking mode, you can specify your own timeout for opening a socket,
-         * and a number of non-fatal error messages have been automatically handled
-         * and treated as standard no-data-available-yet situations on read.
-         *
-         * Please note that there is a condition that will occur eventually (at
-         * least on *nix systems) that will trigger a SIGPIPE condition.  This
-         * will terminate your program immediately unless handled properly.  Most
-         * people doing any connections with TcpSocket will want to put this in
-         * their program somewhere before they use it:
-         *@code
-         #include <signal.h>
-         ...
-         ...
-         ...
-         sigset( SIGPIPE, SIG_IGN ); // do this before you use a Bu::TcpSocket
-         @endcode
-         * When this is done, Bu::TcpSocket will simply throw a broken pipe
-         * exception just like every other error condition, allowing your program
-         * to handle it sanely.
-         *
-         *@ingroup Serving
-         *@ingroup Streams
-         */
-        class TcpSocket : public Stream
-        {
-        public:
+    subExceptionDeclBegin( TcpSocketException );
+        enum {
+            cRead,
+            cWrite,
+            cBadRead,
+            cClosed,
+            cTimeout
+        };
+    subExceptionDeclEnd();
+
+    /**
+     * Network socket stream class.  This class provides a mechanism for
+     * communicating over a network using TCP/IP.  It will provide other low
+     * level protocol and addressing support later on, but for now it's just
+     * standard STREAM TCP/IP sockets.
+     *
+     * Unlike system sockets, these sockets are opened by default in
+     * non-blocking mode, you can specify your own timeout for opening a socket,
+     * and a number of non-fatal error messages have been automatically handled
+     * and treated as standard no-data-available-yet situations on read.
+     *
+     * Please note that there is a condition that will occur eventually (at
+     * least on *nix systems) that will trigger a SIGPIPE condition.  This
+     * will terminate your program immediately unless handled properly.  Most
+     * people doing any connections with TcpSocket will want to put this in
+     * their program somewhere before they use it:
+     *@code
+     #include <signal.h>
+     ...
+     ...
+     ...
+     sigset( SIGPIPE, SIG_IGN ); // do this before you use a Bu::TcpSocket
+     @endcode
+     * When this is done, Bu::TcpSocket will simply throw a broken pipe
+     * exception just like every other error condition, allowing your program
+     * to handle it sanely.
+     *
+     *@ingroup Serving
+     *@ingroup Streams
+     */
+    class TcpSocket : public Stream
+    {
+    public:
 #ifdef WIN32
-                typedef unsigned int handle;
+        typedef unsigned int handle;
 #else
-                typedef int handle;
+        typedef int handle;
 #endif
 
-                TcpSocket( handle nTcpSocket );
-                TcpSocket( const String &sAddr, int nPort, int nTimeout=30,
-                                bool bBlocking=true );
-                virtual ~TcpSocket();
-                
-                virtual void close();
-                virtual size read( void *pBuf, size nBytes );
-                virtual size read( void *pBuf, size nBytes,
-                                uint32_t nSec, uint32_t nUSec=0 );
-                virtual size write( const void *pBuf, size nBytes );
-                virtual size write( const void *pBuf, size nBytes,
-                                uint32_t nSec, uint32_t nUSec=0 );
-                using Stream::write;
-
-                virtual size tell();
-                virtual void seek( size offset );
-                virtual void setPos( size pos );
-                virtual void setPosEnd( size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-
-                virtual void flush();
-
-                virtual bool canRead();
-                virtual bool canWrite();
-
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-
-                virtual void setSize( size iSize );
-
-                Bu::String getAddress() const;
-                operator handle() const;
-
-                handle getHandle() const;
-                handle takeHandle();
-
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-
-        private:
-                void setAddress();
-
-                handle nTcpSocket;
-                
-                bool bActive;
-                bool bBlocking;
-                String sReadBuf;
-                String sAddress;
-        };
+        TcpSocket( handle nTcpSocket );
+        TcpSocket( const String &sAddr, int nPort, int nTimeout=30,
+                bool bBlocking=true );
+        virtual ~TcpSocket();
+        
+        virtual void close();
+        virtual size read( void *pBuf, size nBytes );
+        virtual size read( void *pBuf, size nBytes,
+                uint32_t nSec, uint32_t nUSec=0 );
+        virtual size write( const void *pBuf, size nBytes );
+        virtual size write( const void *pBuf, size nBytes,
+                uint32_t nSec, uint32_t nUSec=0 );
+        using Stream::write;
+
+        virtual size tell();
+        virtual void seek( size offset );
+        virtual void setPos( size pos );
+        virtual void setPosEnd( size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+
+        virtual void flush();
+
+        virtual bool canRead();
+        virtual bool canWrite();
+
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+
+        virtual void setSize( size iSize );
+
+        Bu::String getAddress() const;
+        operator handle() const;
+
+        handle getHandle() const;
+        handle takeHandle();
+
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+
+    private:
+        void setAddress();
+
+        handle nTcpSocket;
+        
+        bool bActive;
+        bool bBlocking;
+        String sReadBuf;
+        String sAddress;
+    };
 }
 
 #endif
diff --git a/src/stable/thread.cpp b/src/stable/thread.cpp
index 30443e6..ddb7ff5 100644
--- a/src/stable/thread.cpp
+++ b/src/stable/thread.cpp
@@ -10,7 +10,7 @@
 namespace Bu { subExceptionDef( ThreadException ); }
 
 Bu::ThreadId::ThreadId( pthread_t tId ) :
-        tId( tId )
+    tId( tId )
 {
 }
 
@@ -20,12 +20,12 @@ Bu::ThreadId::ThreadId()
 
 bool Bu::ThreadId::operator==( const Bu::ThreadId &rhs )
 {
-        return pthread_equal( tId, rhs.tId );
+    return pthread_equal( tId, rhs.tId );
 }
 
 bool Bu::ThreadId::operator!=( const ThreadId &rhs )
 {
-        return !pthread_equal( tId, rhs.tId );
+    return !pthread_equal( tId, rhs.tId );
 }
 
 Bu::Thread::Thread()
@@ -38,45 +38,45 @@ Bu::Thread::~Thread()
 
 Bu::ThreadId Bu::Thread::currentThread()
 {
-        return ThreadId( pthread_self() );
+    return ThreadId( pthread_self() );
 }
 
 bool Bu::Thread::start()
 {
-        if( pthread_create( &ptHandle, NULL, threadRunner, this ) )
-        {
-                throw Bu::ThreadException("Could not start thread.");
-        }
+    if( pthread_create( &ptHandle, NULL, threadRunner, this ) )
+    {
+        throw Bu::ThreadException("Could not start thread.");
+    }
 
-        return true;
+    return true;
 }
 
 bool Bu::Thread::stop()
 {
-        pthread_cancel( ptHandle );
+    pthread_cancel( ptHandle );
 
-        return true;
+    return true;
 }
 
 void *Bu::Thread::threadRunner( void *pThread )
 {
-        ((Thread *)pThread)->run();
-        pthread_exit( NULL );
-        return NULL;
+    ((Thread *)pThread)->run();
+    pthread_exit( NULL );
+    return NULL;
 }
 
 bool Bu::Thread::join()
 {
-        pthread_join( ptHandle, NULL );
-        return true;
+    pthread_join( ptHandle, NULL );
+    return true;
 }
 
 void Bu::Thread::yield()
 {
 #ifndef WIN32
-        pthread_yield();
+    pthread_yield();
 #else
-        sched_yield();
+    sched_yield();
 #endif
 }
 
diff --git a/src/stable/thread.h b/src/stable/thread.h
index ae07665..ca3ab9f 100644
--- a/src/stable/thread.h
+++ b/src/stable/thread.h
@@ -15,120 +15,120 @@
 
 namespace Bu
 {
-        subExceptionDecl( ThreadException );
-        class ThreadId
-        {
-        friend class Thread;
-        private:
-                ThreadId( pthread_t tId );
-
-        public:
-                ThreadId();
-
-                bool operator==( const ThreadId &rhs );
-                bool operator!=( const ThreadId &rhs );
-
-        private:
-                pthread_t tId;
-        };
-
-        /**
-         * Simple thread class.  This wraps the basic pthread (posix threads)
-         * system in an object oriented sort of way.  It allows you to create a
-         * class with standard member variables and callable functions that can be
-         * run in it's own thread, one per class instance.
-         *@ingroup Threading
-         */
-        class Thread
-        {
-        public:
-                /**
-                 * Construct an Thread thread.
-                 */
-                Thread();
-
-                /**
-                 * Destroy an Thread thread.
-                 */
-                virtual ~Thread();
-
-                static ThreadId currentThread();
-                ThreadId getId() { return ThreadId( ptHandle ); }
-
-                /**
-                 * Begin thread execution.  This will call the overridden run function,
-                 * which will simply execute in it's own thread until the function
-                 * exits, the thread is killed, or the thread is cancelled (optionally).
-                 * The thread started in this manner has access to all of it's class
-                 * variables, but be sure to protect possible multiple-access with
-                 * ThreadMutex objects.
-                 * @returns True if starting the thread was successful.  False if
-                 * something went wrong and the thread has not started.
-                 */
-                bool start();
-
-                /**
-                 * Forcibly kill a thread.  This is not generally considered a good
-                 * thing to do, but in those rare cases you need it, it's invaluable.
-                 * The problem with stopping (or killing) a thread is that it stops it
-                 * the moment you call stop, no matter what it's doing.  The object
-                 * oriented approach to this will help clean up any class variables
-                 * that were used, but anything not managed as a member variable will
-                 * probably create a memory leak type of situation.  Instead of stop,
-                 * consider using cancel, which can be handled by the running thread in
-                 * a graceful manner.
-                 *@returns True if the thread was stopped, false otherwise.  When this
-                 * function returns the thread may not have stopped, to ensure that the
-                 * thread has really stopped, call join.
-                 */
-                bool stop();
-
-                /**
-                 * Join the thread in action.  This function performs what is commonly
-                 * called a thread join.  That is that it effectively makes the calling
-                 * thread an the Thread thread contained in the called object one in the
-                 * same, and pauses the calling thread until the called thread exits.
-                 * That is, when called from, say, your main(), mythread.join() will
-                 * not return until the thread mythread has exited.  This is very handy
-                 * at the end of programs to ensure all of your data was cleaned up.
-                 *@returns True if the thread was joined, false if the thread couldn't
-                 * be joined, usually because it isn't running to begin with.
-                 */
-                bool join();
-
-        private:
-                pthread_t ptHandle;     /**< Internal handle to the posix thread. */
-
-        protected:
-                /**
-                 * The workhorse of the Thread class.  This is the function that will
-                 * run in the thread, when this function exits the thread dies and is
-                 * cleaned up by the system.  Make sure to read up on Bu::Mutex,
-                 * Bu::Condition, and the Bu::Synchro* classes to see how to control
-                 * and protect everything you do in a safe way within this function.
-                 *@returns I'm not sure right now, but this is the posix standard form.
-                 */
-                virtual void run()=0;
-
-                /**
-                 * Gives up some cpu-time in the currently running thread.  If a thread
-                 * is working hard, but you want to give other threads on the system
-                 * some time to do some work, call yield.
-                 */
-                void yield();
-
-        private:
-                /**
-                 * This is the hidden-heart of the thread system.  While run is what the
-                 * user gets to override, and everything said about it is true, this is
-                 * the function that actually makes up the thread, it simply calls the
-                 * run member function in an OO-friendly way.  This is what allows us to
-                 * use member variables from within the thread itself.
-                 *@param pThread Should always be this.
-                 *@returns This is specified by posix, I'm not sure yet.
-                 */
-                static void *threadRunner( void *pThread );
-        };
+    subExceptionDecl( ThreadException );
+    class ThreadId
+    {
+    friend class Thread;
+    private:
+        ThreadId( pthread_t tId );
+
+    public:
+        ThreadId();
+
+        bool operator==( const ThreadId &rhs );
+        bool operator!=( const ThreadId &rhs );
+
+    private:
+        pthread_t tId;
+    };
+
+    /**
+     * Simple thread class.  This wraps the basic pthread (posix threads)
+     * system in an object oriented sort of way.  It allows you to create a
+     * class with standard member variables and callable functions that can be
+     * run in it's own thread, one per class instance.
+     *@ingroup Threading
+     */
+    class Thread
+    {
+    public:
+        /**
+         * Construct an Thread thread.
+         */
+        Thread();
+
+        /**
+         * Destroy an Thread thread.
+         */
+        virtual ~Thread();
+
+        static ThreadId currentThread();
+        ThreadId getId() { return ThreadId( ptHandle ); }
+
+        /**
+         * Begin thread execution.  This will call the overridden run function,
+         * which will simply execute in it's own thread until the function
+         * exits, the thread is killed, or the thread is cancelled (optionally).
+         * The thread started in this manner has access to all of it's class
+         * variables, but be sure to protect possible multiple-access with
+         * ThreadMutex objects.
+         * @returns True if starting the thread was successful.  False if
+         * something went wrong and the thread has not started.
+         */
+        bool start();
+
+        /**
+         * Forcibly kill a thread.  This is not generally considered a good
+         * thing to do, but in those rare cases you need it, it's invaluable.
+         * The problem with stopping (or killing) a thread is that it stops it
+         * the moment you call stop, no matter what it's doing.  The object
+         * oriented approach to this will help clean up any class variables
+         * that were used, but anything not managed as a member variable will
+         * probably create a memory leak type of situation.  Instead of stop,
+         * consider using cancel, which can be handled by the running thread in
+         * a graceful manner.
+         *@returns True if the thread was stopped, false otherwise.  When this
+         * function returns the thread may not have stopped, to ensure that the
+         * thread has really stopped, call join.
+         */
+        bool stop();
+
+        /**
+         * Join the thread in action.  This function performs what is commonly
+         * called a thread join.  That is that it effectively makes the calling
+         * thread an the Thread thread contained in the called object one in the
+         * same, and pauses the calling thread until the called thread exits.
+         * That is, when called from, say, your main(), mythread.join() will
+         * not return until the thread mythread has exited.  This is very handy
+         * at the end of programs to ensure all of your data was cleaned up.
+         *@returns True if the thread was joined, false if the thread couldn't
+         * be joined, usually because it isn't running to begin with.
+         */
+        bool join();
+
+    private:
+        pthread_t ptHandle; /**< Internal handle to the posix thread. */
+
+    protected:
+        /**
+         * The workhorse of the Thread class.  This is the function that will
+         * run in the thread, when this function exits the thread dies and is
+         * cleaned up by the system.  Make sure to read up on Bu::Mutex,
+         * Bu::Condition, and the Bu::Synchro* classes to see how to control
+         * and protect everything you do in a safe way within this function.
+         *@returns I'm not sure right now, but this is the posix standard form.
+         */
+        virtual void run()=0;
+
+        /**
+         * Gives up some cpu-time in the currently running thread.  If a thread
+         * is working hard, but you want to give other threads on the system
+         * some time to do some work, call yield.
+         */
+        void yield();
+
+    private:
+        /**
+         * This is the hidden-heart of the thread system.  While run is what the
+         * user gets to override, and everything said about it is true, this is
+         * the function that actually makes up the thread, it simply calls the
+         * run member function in an OO-friendly way.  This is what allows us to
+         * use member variables from within the thread itself.
+         *@param pThread Should always be this.
+         *@returns This is specified by posix, I'm not sure yet.
+         */
+        static void *threadRunner( void *pThread );
+    };
 }
 
 #endif
diff --git a/src/stable/trace.cpp b/src/stable/trace.cpp
index c072fd9..2b3b863 100644
--- a/src/stable/trace.cpp
+++ b/src/stable/trace.cpp
@@ -9,59 +9,59 @@
 
 void Bu::__tracer( const char *pf )
 {
-        printf("trace: %s\n", pf );
+    printf("trace: %s\n", pf );
 }
 
 template<> void Bu::__tracer_format<float>( const float &v )
 {
-        printf("%f", v );
+    printf("%f", v );
 }
 
 template<> void Bu::__tracer_format<double>( const double &v )
 {
-        printf("%f", v );
+    printf("%f", v );
 }
 
 template<> void Bu::__tracer_format<void *>( void * const &v )
 {
-        printf("0x%08X", (ptrdiff_t)v );
+    printf("0x%08X", (ptrdiff_t)v );
 }
 
 template<> void Bu::__tracer_format<char *>( char * const &v )
 {
-        printf("\"%s\"", v );
+    printf("\"%s\"", v );
 }
 
 template<> void Bu::__tracer_format<char **>( char ** const &v )
 {
-        printf("[");
-        for( int j = 0; v[j]; j++ )
-        {
-                if( j > 0 )
-                        printf(", ");
-                printf("\"%s\"", v[j] );
-        }
-        printf("]");
+    printf("[");
+    for( int j = 0; v[j]; j++ )
+    {
+        if( j > 0 )
+            printf(", ");
+        printf("\"%s\"", v[j] );
+    }
+    printf("]");
 }
 
 template<> void Bu::__tracer_format<void const *>( void const * const &v )
 {
-        printf("0x%08X", (ptrdiff_t)v );
+    printf("0x%08X", (ptrdiff_t)v );
 }
 
 template<> void Bu::__tracer_format<char const *>( char const * const &v )
 {
-        printf("\"%s\"", v );
+    printf("\"%s\"", v );
 }
 
 template<> void Bu::__tracer_format<char const **>( char const ** const &v )
 {
-        printf("[");
-        for( int j = 0; v[j]; j++ )
-        {
-                if( j > 0 )
-                        printf(", ");
-                printf("\"%s\"", v[j] );
-        }
-        printf("]");
+    printf("[");
+    for( int j = 0; v[j]; j++ )
+    {
+        if( j > 0 )
+            printf(", ");
+        printf("\"%s\"", v[j] );
+    }
+    printf("]");
 }
diff --git a/src/stable/trace.h b/src/stable/trace.h
index da67f03..d47df9c 100644
--- a/src/stable/trace.h
+++ b/src/stable/trace.h
@@ -17,165 +17,165 @@
 
 namespace Bu
 {
-/*      template<typename t> void __tracer_format( t &v )
-        {
-                __tracer_format( *const_cast<const t *>(&v) );
-        }
+/*  template<typename t> void __tracer_format( t &v )
+    {
+        __tracer_format( *const_cast<const t *>(&v) );
+    }
 */
-        template<typename t> void __tracer_format( const t &v )
-        {
-                Bu::sio << v;
-        }
+    template<typename t> void __tracer_format( const t &v )
+    {
+        Bu::sio << v;
+    }
 
-        void __tracer( const char *pf );
+    void __tracer( const char *pf );
 
-        #define looper( vv )                                                            \
-                for( ; *n; n++ )                                                                \
-                {                                                                                               \
-                        if( bInBracket == true )                                        \
-                        {                                                                                       \
-                                if( *n == '>' )                                                 \
-                                        bInBracket = false;                                     \
-                        }                                                                                       \
-                        else if( *n == ',' || *n == ')' )                       \
-                        {                                                                                       \
-                                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, 1, stdout );      \
-                                fwrite("=", 1, 1, stdout);                              \
-                                __tracer_format( vv );                                  \
-                                s = n;                                                                  \
-                                n++;                                                                    \
-                                break;                                                                  \
-                        }                                                                                       \
-                        else if( *n == '<' )                                            \
-                        {                                                                                       \
-                                bInBracket = true;                                              \
-                        }                                                                                       \
-                } (void)0
-        
-        template<typename t1> void __tracer( const char *pf, t1 &v1 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2> void __tracer( const char *pf,
-                t1 &v1, t2 &v2 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2, typename t3>
-        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                looper( v3 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2, typename t3, typename t4>
-        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                looper( v3 );
-                looper( v4 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2, typename t3, typename t4, typename t5>
-        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                looper( v3 );
-                looper( v4 );
-                looper( v5 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2, typename t3, typename t4, typename t5,
-        typename t6>
-        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5,
-                t6 &v6)
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                looper( v3 );
-                looper( v4 );
-                looper( v5 );
-                looper( v6 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2, typename t3, typename t4, typename t5,
-        typename t6, typename t7>
-        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5,
-                t6 &v6, t7 &v7 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                looper( v3 );
-                looper( v4 );
-                looper( v5 );
-                looper( v6 );
-                looper( v7 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
+    #define looper( vv )                                \
+        for( ; *n; n++ )                                \
+        {                                               \
+            if( bInBracket == true )                    \
+            {                                           \
+                if( *n == '>' )                         \
+                    bInBracket = false;                 \
+            }                                           \
+            else if( *n == ',' || *n == ')' )           \
+            {                                           \
+                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, 1, stdout );  \
+                fwrite("=", 1, 1, stdout);              \
+                __tracer_format( vv );                  \
+                s = n;                                  \
+                n++;                                    \
+                break;                                  \
+            }                                           \
+            else if( *n == '<' )                        \
+            {                                           \
+                bInBracket = true;                      \
+            }                                           \
+        } (void)0
+    
+    template<typename t1> void __tracer( const char *pf, t1 &v1 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2> void __tracer( const char *pf,
+        t1 &v1, t2 &v2 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2, typename t3>
+    void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        looper( v3 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2, typename t3, typename t4>
+    void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        looper( v3 );
+        looper( v4 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2, typename t3, typename t4, typename t5>
+    void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        looper( v3 );
+        looper( v4 );
+        looper( v5 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2, typename t3, typename t4, typename t5,
+    typename t6>
+    void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5,
+        t6 &v6)
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        looper( v3 );
+        looper( v4 );
+        looper( v5 );
+        looper( v6 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2, typename t3, typename t4, typename t5,
+    typename t6, typename t7>
+    void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5,
+        t6 &v6, t7 &v7 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        looper( v3 );
+        looper( v4 );
+        looper( v5 );
+        looper( v6 );
+        looper( v7 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
 #undef looper
-        
-        template<> void __tracer_format<float>( const float &v );
-        template<> void __tracer_format<double>( const double &v );
-        template<> void __tracer_format<void *>( void * const &v );
-        template<> void __tracer_format<char *>( char * const &v );
-        template<> void __tracer_format<char **>( char ** const &v );
-        template<> void __tracer_format<void const *>( void const * const &v );
-        template<> void __tracer_format<char const *>( char const * const &v );
-        template<> void __tracer_format<char const **>( char const ** const &v );
+    
+    template<> void __tracer_format<float>( const float &v );
+    template<> void __tracer_format<double>( const double &v );
+    template<> void __tracer_format<void *>( void * const &v );
+    template<> void __tracer_format<char *>( char * const &v );
+    template<> void __tracer_format<char **>( char ** const &v );
+    template<> void __tracer_format<void const *>( void const * const &v );
+    template<> void __tracer_format<char const *>( char const * const &v );
+    template<> void __tracer_format<char const **>( char const ** const &v );
 }
 
 #ifdef BU_TRACE
diff --git a/src/stable/unitsuite.cpp b/src/stable/unitsuite.cpp
index b6057d0..e0606e6 100644
--- a/src/stable/unitsuite.cpp
+++ b/src/stable/unitsuite.cpp
@@ -17,14 +17,14 @@ using namespace Bu;
 #include <unistd.h>
 
 Bu::UnitSuite::UnitSuite() :
-        iOptions( 0 ),
-        iNameWidth( 0 )
+    iOptions( 0 ),
+    iNameWidth( 0 )
 {
 }
 
 Bu::UnitSuite::UnitSuite( int iOptions ) :
-        iOptions( iOptions ),
-        iNameWidth( 0 )
+    iOptions( iOptions ),
+    iNameWidth( 0 )
 {
 }
 
@@ -34,240 +34,240 @@ Bu::UnitSuite::~UnitSuite()
 
 int Bu::UnitSuite::run( int argc, char *argv[] )
 {
-        bool bCleanup = true;
-        OptParser p;
-        p.addOption( Bu::slot( this, &Bu::UnitSuite::onListCases ), 'l', "list",
-                        "List available test cases." );
-        p.addOption( bCleanup, "no-cleanup", "Don't erase temp files.");
-        p.setOverride( "no-cleanup", false );
-        p.setNonOption( Bu::slot( this, &Bu::UnitSuite::onAddTest ) );
-        p.addHelpOption();
-        p.parse( argc, argv );
-
-        if( !hSelTests.isEmpty() )
-        {
-                TestList lSub;
-                for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
-                {
-                        if( hSelTests.has( (*i).sName ) )
-                                lSub.append( *i );
-                }
-
-                lTests = lSub;
-        }
-
-        int iEPass = 0;
-        int iEFail = 0;
-        int iUPass = 0;
-        int iUFail = 0;
-        for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
-        {
-                sio << Fmt( iNameWidth+3, Fmt::Left ).fill('.') << i->sName
-                        << sio.flush;
-                try
-                {
-                        iStepCount = -1;
-                        iProgress = 0;
-                        (this->*(i->fTest))();
-                        switch( i->eExpect )
-                        {
-                                case expectPass:
-                                        sio << "pass." << sio.nl;
-                                        iEPass++;
-                                        break;
-
-                                case expectFail:
-                                        sio << "unexpected pass." << sio.nl;
-                                        iUPass++;
-                                        break;
-                        }
-                }
-                catch( Failed &e )
-                {
-                        switch( i->eExpect )
-                        {
-                                case expectPass:
-                                        sio << "unexpected ";
-                                        iUFail++;
-                                        break;
-
-                                case expectFail:
-                                        sio << "expected ";
-                                        iEFail++;
-                                        break;
-                        }
-                        if( e.bFile )
-                        {
-                                sio << "fail in unitTest(" << e.str << "). (" << e.sFile
-                                        << ":" << e.nLine << ")." << sio.nl;
-                        }
-                        else
-                        {
-                                sio << "fail in unitTest(" << e.str << ")." << sio.nl;
-                        }
-
-                        if( (iOptions & optStopOnError) )
-                                return 0;
-                }
-                catch( std::exception &e )
-                {
-                        switch( i->eExpect )
-                        {
-                                case expectPass:
-                                        sio << "unexpected ";
-                                        iUFail++;
-                                        break;
-
-                                case expectFail:
-                                        sio << "expected ";
-                                        iEFail++;
-                                        break;
-                        }
-                        sio << "fail with unknown exception.  what: " << e.what() << sio.nl;
-
-                        if( (iOptions & optStopOnError) )
-                                return 0;
-                }
-                catch( ... )
-                {
-                        switch( i->eExpect )
-                        {
-                                case expectPass:
-                                        sio << "unexpected ";
-                                        iUFail++;
-                                        break;
-
-                                case expectFail:
-                                        sio << "expected ";
-                                        iEFail++;
-                                        break;
-                        }
-                        sio << "fail with external exception." << sio.nl;
-
-                        if( (iOptions & optStopOnError) )
-                                return 0;
-                }
-        }
-
-        sio << sio.nl
-                << "Report:" << sio.nl
-                << "\tTotal tests run:     " << lTests.getSize() << sio.nl
-                << "\tExpected passes:     " << iEPass << sio.nl
-                << "\tExpected failures:   " << iEFail << sio.nl
-                << "\tUnexpected passes:   " << iUPass << sio.nl
-                << "\tUnexpected failures: " << iUFail << sio.nl << sio.nl;
-        if( iUPass == 0 && iUFail == 0 )
-                sio << "\tNothing unexpected." << sio.nl << sio.nl;
-
-        if( bCleanup )
-        {
-                for( StrList::iterator i = lFileCleanup.begin(); i; i++ )
-                {
-                        unlink( (*i).getStr() );
-                }
-        }
-
-        return 0;
+    bool bCleanup = true;
+    OptParser p;
+    p.addOption( Bu::slot( this, &Bu::UnitSuite::onListCases ), 'l', "list",
+            "List available test cases." );
+    p.addOption( bCleanup, "no-cleanup", "Don't erase temp files.");
+    p.setOverride( "no-cleanup", false );
+    p.setNonOption( Bu::slot( this, &Bu::UnitSuite::onAddTest ) );
+    p.addHelpOption();
+    p.parse( argc, argv );
+
+    if( !hSelTests.isEmpty() )
+    {
+        TestList lSub;
+        for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
+        {
+            if( hSelTests.has( (*i).sName ) )
+                lSub.append( *i );
+        }
+
+        lTests = lSub;
+    }
+
+    int iEPass = 0;
+    int iEFail = 0;
+    int iUPass = 0;
+    int iUFail = 0;
+    for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
+    {
+        sio << Fmt( iNameWidth+3, Fmt::Left ).fill('.') << i->sName
+            << sio.flush;
+        try
+        {
+            iStepCount = -1;
+            iProgress = 0;
+            (this->*(i->fTest))();
+            switch( i->eExpect )
+            {
+                case expectPass:
+                    sio << "pass." << sio.nl;
+                    iEPass++;
+                    break;
+
+                case expectFail:
+                    sio << "unexpected pass." << sio.nl;
+                    iUPass++;
+                    break;
+            }
+        }
+        catch( Failed &e )
+        {
+            switch( i->eExpect )
+            {
+                case expectPass:
+                    sio << "unexpected ";
+                    iUFail++;
+                    break;
+
+                case expectFail:
+                    sio << "expected ";
+                    iEFail++;
+                    break;
+            }
+            if( e.bFile )
+            {
+                sio << "fail in unitTest(" << e.str << "). (" << e.sFile
+                    << ":" << e.nLine << ")." << sio.nl;
+            }
+            else
+            {
+                sio << "fail in unitTest(" << e.str << ")." << sio.nl;
+            }
+
+            if( (iOptions & optStopOnError) )
+                return 0;
+        }
+        catch( std::exception &e )
+        {
+            switch( i->eExpect )
+            {
+                case expectPass:
+                    sio << "unexpected ";
+                    iUFail++;
+                    break;
+
+                case expectFail:
+                    sio << "expected ";
+                    iEFail++;
+                    break;
+            }
+            sio << "fail with unknown exception.  what: " << e.what() << sio.nl;
+
+            if( (iOptions & optStopOnError) )
+                return 0;
+        }
+        catch( ... )
+        {
+            switch( i->eExpect )
+            {
+                case expectPass:
+                    sio << "unexpected ";
+                    iUFail++;
+                    break;
+
+                case expectFail:
+                    sio << "expected ";
+                    iEFail++;
+                    break;
+            }
+            sio << "fail with external exception." << sio.nl;
+
+            if( (iOptions & optStopOnError) )
+                return 0;
+        }
+    }
+
+    sio << sio.nl
+        << "Report:" << sio.nl
+        << "\tTotal tests run:     " << lTests.getSize() << sio.nl
+        << "\tExpected passes:     " << iEPass << sio.nl
+        << "\tExpected failures:   " << iEFail << sio.nl
+        << "\tUnexpected passes:   " << iUPass << sio.nl
+        << "\tUnexpected failures: " << iUFail << sio.nl << sio.nl;
+    if( iUPass == 0 && iUFail == 0 )
+        sio << "\tNothing unexpected." << sio.nl << sio.nl;
+
+    if( bCleanup )
+    {
+        for( StrList::iterator i = lFileCleanup.begin(); i; i++ )
+        {
+            unlink( (*i).getStr() );
+        }
+    }
+
+    return 0;
 }
 
 Bu::File Bu::UnitSuite::tempFile( Bu::String &sFileName )
 {
-        Bu::File f = Bu::File::tempFile( sFileName );
-        lFileCleanup.append( sFileName );
-        return f;
+    Bu::File f = Bu::File::tempFile( sFileName );
+    lFileCleanup.append( sFileName );
+    return f;
 }
 
 void Bu::UnitSuite::add( Test fTest, const Bu::String &sName, Expect e )
 {
-        TestInfo ti;
-        ti.sName = sName;
-        ti.eExpect = e;
-        long index = ti.sName.rfindIdx("::");
-        if( index != -1 )
-        {
-                String tmp = sSuiteName;
-                tmp += ti.sName.getStr()+index;
-                ti.sName = tmp;
-        }
-        ti.fTest = fTest;
-        lTests.append( ti );
-        if( iNameWidth < ti.sName.getSize() )
-                iNameWidth = ti.sName.getSize();
+    TestInfo ti;
+    ti.sName = sName;
+    ti.eExpect = e;
+    long index = ti.sName.rfindIdx("::");
+    if( index != -1 )
+    {
+        String tmp = sSuiteName;
+        tmp += ti.sName.getStr()+index;
+        ti.sName = tmp;
+    }
+    ti.fTest = fTest;
+    lTests.append( ti );
+    if( iNameWidth < ti.sName.getSize() )
+        iNameWidth = ti.sName.getSize();
 }
 
 void Bu::UnitSuite::setName( const String &sName )
 {
-        sSuiteName = sName;
+    sSuiteName = sName;
 }
 
 void Bu::UnitSuite::dispProgress()
 {
-        if( tLastUpdate == time( NULL ) )
-                return;
-        sio << Fmt(3) << (iProgress*100/iStepCount) << "%" << "\b\b\b\b"
-                << sio.flush;
-        tLastUpdate = time( NULL );
+    if( tLastUpdate == time( NULL ) )
+        return;
+    sio << Fmt(3) << (iProgress*100/iStepCount) << "%" << "\b\b\b\b"
+        << sio.flush;
+    tLastUpdate = time( NULL );
 }
 
 void Bu::UnitSuite::setStepCount( int iSteps )
 {
-        iStepCount = iSteps;
-        if( iStepCount < 0 )
-                return;
-        tLastUpdate = 0;
-        dispProgress();
+    iStepCount = iSteps;
+    if( iStepCount < 0 )
+        return;
+    tLastUpdate = 0;
+    dispProgress();
 }
 
 void Bu::UnitSuite::incProgress( int iAmnt )
 {
-        iProgress += iAmnt;
-        if( iProgress < 0 )
-                iProgress = 0;
-        if( iProgress > iStepCount )
-                iProgress = iStepCount;
-        dispProgress();
+    iProgress += iAmnt;
+    if( iProgress < 0 )
+        iProgress = 0;
+    if( iProgress > iStepCount )
+        iProgress = iStepCount;
+    dispProgress();
 }
 
 void Bu::UnitSuite::setProgress( int iAmnt )
 {
-        iProgress = iAmnt;
-        if( iProgress < 0 )
-                iProgress = 0;
-        if( iProgress > iStepCount )
-                iProgress = iStepCount;
-        dispProgress();
+    iProgress = iAmnt;
+    if( iProgress < 0 )
+        iProgress = 0;
+    if( iProgress > iStepCount )
+        iProgress = iStepCount;
+    dispProgress();
 }
 
 int Bu::UnitSuite::onListCases( StrArray )
 {
-        sio << "Test cases:" << sio.nl;
-        for( TestList::iterator i = lTests.begin(); i; i++ )
-        {
-                sio << "\t- " << Fmt( iNameWidth, 10, Fmt::Left ) << (*i).sName << "  "
-                        << (*i).eExpect << sio.nl;
-        }
-        sio << sio.nl;
-        exit( 0 );
-        return 0;
+    sio << "Test cases:" << sio.nl;
+    for( TestList::iterator i = lTests.begin(); i; i++ )
+    {
+        sio << "\t- " << Fmt( iNameWidth, 10, Fmt::Left ) << (*i).sName << "  "
+            << (*i).eExpect << sio.nl;
+    }
+    sio << sio.nl;
+    exit( 0 );
+    return 0;
 }
 
 int Bu::UnitSuite::onAddTest( StrArray aParam )
 {
-        hSelTests.insert( aParam[0], true );
-        return 0;
+    hSelTests.insert( aParam[0], true );
+    return 0;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::UnitSuite::Expect &e )
 {
-        switch( e )
-        {
-                case Bu::UnitSuite::expectPass:
-                        return f << "expect pass";
+    switch( e )
+    {
+        case Bu::UnitSuite::expectPass:
+            return f << "expect pass";
 
-                case Bu::UnitSuite::expectFail:
-                        return f << "expect fail";
-        }
+        case Bu::UnitSuite::expectFail:
+            return f << "expect fail";
+    }
 
-        return f << "**error**";
+    return f << "**error**";
 }
 
diff --git a/src/stable/unitsuite.h b/src/stable/unitsuite.h
index 3442753..46a0773 100644
--- a/src/stable/unitsuite.h
+++ b/src/stable/unitsuite.h
@@ -17,126 +17,126 @@
 
 namespace Bu
 {
-        /**
-         * Provides a unit testing framework.  This is pretty easy to use, probably
-         * the best way to get started is to use ch to generate a template, or use
-         * the code below with appropriate tweaks:
-         *@code
-         * #include "unitsuite.h"
-         * 
-         * class Unit : public Bu::UnitSuite
-         * {
-         * public:
-         *      Unit()
-         *      {
-         *              setName("Example");
-         *              addTest( Unit::test );
-         *      }
-         * 
-         *      virtual ~Unit() { }
-         * 
-         *      //
-         *      // Tests go here
-         *      //
-         *      void test()
-         *      {
-         *              unitTest( 1 == 1 );
-         *      }
-         * };
-         * 
-         * int main( int argc, char *argv[] )
-         * {
-         *      return Unit().run( argc, argv );
-         * }
-         *
-         @endcode
-         * The main function can contain other things, but using this one exactly
-         * makes all of the test suites work exactly the same.  Using the optional
-         * setName at the top of the constructor replaces the class name with the
-         * chosen name when printing out stats and info.
-         */
-        class UnitSuite
-        {
-        public:
-                UnitSuite();
-                UnitSuite( int iOptions );
-                virtual ~UnitSuite();
-
-                int run( int argc=0, char *argv[]=NULL );
-
-                Bu::File tempFile( Bu::String &sFileName );
-
-                typedef void (UnitSuite::*Test)();
-
-                class Failed
-                {
-                public:
-                        Failed() : str(""), bFile( false ) { }
-                        Failed( const String &s ) : str( s ), bFile( false ) { }
-                        Failed( const String &s, const String &sFile, int nLine ) :
-                                str( s ), sFile( sFile ), nLine( nLine ), bFile( true ) { }
-
-                        String str;
-                        String sFile;
-                        int nLine;
-                        bool bFile;
-                };
-
-                enum
-                {
-                        optStopOnError          = 0x000001
-                };
-
-                enum Expect
-                {
-                        expectPass,
-                        expectFail
-                };
-                
-        protected:
-                void add( Test fTest, const Bu::String &sName, Expect e=expectPass );
-                void setName( const String &sName );
-
-                void dispProgress();
-                void setStepCount( int iSteps );
-                void incProgress( int iAmnt = 1 );
-                void setProgress( int iAmnt );
-
-        private:
-                int onListCases( Bu::Array<Bu::String> aParam );
-                int onAddTest( Bu::Array<Bu::String> aParam );
-
-        private:
-                typedef struct TestInfo
-                {
-                        String sName;
-                        Test fTest;
-                        Expect eExpect;
-                } TestInfo;
-
-                typedef Bu::List<TestInfo> TestList;
-                TestList lTests;
-                String sSuiteName;
-
-                int iOptions;
-
-                typedef Bu::List<Bu::String> StrList;
-                StrList lFileCleanup;
-                int iNameWidth;
-                int iStepCount;
-                int iProgress;
-                time_t tLastUpdate;
-
-                Bu::Hash<Bu::String, bool> hSelTests;
-        };
+    /**
+     * Provides a unit testing framework.  This is pretty easy to use, probably
+     * the best way to get started is to use ch to generate a template, or use
+     * the code below with appropriate tweaks:
+     *@code
+     * #include "unitsuite.h"
+     * 
+     * class Unit : public Bu::UnitSuite
+     * {
+     * public:
+     *  Unit()
+     *  {
+     *      setName("Example");
+     *      addTest( Unit::test );
+     *  }
+     * 
+     *  virtual ~Unit() { }
+     * 
+     *  //
+     *  // Tests go here
+     *  //
+     *  void test()
+     *  {
+     *      unitTest( 1 == 1 );
+     *  }
+     * };
+     * 
+     * int main( int argc, char *argv[] )
+     * {
+     *  return Unit().run( argc, argv );
+     * }
+     *
+     @endcode
+     * The main function can contain other things, but using this one exactly
+     * makes all of the test suites work exactly the same.  Using the optional
+     * setName at the top of the constructor replaces the class name with the
+     * chosen name when printing out stats and info.
+     */
+    class UnitSuite
+    {
+    public:
+        UnitSuite();
+        UnitSuite( int iOptions );
+        virtual ~UnitSuite();
+
+        int run( int argc=0, char *argv[]=NULL );
+
+        Bu::File tempFile( Bu::String &sFileName );
+
+        typedef void (UnitSuite::*Test)();
+
+        class Failed
+        {
+        public:
+            Failed() : str(""), bFile( false ) { }
+            Failed( const String &s ) : str( s ), bFile( false ) { }
+            Failed( const String &s, const String &sFile, int nLine ) :
+                str( s ), sFile( sFile ), nLine( nLine ), bFile( true ) { }
+
+            String str;
+            String sFile;
+            int nLine;
+            bool bFile;
+        };
+
+        enum
+        {
+            optStopOnError      = 0x000001
+        };
+
+        enum Expect
+        {
+            expectPass,
+            expectFail
+        };
+        
+    protected:
+        void add( Test fTest, const Bu::String &sName, Expect e=expectPass );
+        void setName( const String &sName );
+
+        void dispProgress();
+        void setStepCount( int iSteps );
+        void incProgress( int iAmnt = 1 );
+        void setProgress( int iAmnt );
+
+    private:
+        int onListCases( Bu::Array<Bu::String> aParam );
+        int onAddTest( Bu::Array<Bu::String> aParam );
+
+    private:
+        typedef struct TestInfo
+        {
+            String sName;
+            Test fTest;
+            Expect eExpect;
+        } TestInfo;
+
+        typedef Bu::List<TestInfo> TestList;
+        TestList lTests;
+        String sSuiteName;
+
+        int iOptions;
+
+        typedef Bu::List<Bu::String> StrList;
+        StrList lFileCleanup;
+        int iNameWidth;
+        int iStepCount;
+        int iProgress;
+        time_t tLastUpdate;
+
+        Bu::Hash<Bu::String, bool> hSelTests;
+    };
 
 Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::UnitSuite::Expect &e );
 }
 
 #define addTest( fn ) add( static_cast<Bu::UnitSuite::Test>(&fn), #fn )
-#define unitTest( tst ) if( !(tst) )                                                    \
-{                                                                                                                               \
-        throw Bu::UnitSuite::Failed( #tst, __FILE__, __LINE__ );        \
+#define unitTest( tst ) if( !(tst) )                            \
+{                                                               \
+    throw Bu::UnitSuite::Failed( #tst, __FILE__, __LINE__ );    \
 } else (void)0
 #define unitFailed( msg ) throw Bu::UnitSuite::Failed(msg, __FILE__, __LINE__)
 
diff --git a/src/stable/util.cpp b/src/stable/util.cpp
index b42e040..ff9901b 100644
--- a/src/stable/util.cpp
+++ b/src/stable/util.cpp
@@ -9,57 +9,57 @@
 
 int Bu::getDaysInMonth( int iMonth, int iYear )
 {
-        if( iMonth > 11 )
-        {
-                iYear += iMonth/12;
-                iMonth = iMonth%12;
-        }
-        switch( iMonth )
-        {
-        case 0:
-        case 2:
-        case 4:
-        case 6:
-        case 7:
-        case 9:
-        case 11:
-                return 31;
-                break;
+    if( iMonth > 11 )
+    {
+        iYear += iMonth/12;
+        iMonth = iMonth%12;
+    }
+    switch( iMonth )
+    {
+    case 0:
+    case 2:
+    case 4:
+    case 6:
+    case 7:
+    case 9:
+    case 11:
+        return 31;
+        break;
 
-        case 3:
-        case 5:
-        case 8:
-        case 10:
-                return 30;
-                break;
+    case 3:
+    case 5:
+    case 8:
+    case 10:
+        return 30;
+        break;
 
-        case 1:
-                if( iYear%400 == 0 )
-                        return 29;
-                if( iYear%100 == 0 )
-                        return 28;
-                if( iYear%4 == 0 )
-                        return 29;
-                return 28;
-                break;
+    case 1:
+        if( iYear%400 == 0 )
+            return 29;
+        if( iYear%100 == 0 )
+            return 28;
+        if( iYear%4 == 0 )
+            return 29;
+        return 28;
+        break;
 
-        default:
-                return -1;
-        }
+    default:
+        return -1;
+    }
 }
 void Bu::memcpy( void *pDest, const void *pSrc, size_t iBytes )
 {
 #ifdef VALTEST
-        const char *src = (const char *)pSrc;
-        char *dest = (char *)pDest;
-        for( int j = 0; j < count; j++ )
-        {
-                *dest = *src;
-                dest++;
-                src++;
-        }
+    const char *src = (const char *)pSrc;
+    char *dest = (char *)pDest;
+    for( int j = 0; j < count; j++ )
+    {
+        *dest = *src;
+        dest++;
+        src++;
+    }
 #else
-        ::memcpy( pDest, pSrc, iBytes );
+    ::memcpy( pDest, pSrc, iBytes );
 #endif
 }
 
diff --git a/src/stable/util.h b/src/stable/util.h
index 4514281..ab9cd08 100644
--- a/src/stable/util.h
+++ b/src/stable/util.h
@@ -25,158 +25,158 @@
 
 namespace Bu
 {
-        /**
-         * Swap the value of two variables, uses references, so it's pretty safe.
-         * Objects passed in must support a basic assignemnt operator (=);
-         *@param a Variable to recieve the value of parameter b
-         *@param b Variable to recieve the value of parameter a
-         */
-        template<typename item>
-        void swap( item &a, item &b )
-        {
-                item tmp = a;
-                a = b;
-                b = tmp;
-        }
+    /**
+     * Swap the value of two variables, uses references, so it's pretty safe.
+     * Objects passed in must support a basic assignemnt operator (=);
+     *@param a Variable to recieve the value of parameter b
+     *@param b Variable to recieve the value of parameter a
+     */
+    template<typename item>
+    void swap( item &a, item &b )
+    {
+        item tmp = a;
+        a = b;
+        b = tmp;
+    }
 
-        /**
-         * Finds the lesser of the two objects, objects passed in must be
-         * less-than-comparable.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@returns A reference to the lesser of a or b.
-         */
-        template<typename item>
-        const item &buMin( const item &a, const item &b )
-        {
-                return a<b?a:b;
-        }
-        
-        /**
-         * Finds the lesser of the two objects, objects passed in must be
-         * less-than-comparable.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@returns A reference to the lesser of a or b.
-         */
-        template<typename item>
-        item &buMin( item &a, item &b )
-        {
-                return a<b?a:b;
-        }
-        
-        /**
-         * Finds the greater of the two objects, objects passed in must be
-         * less-than-comparable.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@returns A reference to the greater of a or b.
-         */
-        template<typename item>
-        const item &buMax( const item &a, const item &b )
-        {
-                return b<a?a:b;
-        }
-        
-        /**
-         * Finds the greater of the two objects, objects passed in must be
-         * less-than-comparable.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@returns A reference to the greater of a or b.
-         */
-        template<typename item>
-        item &buMax( item &a, item &b )
-        {
-                return b<a?a:b;
-        }
+    /**
+     * Finds the lesser of the two objects, objects passed in must be
+     * less-than-comparable.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@returns A reference to the lesser of a or b.
+     */
+    template<typename item>
+    const item &buMin( const item &a, const item &b )
+    {
+        return a<b?a:b;
+    }
+    
+    /**
+     * Finds the lesser of the two objects, objects passed in must be
+     * less-than-comparable.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@returns A reference to the lesser of a or b.
+     */
+    template<typename item>
+    item &buMin( item &a, item &b )
+    {
+        return a<b?a:b;
+    }
+    
+    /**
+     * Finds the greater of the two objects, objects passed in must be
+     * less-than-comparable.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@returns A reference to the greater of a or b.
+     */
+    template<typename item>
+    const item &buMax( const item &a, const item &b )
+    {
+        return b<a?a:b;
+    }
+    
+    /**
+     * Finds the greater of the two objects, objects passed in must be
+     * less-than-comparable.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@returns A reference to the greater of a or b.
+     */
+    template<typename item>
+    item &buMax( item &a, item &b )
+    {
+        return b<a?a:b;
+    }
 
-        /**
-         * Given three objects this finds the one between the other two.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@param c Yet another value to test.
-         *@returns A reference to the mid-value of a, b, and c.
-         */
-        template<typename item>
-        const item &buMid( const item &a, const item &b, const item &c )
-        {
-                return buMin( buMax( a, b ), c );
-        }
-                
-        /**
-         * Given three objects this finds the one between the other two.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@param c Yet another value to test.
-         *@returns A reference to the mid-value of a, b, and c.
-         */
-        template<typename item>
-        item &buMid( item &a, item &b, item &c )
-        {
-                return buMin( buMax( a, b ), c );
-        }
-        
-        //
-        //  Basic comparison functors
-        //
-        /**
-         * Simple less-than comparison functor.  Objects being used should be
-         * less-than-comparable.
-         */
-        template<typename item>
-        struct __basicLTCmp
-        {
-                bool operator()( const item &a, const item &b )
-                {
-                        return a < b;
-                }
-        };
-        
-        /**
-         * Simple greater-than comparison functor.  Objects being used should be
-         * greater-than-comparable.
-         */
-        template<typename item>
-        struct __basicGTCmp
-        {
-                bool operator()( const item &a, const item &b )
-                {
-                        return a > b;
-                }
-        };
+    /**
+     * Given three objects this finds the one between the other two.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@param c Yet another value to test.
+     *@returns A reference to the mid-value of a, b, and c.
+     */
+    template<typename item>
+    const item &buMid( const item &a, const item &b, const item &c )
+    {
+        return buMin( buMax( a, b ), c );
+    }
+        
+    /**
+     * Given three objects this finds the one between the other two.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@param c Yet another value to test.
+     *@returns A reference to the mid-value of a, b, and c.
+     */
+    template<typename item>
+    item &buMid( item &a, item &b, item &c )
+    {
+        return buMin( buMax( a, b ), c );
+    }
+    
+    //
+    //  Basic comparison functors
+    //
+    /**
+     * Simple less-than comparison functor.  Objects being used should be
+     * less-than-comparable.
+     */
+    template<typename item>
+    struct __basicLTCmp
+    {
+        bool operator()( const item &a, const item &b )
+        {
+            return a < b;
+        }
+    };
+    
+    /**
+     * Simple greater-than comparison functor.  Objects being used should be
+     * greater-than-comparable.
+     */
+    template<typename item>
+    struct __basicGTCmp
+    {
+        bool operator()( const item &a, const item &b )
+        {
+            return a > b;
+        }
+    };
 
-        /**
-         * As __basicLTCmp but dereferences the passed in pointers before comparing.
-         */
-        template<typename item>
-        struct __basicPtrLTCmp
-        {
-                bool operator()( const item &a, const item &b )
-                {
-                        return *a < *b;
-                }
-        };
-        
-        /**
-         * As __basicGTCmp but dereferences the passed in pointers before comparing.
-         */
-        template<typename item>
-        struct __basicPtrGTCmp
-        {
-                bool operator()( const item &a, const item &b )
-                {
-                        return *a > *b;
-                }
-        };
+    /**
+     * As __basicLTCmp but dereferences the passed in pointers before comparing.
+     */
+    template<typename item>
+    struct __basicPtrLTCmp
+    {
+        bool operator()( const item &a, const item &b )
+        {
+            return *a < *b;
+        }
+    };
+    
+    /**
+     * As __basicGTCmp but dereferences the passed in pointers before comparing.
+     */
+    template<typename item>
+    struct __basicPtrGTCmp
+    {
+        bool operator()( const item &a, const item &b )
+        {
+            return *a > *b;
+        }
+    };
 
-        /**
-         * Get the number of days in the month in the gregorian calendar, taking
-         * leap years into account.
-         */
-        int getDaysInMonth( int iMonth, int iYear );
+    /**
+     * Get the number of days in the month in the gregorian calendar, taking
+     * leap years into account.
+     */
+    int getDaysInMonth( int iMonth, int iYear );
 
-        void memcpy( void *pDest, const void *pSrc, size_t iBytes );
+    void memcpy( void *pDest, const void *pSrc, size_t iBytes );
 };
 
 #endif
diff --git a/src/stable/variant.cpp b/src/stable/variant.cpp
index 674ae04..d724fa7 100644
--- a/src/stable/variant.cpp
+++ b/src/stable/variant.cpp
@@ -11,7 +11,7 @@
 
 namespace Bu
 {
-        Formatter &operator<<( Formatter &f, const String &s );
+    Formatter &operator<<( Formatter &f, const String &s );
 };
 
 Bu::VariantTypeRoot::VariantTypeRoot()
@@ -23,84 +23,84 @@ Bu::VariantTypeRoot::~VariantTypeRoot()
 }
 
 Bu::Variant::Variant() :
-        pCore( NULL )
+    pCore( NULL )
 {
 }
 
 Bu::Variant::Variant( const Variant &v ) :
-        pCore( NULL )
+    pCore( NULL )
 {
-        if( v.pCore )
-        {
-                pCore = v.pCore->clone();
-        }
+    if( v.pCore )
+    {
+        pCore = v.pCore->clone();
+    }
 }
 
 Bu::Variant::Variant( const char *t ) :
-        pCore( NULL )
+    pCore( NULL )
 {
-        set( Bu::String( t ) );
+    set( Bu::String( t ) );
 }
 
 Bu::Variant::~Variant()
 {
-        if( pCore )
-        {
-                delete pCore;
-                pCore = NULL;
-        }
+    if( pCore )
+    {
+        delete pCore;
+        pCore = NULL;
+    }
 }
 
 Bu::String Bu::Variant::toString() const
 {
-        if( getType() == typeid( Bu::String ) )
-        {
-                return get<Bu::String>();
-        }
-        else
-        {
-                Bu::MemBuf mb;
-                Bu::Formatter f( mb );
-                f << *this;
-                return mb.getString();
-        }
+    if( getType() == typeid( Bu::String ) )
+    {
+        return get<Bu::String>();
+    }
+    else
+    {
+        Bu::MemBuf mb;
+        Bu::Formatter f( mb );
+        f << *this;
+        return mb.getString();
+    }
 }
 
 bool Bu::Variant::isSet() const
 {
-        return pCore != NULL;
+    return pCore != NULL;
 }
 
 const std::type_info &Bu::Variant::getType() const
 {
-        if( !pCore )
-        {
-                throw Bu::ExceptionBase("No data!");
-        }
-        return pCore->getType();
+    if( !pCore )
+    {
+        throw Bu::ExceptionBase("No data!");
+    }
+    return pCore->getType();
 }
 
 Bu::Variant &Bu::Variant::operator=( const Bu::Variant &rhs )
 {
-        if( pCore )
-        {
-                delete pCore;
-                pCore = NULL;
-        }
-        if( rhs.pCore )
-        {
-                pCore = rhs.pCore->clone();
-        }
-
-        return *this;
+    if( pCore )
+    {
+        delete pCore;
+        pCore = NULL;
+    }
+    if( rhs.pCore )
+    {
+        pCore = rhs.pCore->clone();
+    }
+
+    return *this;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Variant &v )
 {
-        if( !v.pCore )
-                return f << "(null)";
+    if( !v.pCore )
+        return f << "(null)";
 
-        v.pCore->format( f );
-        return f;
+    v.pCore->format( f );
+    return f;
 }
 
diff --git a/src/stable/variant.h b/src/stable/variant.h
index 6837954..227e246 100644
--- a/src/stable/variant.h
+++ b/src/stable/variant.h
@@ -20,217 +20,217 @@
 
 namespace Bu
 {
-        class String;
-        class Formatter;
-        class Variant;
-        /** @cond DEVEL */
-        template<class t> class VariantType;
-
-        class VariantTypeRoot
-        {
-        public:
-                VariantTypeRoot();
-                virtual ~VariantTypeRoot();
-
-                virtual const std::type_info &getType() const=0;
-                virtual VariantTypeRoot *clone() const=0;
-                virtual void format( Bu::Formatter &f ) const=0;
-        };
-
-        template<class t>
-        class VariantType : public VariantTypeRoot
-        {
-                friend class Variant;
-        private:
-                VariantType()
-                {
-                }
-
-                VariantType( const t &d ) : 
-                        data( d )
-                {
-                }
-
-                VariantType( const VariantType<t> &vt ) :
-                        data( vt.data )
-                {
-                }
-
-                virtual ~VariantType()
-                {
-                }
-
-        public:
-                t &getData()
-                {
-                        return data;
-                }
-                
-                const t &getData() const
-                {
-                        return data;
-                }
-
-                virtual void format( Formatter &f ) const
-                {
-                        f << data;
-                }
-
-                virtual const std::type_info &getType() const
-                {
-                        return typeid( data );
-                }
-
-                VariantType<t> operator=( const t &rhs )
-                {
-                        data = rhs;
-
-                        return *this;
-                }
-
-                virtual VariantTypeRoot *clone() const
-                {
-                        return new VariantType<t>( *this );
-                }
-
-        private:
-                t data;
-        };
-        /** @endcond */
-
-        /**
-         * Store any data type and access it safely.  Variant gives you a way to
-         * pass arbitrary data types around without having to worry about what
-         * type a variable is.  It allows code to be easily extended and to manage
-         * data without having to know what type it is ahead of time.
-         *
-         * Because of the generic method that this class was implemented it may seem
-         * to have some drawbacks compared to other Variant classes you may have
-         * seen, however it is fairly easy to get it to do just about anything you
-         * may need.  It is also very low overhead.  On most compilers the class
-         * itself has only 3 words of overhead + the size of the variable you store
-         * in it.  And, since many parts of it are templatized they can often be
-         * optimized quite a bit.
-         */
-        class Variant
-        {
-        friend Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
-        public:
-                Variant();
-                Variant( const Variant &v );
-                Variant( const char *t );
-                template<class t>
-                Variant( const t &v ) :
-                        pCore( new VariantType<t>() )
-                {
-                        (*dynamic_cast<VariantType<t> *>(pCore)) = v;
-                }
-                virtual ~Variant();
-
-                Bu::String toString() const;
-                bool isSet() const;
-                const std::type_info &getType() const;
-
-                Variant &operator=( const Variant &rhs );
-
-                template<class t>
-                Variant &operator=( const t &rhs )
-                {
-                        if( pCore ) // && pCore->getType() != typeid(t) )
-                        {
-                                delete pCore;
-                                pCore = NULL;
-                        }
-                        pCore = new VariantType<t>();
-                        (*dynamic_cast<VariantType<t> *>(pCore)) = rhs;
-                        return *this;
-                }
-
-                template<class t>
-                t &get()
-                {
-                        if( !pCore )
-                        {
-                                throw Bu::ExceptionBase("No data!");
-                        }
-                        if( pCore->getType() != typeid(t) )
-                        {
-                                throw Bu::ExceptionBase("Invalid type conversion.");
-                        }
-                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
-                }
-                
-                template<class t>
-                t &get() const
-                {
-                        if( !pCore )
-                        {
-                                throw Bu::ExceptionBase("No data!");
-                        }
-                        if( pCore->getType() != typeid(t) )
-                        {
-                                throw Bu::ExceptionBase("Invalid type conversion.");
-                        }
-                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
-                }
-                
-                template<class t>
-                void set( const t &val )
-                {
-                        if( pCore && pCore->getType() != typeid(t) )
-                        {
-                                delete pCore;
-                                pCore = NULL;
-                        }
-                        pCore = new VariantType<t>();
-                        (*dynamic_cast<VariantType<t> *>(pCore)) = val;
-                }
-
-                template<class t>
-                bool isType() const
-                {
-                        return pCore->getType() == typeid(t);
-                }
-
-                template<class t>
-                operator t()
-                {
-                        if( !pCore )
-                        {
-                                throw Bu::ExceptionBase("No data!");
-                        }
-                        if( pCore->getType() != typeid(t) )
-                        {
-                                throw Bu::ExceptionBase("Invalid type conversion.");
-                        }
-                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
-                }
-                
-                template<class t>
-                operator t() const
-                {
-                        if( !pCore )
-                        {
-                                throw Bu::ExceptionBase("No data!");
-                        }
-                        if( pCore->getType() != typeid(t) )
-                        {
-                                throw Bu::ExceptionBase("Invalid type conversion.");
-                        }
-                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
-                }
-
-        private:
-                VariantTypeRoot *pCore;
-        };
+    class String;
+    class Formatter;
+    class Variant;
+    /** @cond DEVEL */
+    template<class t> class VariantType;
+
+    class VariantTypeRoot
+    {
+    public:
+        VariantTypeRoot();
+        virtual ~VariantTypeRoot();
+
+        virtual const std::type_info &getType() const=0;
+        virtual VariantTypeRoot *clone() const=0;
+        virtual void format( Bu::Formatter &f ) const=0;
+    };
+
+    template<class t>
+    class VariantType : public VariantTypeRoot
+    {
+        friend class Variant;
+    private:
+        VariantType()
+        {
+        }
+
+        VariantType( const t &d ) : 
+            data( d )
+        {
+        }
+
+        VariantType( const VariantType<t> &vt ) :
+            data( vt.data )
+        {
+        }
+
+        virtual ~VariantType()
+        {
+        }
+
+    public:
+        t &getData()
+        {
+            return data;
+        }
+        
+        const t &getData() const
+        {
+            return data;
+        }
+
+        virtual void format( Formatter &f ) const
+        {
+            f << data;
+        }
+
+        virtual const std::type_info &getType() const
+        {
+            return typeid( data );
+        }
+
+        VariantType<t> operator=( const t &rhs )
+        {
+            data = rhs;
+
+            return *this;
+        }
+
+        virtual VariantTypeRoot *clone() const
+        {
+            return new VariantType<t>( *this );
+        }
+
+    private:
+        t data;
+    };
+    /** @endcond */
+
+    /**
+     * Store any data type and access it safely.  Variant gives you a way to
+     * pass arbitrary data types around without having to worry about what
+     * type a variable is.  It allows code to be easily extended and to manage
+     * data without having to know what type it is ahead of time.
+     *
+     * Because of the generic method that this class was implemented it may seem
+     * to have some drawbacks compared to other Variant classes you may have
+     * seen, however it is fairly easy to get it to do just about anything you
+     * may need.  It is also very low overhead.  On most compilers the class
+     * itself has only 3 words of overhead + the size of the variable you store
+     * in it.  And, since many parts of it are templatized they can often be
+     * optimized quite a bit.
+     */
+    class Variant
+    {
+    friend Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
+    public:
+        Variant();
+        Variant( const Variant &v );
+        Variant( const char *t );
+        template<class t>
+        Variant( const t &v ) :
+            pCore( new VariantType<t>() )
+        {
+            (*dynamic_cast<VariantType<t> *>(pCore)) = v;
+        }
+        virtual ~Variant();
+
+        Bu::String toString() const;
+        bool isSet() const;
+        const std::type_info &getType() const;
+
+        Variant &operator=( const Variant &rhs );
+
+        template<class t>
+        Variant &operator=( const t &rhs )
+        {
+            if( pCore ) // && pCore->getType() != typeid(t) )
+            {
+                delete pCore;
+                pCore = NULL;
+            }
+            pCore = new VariantType<t>();
+            (*dynamic_cast<VariantType<t> *>(pCore)) = rhs;
+            return *this;
+        }
+
+        template<class t>
+        t &get()
+        {
+            if( !pCore )
+            {
+                throw Bu::ExceptionBase("No data!");
+            }
+            if( pCore->getType() != typeid(t) )
+            {
+                throw Bu::ExceptionBase("Invalid type conversion.");
+            }
+            return dynamic_cast<VariantType<t> *>(pCore)->getData();
+        }
+        
+        template<class t>
+        t &get() const
+        {
+            if( !pCore )
+            {
+                throw Bu::ExceptionBase("No data!");
+            }
+            if( pCore->getType() != typeid(t) )
+            {
+                throw Bu::ExceptionBase("Invalid type conversion.");
+            }
+            return dynamic_cast<VariantType<t> *>(pCore)->getData();
+        }
+        
+        template<class t>
+        void set( const t &val )
+        {
+            if( pCore && pCore->getType() != typeid(t) )
+            {
+                delete pCore;
+                pCore = NULL;
+            }
+            pCore = new VariantType<t>();
+            (*dynamic_cast<VariantType<t> *>(pCore)) = val;
+        }
+
+        template<class t>
+        bool isType() const
+        {
+            return pCore->getType() == typeid(t);
+        }
+
+        template<class t>
+        operator t()
+        {
+            if( !pCore )
+            {
+                throw Bu::ExceptionBase("No data!");
+            }
+            if( pCore->getType() != typeid(t) )
+            {
+                throw Bu::ExceptionBase("Invalid type conversion.");
+            }
+            return dynamic_cast<VariantType<t> *>(pCore)->getData();
+        }
+        
+        template<class t>
+        operator t() const
+        {
+            if( !pCore )
+            {
+                throw Bu::ExceptionBase("No data!");
+            }
+            if( pCore->getType() != typeid(t) )
+            {
+                throw Bu::ExceptionBase("Invalid type conversion.");
+            }
+            return dynamic_cast<VariantType<t> *>(pCore)->getData();
+        }
+
+    private:
+        VariantTypeRoot *pCore;
+    };
 /*
-        template<class t>
-        Bu::Formatter &operator<<( Bu::Formatter &f, const VariantType<t> &vt )
-        {
-                return f << vt.getData;
-        }*/
+    template<class t>
+    Bu::Formatter &operator<<( Bu::Formatter &f, const VariantType<t> &vt )
+    {
+        return f << vt.getData;
+    }*/
 
-        Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
+    Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
 };
 
 #endif
diff --git a/src/tests/base64.cpp b/src/tests/base64.cpp
index 1e1892d..640118a 100644
--- a/src/tests/base64.cpp
+++ b/src/tests/base64.cpp
@@ -11,73 +11,73 @@
 
 int main( int argc, char *argv[] )
 {
-        argc--,argv++;
+    argc--,argv++;
 
-        if( argc < 3 )
-                return 0;
+    if( argc < 3 )
+        return 0;
 
-        if( argv[0][0] == 'e' )
-        {
-                argv++;
-                Bu::File fIn( argv[0], Bu::File::Read );
-                Bu::File fOut( argv[1], Bu::File::WriteNew );
-                Bu::Base64 bOut( fOut );
+    if( argv[0][0] == 'e' )
+    {
+        argv++;
+        Bu::File fIn( argv[0], Bu::File::Read );
+        Bu::File fOut( argv[1], Bu::File::WriteNew );
+        Bu::Base64 bOut( fOut );
 
-                char buf[900];
-                for(;;)
-                {
-                        int iRead = fIn.read( buf, 900 );
-                        bOut.write( buf, iRead );
-                        if( iRead < 900 )
-                                break;
-                }
-        }
-        else if( argv[0][0] == 'd' )
-        {
-                argv++;
-                Bu::File fIn( argv[0], Bu::File::Read );
-                Bu::File fOut( argv[1], Bu::File::WriteNew );
-                Bu::Base64 bIn( fIn );
+        char buf[900];
+        for(;;)
+        {
+            int iRead = fIn.read( buf, 900 );
+            bOut.write( buf, iRead );
+            if( iRead < 900 )
+                break;
+        }
+    }
+    else if( argv[0][0] == 'd' )
+    {
+        argv++;
+        Bu::File fIn( argv[0], Bu::File::Read );
+        Bu::File fOut( argv[1], Bu::File::WriteNew );
+        Bu::Base64 bIn( fIn );
 
-                char buf[1024];
-                for(;;)
-                {
-                        int iRead = bIn.read( buf, 1024 );
-                        printf("Read %d bytes.\n", iRead );
-                        fOut.write( buf, iRead );
-                        if( iRead == 0 )
-                                break;
-                }
-        }
-        else if( argv[0][0] == 'D' )
-        {
-                argv++;
-                Bu::MemBuf mIn;
-                {
-                        Bu::File fIn( argv[0], Bu::File::Read );
-                        char buf[1024];
-                        for(;;)
-                        {
-                                int iRead = fIn.read( buf, 1024 );
-                                mIn.write( buf, iRead );
-                                if( iRead < 1024 )
-                                        break;
-                        }
-                        mIn.setPos( 0 );
-                }
-                Bu::File fOut( argv[1], Bu::File::WriteNew );
-                Bu::Base64 bIn( mIn );
+        char buf[1024];
+        for(;;)
+        {
+            int iRead = bIn.read( buf, 1024 );
+            printf("Read %d bytes.\n", iRead );
+            fOut.write( buf, iRead );
+            if( iRead == 0 )
+                break;
+        }
+    }
+    else if( argv[0][0] == 'D' )
+    {
+        argv++;
+        Bu::MemBuf mIn;
+        {
+            Bu::File fIn( argv[0], Bu::File::Read );
+            char buf[1024];
+            for(;;)
+            {
+                int iRead = fIn.read( buf, 1024 );
+                mIn.write( buf, iRead );
+                if( iRead < 1024 )
+                    break;
+            }
+            mIn.setPos( 0 );
+        }
+        Bu::File fOut( argv[1], Bu::File::WriteNew );
+        Bu::Base64 bIn( mIn );
 
-                char buf[1024];
-                for(;;)
-                {
-                        int iRead = bIn.read( buf, 1024 );
-                        printf("Read %d bytes.\n", iRead );
-                        fOut.write( buf, iRead );
-                        if( iRead == 0 )
-                                break;
-                }
-        }
+        char buf[1024];
+        for(;;)
+        {
+            int iRead = bIn.read( buf, 1024 );
+            printf("Read %d bytes.\n", iRead );
+            fOut.write( buf, iRead );
+            if( iRead == 0 )
+                break;
+        }
+    }
 
-        return 0;
+    return 0;
 }
diff --git a/src/tests/bigmyriad.cpp b/src/tests/bigmyriad.cpp
index 6661bf1..9af301c 100644
--- a/src/tests/bigmyriad.cpp
+++ b/src/tests/bigmyriad.cpp
@@ -4,22 +4,22 @@
 
 int main()
 {
-        Bu::File f("big.myr", Bu::File::Read|Bu::File::Write|Bu::File::Create );
-        Bu::Myriad m( f, 2048 );
+    Bu::File f("big.myr", Bu::File::Read|Bu::File::Write|Bu::File::Create );
+    Bu::Myriad m( f, 2048 );
 
-        char *buf = new char[1024*1024*10];
-        memset( buf, 0, 1024*1024*10 );
+    char *buf = new char[1024*1024*10];
+    memset( buf, 0, 1024*1024*10 );
 
-        for( int j = 0; j < 250; j++ )
-        {
-                m.openStream( m.createStream() ).write( buf, 1024*1024*10 );
-//              m.sync();
-                printf("\r%03d%%", (j+1)*100/250 );
-                fflush( stdout );
-        }
+    for( int j = 0; j < 250; j++ )
+    {
+        m.openStream( m.createStream() ).write( buf, 1024*1024*10 );
+//      m.sync();
+        printf("\r%03d%%", (j+1)*100/250 );
+        fflush( stdout );
+    }
 
-        printf("\n\n");
+    printf("\n\n");
 
-        return 0;
+    return 0;
 }
 
diff --git a/src/tests/blowfish.cpp b/src/tests/blowfish.cpp
index 7c175d4..c0aba30 100644
--- a/src/tests/blowfish.cpp
+++ b/src/tests/blowfish.cpp
@@ -56,72 +56,72 @@ static const char *testdat[34][3] ={
 
 int main( int argc, char *argv[] )
 {
-        MemBuf mb;
-        {
-                BlowfishEcb bf( mb );
-                bf.setPassword( "01234567" );
-                for( int j = 0; j < 4; j++ )
-                {
-                        bf.write("this is a test!!"+j, 1 );
-                }
-                bf.write("this is a test!!"+4, 12 );
-        }
-        mb.setPos( 0 );
-        BlowfishEcb bf( mb );
-        bf.setPassword( "01234567" );
-        for( int j = 0; j < 3; j++ )
-        {
-                char c;
-                bf.read( &c, 1 );
-                sio << "char: '" << c << "'" << sio.nl;
-        }
+    MemBuf mb;
+    {
+        BlowfishEcb bf( mb );
+        bf.setPassword( "01234567" );
+        for( int j = 0; j < 4; j++ )
+        {
+            bf.write("this is a test!!"+j, 1 );
+        }
+        bf.write("this is a test!!"+4, 12 );
+    }
+    mb.setPos( 0 );
+    BlowfishEcb bf( mb );
+    bf.setPassword( "01234567" );
+    for( int j = 0; j < 3; j++ )
+    {
+        char c;
+        bf.read( &c, 1 );
+        sio << "char: '" << c << "'" << sio.nl;
+    }
 
-        char buf[100];
-        int iR = bf.read( buf, 100 );
-        buf[iR] = '\0';
-        sio << "Got(" << iR << ") = '" << buf << "'" << sio.nl;
+    char buf[100];
+    int iR = bf.read( buf, 100 );
+    buf[iR] = '\0';
+    sio << "Got(" << iR << ") = '" << buf << "'" << sio.nl;
 
-        return 0;
+    return 0;
 
-        for( int j = 0; j < 34; j++ )
-        {
-                MemBuf mb;
-                BlowfishEcb bf( mb );
-                bf.setPassword( decodeStr<Hex>( testdat[j][0] ) );
-                bf.write( decodeStr<Hex>( testdat[j][1] ) );
-                sio << "Test " << j << ": " << (mb.getString() == decodeStr<Hex>( testdat[j][2] )) << " (" << encodeStr<Hex>( mb.getString(), true ) << " == " << testdat[j][2] << ")" << sio.nl;
+    for( int j = 0; j < 34; j++ )
+    {
+        MemBuf mb;
+        BlowfishEcb bf( mb );
+        bf.setPassword( decodeStr<Hex>( testdat[j][0] ) );
+        bf.write( decodeStr<Hex>( testdat[j][1] ) );
+        sio << "Test " << j << ": " << (mb.getString() == decodeStr<Hex>( testdat[j][2] )) << " (" << encodeStr<Hex>( mb.getString(), true ) << " == " << testdat[j][2] << ")" << sio.nl;
 
-                mb.setPos( 0 );
-                BlowfishEcb bf2( mb );
-                bf2.setPassword( decodeStr<Hex>( testdat[j][0] ) );
-                char buf[8];
-                bf2.read( buf, 8 );
-                
-                sio << "  - Back: " << (Bu::String(testdat[j][1]) == encodeStr<Hex>(String(buf,8),true)) << sio.nl;
-        }
+        mb.setPos( 0 );
+        BlowfishEcb bf2( mb );
+        bf2.setPassword( decodeStr<Hex>( testdat[j][0] ) );
+        char buf[8];
+        bf2.read( buf, 8 );
+        
+        sio << "  - Back: " << (Bu::String(testdat[j][1]) == encodeStr<Hex>(String(buf,8),true)) << sio.nl;
+    }
 
-        {
-                File fIn("data.plain", File::Read );
-                File fOut("data.crypt", File::WriteNew );
+    {
+        File fIn("data.plain", File::Read );
+        File fOut("data.crypt", File::WriteNew );
 
-                BlowfishOfb bOut( fOut );
-                bOut.setIv("01234567");
-                bOut.setPassword("abcdefghijklmnop");
-                bOut.write( fIn.readAll() );
-        }
-        {
-                File fIn("data.java", File::Read );
-                File fOut("data.stuff", File::WriteNew );
+        BlowfishOfb bOut( fOut );
+        bOut.setIv("01234567");
+        bOut.setPassword("abcdefghijklmnop");
+        bOut.write( fIn.readAll() );
+    }
+    {
+        File fIn("data.java", File::Read );
+        File fOut("data.stuff", File::WriteNew );
 
-                BlowfishOfb bIn( fIn );
-                bIn.setIv("01234567");
-                bIn.setPassword("abcdefghijklmnop");
-                char buf[64];
-                bIn.read( buf, 64 );
-                fOut.write( buf, 64 );
-                sio << sio.nl << "All done." << sio.nl;
-        }
+        BlowfishOfb bIn( fIn );
+        bIn.setIv("01234567");
+        bIn.setPassword("abcdefghijklmnop");
+        char buf[64];
+        bIn.read( buf, 64 );
+        fOut.write( buf, 64 );
+        sio << sio.nl << "All done." << sio.nl;
+    }
 
-        return 0;
+    return 0;
 }
 
diff --git a/src/tests/bnfcompile.cpp b/src/tests/bnfcompile.cpp
index af7a0eb..40d410d 100644
--- a/src/tests/bnfcompile.cpp
+++ b/src/tests/bnfcompile.cpp
@@ -15,408 +15,408 @@ using namespace Bu;
 
 enum TokenType
 {
-        tokIdentifier,
-        tokColon,
-        tokOr,
-        tokSemiColon,
-        tokTokens,
-        tokEquals,
-        tokOpenCurly,
-        tokCloseCurly,
-        tokOpenSquare,
-        tokCloseSquare,
-
-        tokEos=-1
+    tokIdentifier,
+    tokColon,
+    tokOr,
+    tokSemiColon,
+    tokTokens,
+    tokEquals,
+    tokOpenCurly,
+    tokCloseCurly,
+    tokOpenSquare,
+    tokCloseSquare,
+
+    tokEos=-1
 };
 
 class BnfLexer : public Lexer
 {
 public:
-        BnfLexer( Stream &rSrc ) :
-                rSrc( rSrc )
-        {
-        }
-
-        virtual ~BnfLexer()
-        {
-        }
-
-        virtual Token *nextToken()
-        {
-                char cBuf;
-
-                for(;;)
-                {
-                        if( qbIn.getSize() == 0 )
-                        {
-                                char buf[4096];
-                                qbIn.write( buf, rSrc.read( buf, 4096 ) );
-
-                                if( rSrc.isEos() && qbIn.getSize() == 0 )
-                                        return new Token( tokEos );
-                        }
-                        qbIn.peek( &cBuf, 1 );
-                        if( (cBuf >= 'a' && cBuf <= 'z') ||
-                                (cBuf >= 'A' && cBuf <= 'Z') ||
-                                (cBuf >= '0' && cBuf <= '9') ||
-                                cBuf == '_' )
-                        {
-                                sBuf.append( cBuf );
-                                qbIn.seek( 1 );
-                        }
-                        else if( sBuf.isSet() )
-                        {
-                                if( sBuf == "tokens" )
-                                {
-                                        sBuf.clear();
-                                        return new Token( tokTokens );
-                                }
-                                else
-                                {
-                                        Token *pRet = new Token( tokIdentifier, sBuf );
-                                        sBuf.clear();
-                                        return pRet;
-                                }
-                        }
-                        else
-                        {
-                                switch( cBuf )
-                                {
-                                        case ' ':
-                                        case '\t':
-                                        case '\n':
-                                        case '\r':
-                                                qbIn.seek( 1 );
-                                                continue;
-
-                                        case ':':
-                                                qbIn.seek( 1 );
-                                                return new Token( tokColon );
-
-                                        case ';':
-                                                qbIn.seek( 1 );
-                                                return new Token( tokSemiColon );
-
-                                        case '|':
-                                                qbIn.seek( 1 );
-                                                return new Token( tokOr );
-
-                                        case '=':
-                                                qbIn.seek( 1 );
-                                                return new Token( tokEquals );
-
-                                        case '[':
-                                                qbIn.seek( 1 );
-                                                return new Token( tokOpenSquare );
-
-                                        case ']':
-                                                qbIn.seek( 1 );
-                                                return new Token( tokCloseSquare );
-
-                                        case '{':
-                                                qbIn.seek( 1 );
-                                                return new Token( tokOpenCurly );
-
-                                        case '}':
-                                                qbIn.seek( 1 );
-                                                return new Token( tokCloseCurly );
-
-                                        default:
-                                                throw ExceptionBase("Unexpected character '%c'.",
-                                                        cBuf );
-                                                break;
-                                }
-                        }
-                }
-        }
-
-        virtual String tokenToString( const Token &t )
-        {
-                switch( (TokenType)t.iToken )
-                {
-                        case tokIdentifier:             return "tokIdentifier";
-                        case tokColon:                  return "tokColon";
-                        case tokOr:                             return "tokOr";
-                        case tokSemiColon:              return "tokSemiColon";
-                        case tokTokens:                 return "tokTokens";
-                        case tokEquals:                 return "tokEquals";
-                        case tokOpenCurly:              return "tokOpenCurly";
-                        case tokCloseCurly:             return "tokCloseCurly";
-                        case tokOpenSquare:             return "tokOpenSquare";
-                        case tokCloseSquare:    return "tokCloseSquare";
-                        case tokEos:                    return "tokEos";
-                }
-
-                return "???";
-        }
+    BnfLexer( Stream &rSrc ) :
+        rSrc( rSrc )
+    {
+    }
+
+    virtual ~BnfLexer()
+    {
+    }
+
+    virtual Token *nextToken()
+    {
+        char cBuf;
+
+        for(;;)
+        {
+            if( qbIn.getSize() == 0 )
+            {
+                char buf[4096];
+                qbIn.write( buf, rSrc.read( buf, 4096 ) );
+
+                if( rSrc.isEos() && qbIn.getSize() == 0 )
+                    return new Token( tokEos );
+            }
+            qbIn.peek( &cBuf, 1 );
+            if( (cBuf >= 'a' && cBuf <= 'z') ||
+                (cBuf >= 'A' && cBuf <= 'Z') ||
+                (cBuf >= '0' && cBuf <= '9') ||
+                cBuf == '_' )
+            {
+                sBuf.append( cBuf );
+                qbIn.seek( 1 );
+            }
+            else if( sBuf.isSet() )
+            {
+                if( sBuf == "tokens" )
+                {
+                    sBuf.clear();
+                    return new Token( tokTokens );
+                }
+                else
+                {
+                    Token *pRet = new Token( tokIdentifier, sBuf );
+                    sBuf.clear();
+                    return pRet;
+                }
+            }
+            else
+            {
+                switch( cBuf )
+                {
+                    case ' ':
+                    case '\t':
+                    case '\n':
+                    case '\r':
+                        qbIn.seek( 1 );
+                        continue;
+
+                    case ':':
+                        qbIn.seek( 1 );
+                        return new Token( tokColon );
+
+                    case ';':
+                        qbIn.seek( 1 );
+                        return new Token( tokSemiColon );
+
+                    case '|':
+                        qbIn.seek( 1 );
+                        return new Token( tokOr );
+
+                    case '=':
+                        qbIn.seek( 1 );
+                        return new Token( tokEquals );
+
+                    case '[':
+                        qbIn.seek( 1 );
+                        return new Token( tokOpenSquare );
+
+                    case ']':
+                        qbIn.seek( 1 );
+                        return new Token( tokCloseSquare );
+
+                    case '{':
+                        qbIn.seek( 1 );
+                        return new Token( tokOpenCurly );
+
+                    case '}':
+                        qbIn.seek( 1 );
+                        return new Token( tokCloseCurly );
+
+                    default:
+                        throw ExceptionBase("Unexpected character '%c'.",
+                            cBuf );
+                        break;
+                }
+            }
+        }
+    }
+
+    virtual String tokenToString( const Token &t )
+    {
+        switch( (TokenType)t.iToken )
+        {
+            case tokIdentifier:     return "tokIdentifier";
+            case tokColon:          return "tokColon";
+            case tokOr:             return "tokOr";
+            case tokSemiColon:      return "tokSemiColon";
+            case tokTokens:         return "tokTokens";
+            case tokEquals:         return "tokEquals";
+            case tokOpenCurly:      return "tokOpenCurly";
+            case tokCloseCurly:     return "tokCloseCurly";
+            case tokOpenSquare:     return "tokOpenSquare";
+            case tokCloseSquare:    return "tokCloseSquare";
+            case tokEos:            return "tokEos";
+        }
+
+        return "???";
+    }
 
 private:
-        Stream &rSrc;
-        QueueBuf qbIn;
-        String sBuf;
+    Stream &rSrc;
+    QueueBuf qbIn;
+    String sBuf;
 };
 
 class BnfParser
 {
 public:
-        BnfParser( BnfLexer &l ) :
-                l( l ),
-                pCur( NULL ),
-                iLastToken( 0 )
-        {
-        }
-
-        virtual ~BnfParser()
-        {
-                delete pCur;
-                pCur = NULL;
-        }
-
-        void parse()
-        {
-                for(;;)
-                {
-                        next();
-                        switch( pCur->iToken )
-                        {
-                                case tokTokens:
-                                        tokens();
-                                        break;
-
-                                case tokIdentifier:
-                                        nonTerminal();
-                                        break;
-
-                                case tokEos:
-                                        return;
-                                        break;
-
-                                default:
-                                        tokenError("tokTokens, tokIdentifier, or tokEos");
-                        }
-                }
-        }
+    BnfParser( BnfLexer &l ) :
+        l( l ),
+        pCur( NULL ),
+        iLastToken( 0 )
+    {
+    }
+
+    virtual ~BnfParser()
+    {
+        delete pCur;
+        pCur = NULL;
+    }
+
+    void parse()
+    {
+        for(;;)
+        {
+            next();
+            switch( pCur->iToken )
+            {
+                case tokTokens:
+                    tokens();
+                    break;
+
+                case tokIdentifier:
+                    nonTerminal();
+                    break;
+
+                case tokEos:
+                    return;
+                    break;
+
+                default:
+                    tokenError("tokTokens, tokIdentifier, or tokEos");
+            }
+        }
+    }
 
 private:
-        void tokens()
-        {
-                next();
-                if( pCur->iToken != tokEquals )
-                        tokenError("tokEquals");
-                for(;;)
-                {
-                        next();
-                        if( pCur->iToken == tokIdentifier )
-                        {
-                                hTokens.insert( pCur->vExtra.get<Bu::String>(), ++iLastToken );
-                                sio << "Added token[" << iLastToken << "]: "
-                                        << pCur->vExtra.get<Bu::String>() << sio.nl;
-                        }
-                        else if( pCur->iToken == tokSemiColon )
-                                break;
-                        else
-                                tokenError("tokIdentifier or tokSemiColon");
-                }
-        }
-
-        void nonTerminal()
-        {
-                Bu::String sNtName = pCur->vExtra.get<Bu::String>();
-                Parser::NonTerminal nt;
-                p.addNonTerminal( sNtName );
-                sio.incIndent();
-                sio << "Created non-terminal: " << sNtName << sio.nl;
-
-                next();
-                if( pCur->iToken != tokColon )
-                        tokenError("tokColon");
-                production( nt );
-                for(;;)
-                {
-                        switch( pCur->iToken )
-                        {
-                                case tokOr:
-                                        production( nt );
-                                        break;
-
-                                case tokSemiColon:
-                                        p.setNonTerminal( sNtName, nt );
-                                        sio.decIndent();
-                                        sio << "Closing non-terminal." << sio.nl;
-                                        return;
-
-                                default:
-                                        tokenError("tkOr or tokSemiColon");
-                                        break;
-                        }
-                }
-        }
-
-        void production( Parser::NonTerminal &nt )
-        {
-                sio.incIndent();
-                sio << "Adding new production:" << sio.nl;
-                Parser::Production pr;
-                bool bAnything = false;
-                for(;;)
-                {
-                        next();
-                        switch( pCur->iToken )
-                        {
-                                case tokIdentifier:
-                                        {
-                                                const Bu::String &sName =
-                                                        pCur->vExtra.get<Bu::String>();
-                                                if( hTokens.has( sName ) )
-                                                {
-                                                        pr.append(
-                                                                Parser::State(
-                                                                        Parser::State::typeTerminal,
-                                                                        hTokens.get( sName )
-                                                                        )
-                                                                );
-                                                        sio << "Added terminal " << sName << sio.nl;
-                                                }
-                                                else
-                                                {
-                                                        if( !p.hasNonTerminal( sName ) )
-                                                        {
-                                                                p.addNonTerminal( sName );
-                                                        }
-                                                        pr.append(
-                                                                Parser::State(
-                                                                        Parser::State::typeNonTerminal,
-                                                                        p.getNonTerminalId( sName )
-                                                                        )
-                                                                );
-                                                        sio << "Added non-terminal " << sName << sio.nl;
-                                                }
-                                        }
-                                        break;
-
-                                case tokOpenSquare:
-                                        {
-                                                next();
-                                                if( pCur->iToken != tokIdentifier )
-                                                        tokenError("tokIdentifier");
-                                                Bu::String sName =
-                                                        pCur->vExtra.get<Bu::String>();
-                                                next();
-                                                if( pCur->iToken != tokCloseSquare )
-                                                        tokenError("tokCloseSquare");
-
-                                                if( !hTokens.has( sName ) )
-                                                        throw ExceptionBase("Only token names may be "
-                                                                "enclosed in square brackets.");
-
-                                                pr.append(
-                                                        Parser::State(
-                                                                Parser::State::typeTerminalPush,
-                                                                hTokens.get( sName )
-                                                                )
-                                                        );
-                                                sio << "Added terminal-push " << sName << sio.nl;
-                                        }
-                                        break;
-
-                                case tokOpenCurly:
-                                        {
-                                                next();
-                                                if( pCur->iToken != tokIdentifier )
-                                                        tokenError("tokIdentifier");
-                                                Bu::String sName =
-                                                        pCur->vExtra.get<Bu::String>();
-                                                next();
-                                                if( pCur->iToken != tokCloseCurly )
-                                                        tokenError("tokCloseCurly");
-
-                                                if( !p.hasReduction( sName ) )
-                                                        p.addReduction( sName );
-
-                                                pr.append(
-                                                        Parser::State(
-                                                                Parser::State::typeReduction,
-                                                                p.getReductionId( sName )
-                                                                )
-                                                        );
-                                                sio << "Added reduction " << sName << sio.nl;
-                                        }
-                                        break;
-
-                                case tokOr:
-                                case tokSemiColon:
-                                        if( bAnything )
-                                        {
-                                                nt.addProduction( pr );
-                                                sio.decIndent();
-                                                sio << "Closing production." << sio.nl;
-                                        }
-                                        else
-                                        {
-                                                nt.setCanSkip();
-                                                sio.decIndent();
-                                                sio << "Closing empty production." << sio.nl;
-                                        }
-                                        return;
-
-                                default:
-                                        tokenError("tokIdentifier, tokOpenSquare, tokOr, "
-                                                        "tokOpenCurly, or tokSemiColon");
-                        }
-                }
-        }
+    void tokens()
+    {
+        next();
+        if( pCur->iToken != tokEquals )
+            tokenError("tokEquals");
+        for(;;)
+        {
+            next();
+            if( pCur->iToken == tokIdentifier )
+            {
+                hTokens.insert( pCur->vExtra.get<Bu::String>(), ++iLastToken );
+                sio << "Added token[" << iLastToken << "]: "
+                    << pCur->vExtra.get<Bu::String>() << sio.nl;
+            }
+            else if( pCur->iToken == tokSemiColon )
+                break;
+            else
+                tokenError("tokIdentifier or tokSemiColon");
+        }
+    }
+
+    void nonTerminal()
+    {
+        Bu::String sNtName = pCur->vExtra.get<Bu::String>();
+        Parser::NonTerminal nt;
+        p.addNonTerminal( sNtName );
+        sio.incIndent();
+        sio << "Created non-terminal: " << sNtName << sio.nl;
+
+        next();
+        if( pCur->iToken != tokColon )
+            tokenError("tokColon");
+        production( nt );
+        for(;;)
+        {
+            switch( pCur->iToken )
+            {
+                case tokOr:
+                    production( nt );
+                    break;
+
+                case tokSemiColon:
+                    p.setNonTerminal( sNtName, nt );
+                    sio.decIndent();
+                    sio << "Closing non-terminal." << sio.nl;
+                    return;
+
+                default:
+                    tokenError("tkOr or tokSemiColon");
+                    break;
+            }
+        }
+    }
+
+    void production( Parser::NonTerminal &nt )
+    {
+        sio.incIndent();
+        sio << "Adding new production:" << sio.nl;
+        Parser::Production pr;
+        bool bAnything = false;
+        for(;;)
+        {
+            next();
+            switch( pCur->iToken )
+            {
+                case tokIdentifier:
+                    {
+                        const Bu::String &sName =
+                            pCur->vExtra.get<Bu::String>();
+                        if( hTokens.has( sName ) )
+                        {
+                            pr.append(
+                                Parser::State(
+                                    Parser::State::typeTerminal,
+                                    hTokens.get( sName )
+                                    )
+                                );
+                            sio << "Added terminal " << sName << sio.nl;
+                        }
+                        else
+                        {
+                            if( !p.hasNonTerminal( sName ) )
+                            {
+                                p.addNonTerminal( sName );
+                            }
+                            pr.append(
+                                Parser::State(
+                                    Parser::State::typeNonTerminal,
+                                    p.getNonTerminalId( sName )
+                                    )
+                                );
+                            sio << "Added non-terminal " << sName << sio.nl;
+                        }
+                    }
+                    break;
+
+                case tokOpenSquare:
+                    {
+                        next();
+                        if( pCur->iToken != tokIdentifier )
+                            tokenError("tokIdentifier");
+                        Bu::String sName =
+                            pCur->vExtra.get<Bu::String>();
+                        next();
+                        if( pCur->iToken != tokCloseSquare )
+                            tokenError("tokCloseSquare");
+
+                        if( !hTokens.has( sName ) )
+                            throw ExceptionBase("Only token names may be "
+                                "enclosed in square brackets.");
+
+                        pr.append(
+                            Parser::State(
+                                Parser::State::typeTerminalPush,
+                                hTokens.get( sName )
+                                )
+                            );
+                        sio << "Added terminal-push " << sName << sio.nl;
+                    }
+                    break;
+
+                case tokOpenCurly:
+                    {
+                        next();
+                        if( pCur->iToken != tokIdentifier )
+                            tokenError("tokIdentifier");
+                        Bu::String sName =
+                            pCur->vExtra.get<Bu::String>();
+                        next();
+                        if( pCur->iToken != tokCloseCurly )
+                            tokenError("tokCloseCurly");
+
+                        if( !p.hasReduction( sName ) )
+                            p.addReduction( sName );
+
+                        pr.append(
+                            Parser::State(
+                                Parser::State::typeReduction,
+                                p.getReductionId( sName )
+                                )
+                            );
+                        sio << "Added reduction " << sName << sio.nl;
+                    }
+                    break;
+
+                case tokOr:
+                case tokSemiColon:
+                    if( bAnything )
+                    {
+                        nt.addProduction( pr );
+                        sio.decIndent();
+                        sio << "Closing production." << sio.nl;
+                    }
+                    else
+                    {
+                        nt.setCanSkip();
+                        sio.decIndent();
+                        sio << "Closing empty production." << sio.nl;
+                    }
+                    return;
+
+                default:
+                    tokenError("tokIdentifier, tokOpenSquare, tokOr, "
+                            "tokOpenCurly, or tokSemiColon");
+            }
+        }
+    }
 
 private:
-        void next()
-        {
-                delete pCur;
-                pCur = l.nextToken();
-        }
-
-        void tokenError( const String &s )
-        {
-                throw ExceptionBase( ("Expected " + s + " but found "
-                                + l.tokenToString( *pCur ) + ".").getStr() );
-        }
+    void next()
+    {
+        delete pCur;
+        pCur = l.nextToken();
+    }
+
+    void tokenError( const String &s )
+    {
+        throw ExceptionBase( ("Expected " + s + " but found "
+                + l.tokenToString( *pCur ) + ".").getStr() );
+    }
 
 private:
-        typedef Bu::Hash<Bu::String, int> TokenHash;
-        TokenHash hTokens;
-        BnfLexer &l;
-        BnfLexer::Token *pCur;
-        int iLastToken;
-        Parser p;
+    typedef Bu::Hash<Bu::String, int> TokenHash;
+    TokenHash hTokens;
+    BnfLexer &l;
+    BnfLexer::Token *pCur;
+    int iLastToken;
+    Parser p;
 };
 
 int main( int argc, char *argv[] )
 {
-        if( argc < 2 )
-        {
-                println("Provide an input filename as the first parameter.");
-                return 0;
-        }
-        File fIn( argv[1], File::Read );
+    if( argc < 2 )
+    {
+        println("Provide an input filename as the first parameter.");
+        return 0;
+    }
+    File fIn( argv[1], File::Read );
 
-        BnfLexer bl( fIn );
-        BnfParser parser( bl );
+    BnfLexer bl( fIn );
+    BnfParser parser( bl );
 
-        parser.parse();
+    parser.parse();
 
 /*
-        for(;;)
-        {
-                Lexer::Token *pTok = bl.nextToken();
-                sio << bl.tokenToString(*pTok);
-                if( pTok->vExtra.isSet() )
-                {
-                        sio << " - " << pTok->vExtra;
-                }
-                sio << sio.nl;
-                if( pTok->iToken == tokEos )
-                        break;
-        }
+    for(;;)
+    {
+        Lexer::Token *pTok = bl.nextToken();
+        sio << bl.tokenToString(*pTok);
+        if( pTok->vExtra.isSet() )
+        {
+            sio << " - " << pTok->vExtra;
+        }
+        sio << sio.nl;
+        if( pTok->iToken == tokEos )
+            break;
+    }
 */
 
-        return 0;
+    return 0;
 }
 
diff --git a/src/tests/bzip2.cpp b/src/tests/bzip2.cpp
index 1b6fc2f..26bb9bd 100644
--- a/src/tests/bzip2.cpp
+++ b/src/tests/bzip2.cpp
@@ -10,27 +10,27 @@
 
 int main( int argc, char *argv[] )
 {
-        if( argc < 3 )
-        {
-                printf("usage:  %s <in> <out>\n", argv[0] );
-                return -1;
-        }
+    if( argc < 3 )
+    {
+        printf("usage:  %s <in> <out>\n", argv[0] );
+        return -1;
+    }
 
-        char buf[1024];
-        size_t nRead;
+    char buf[1024];
+    size_t nRead;
 
-        Bu::File fin( argv[1], Bu::File::Read );
-        
-        Bu::File f( argv[2], Bu::File::WriteNew );
-        Bu::BZip2 bz2( f );
+    Bu::File fin( argv[1], Bu::File::Read );
+    
+    Bu::File f( argv[2], Bu::File::WriteNew );
+    Bu::BZip2 bz2( f );
 
-        for(;;)
-        {
-                nRead = fin.read( buf, 1024 );
-                if( nRead > 0 )
-                        bz2.write( buf, nRead );
-                if( fin.isEos() )
-                        break;
-        }
+    for(;;)
+    {
+        nRead = fin.read( buf, 1024 );
+        if( nRead > 0 )
+            bz2.write( buf, nRead );
+        if( fin.isEos() )
+            break;
+    }
 }
 
diff --git a/src/tests/deflate.cpp b/src/tests/deflate.cpp
index 8290ed5..89640e1 100644
--- a/src/tests/deflate.cpp
+++ b/src/tests/deflate.cpp
@@ -10,44 +10,44 @@
 
 int main( int argc, char *argv[] )
 {
-        if( argc < 3 )
-        {
-                printf("usage:  %s <in> <out>\n", argv[0] );
-                return -1;
-        }
-
-        char buf[1024];
-        size_t nRead;
-
-        /*
-        Bu::File fin( argv[1], Bu::File::Read );
-        fin.seek( 4 );
-        Bu::Deflate def( fin );
-        
-        Bu::File f( argv[2], Bu::File::WriteNew );
-
-        for(;;)
-        {
-                nRead = def.read( buf, 1024 );
-                if( nRead > 0 )
-                        f.write( buf, nRead );
-                if( def.isEos() )
-                        break;
-        }
-        */
-
-        Bu::File fin( argv[1], Bu::File::Read );
-        
-        Bu::File f( argv[2], Bu::File::WriteNew );
-        Bu::Deflate def( f, 9, Bu::Deflate::Gzip );
-
-        for(;;)
-        {
-                nRead = fin.read( buf, 1024 );
-                if( nRead > 0 )
-                        def.write( buf, nRead );
-                if( fin.isEos() )
-                        break;
-        }
+    if( argc < 3 )
+    {
+        printf("usage:  %s <in> <out>\n", argv[0] );
+        return -1;
+    }
+
+    char buf[1024];
+    size_t nRead;
+
+    /*
+    Bu::File fin( argv[1], Bu::File::Read );
+    fin.seek( 4 );
+    Bu::Deflate def( fin );
+    
+    Bu::File f( argv[2], Bu::File::WriteNew );
+
+    for(;;)
+    {
+        nRead = def.read( buf, 1024 );
+        if( nRead > 0 )
+            f.write( buf, nRead );
+        if( def.isEos() )
+            break;
+    }
+    */
+
+    Bu::File fin( argv[1], Bu::File::Read );
+    
+    Bu::File f( argv[2], Bu::File::WriteNew );
+    Bu::Deflate def( f, 9, Bu::Deflate::Gzip );
+
+    for(;;)
+    {
+        nRead = fin.read( buf, 1024 );
+        if( nRead > 0 )
+            def.write( buf, nRead );
+        if( fin.isEos() )
+            break;
+    }
 }
 
diff --git a/src/tests/lzma.cpp b/src/tests/lzma.cpp
index 596c396..7d4d1eb 100644
--- a/src/tests/lzma.cpp
+++ b/src/tests/lzma.cpp
@@ -10,44 +10,44 @@
 
 int main( int argc, char *argv[] )
 {
-        if( argc < 3 )
-        {
-                printf("usage:  %s <in> <out>\n", argv[0] );
-                return -1;
-        }
-
-        char buf[1024];
-        size_t nRead;
-
-        /*
-        Bu::File fin( argv[1], Bu::File::Read );
-        fin.seek( 4 );
-        Bu::Deflate def( fin );
-        
-        Bu::File f( argv[2], Bu::File::WriteNew );
-
-        for(;;)
-        {
-                nRead = def.read( buf, 1024 );
-                if( nRead > 0 )
-                        f.write( buf, nRead );
-                if( def.isEos() )
-                        break;
-        }
-        */
-
-        Bu::File fin( argv[1], Bu::File::Read );
-        
-        Bu::File f( argv[2], Bu::File::WriteNew );
-        Bu::Lzma def( f, 9 );
-
-        for(;;)
-        {
-                nRead = fin.read( buf, 1024 );
-                if( nRead > 0 )
-                        def.write( buf, nRead );
-                if( fin.isEos() )
-                        break;
-        }
+    if( argc < 3 )
+    {
+        printf("usage:  %s <in> <out>\n", argv[0] );
+        return -1;
+    }
+
+    char buf[1024];
+    size_t nRead;
+
+    /*
+    Bu::File fin( argv[1], Bu::File::Read );
+    fin.seek( 4 );
+    Bu::Deflate def( fin );
+    
+    Bu::File f( argv[2], Bu::File::WriteNew );
+
+    for(;;)
+    {
+        nRead = def.read( buf, 1024 );
+        if( nRead > 0 )
+            f.write( buf, nRead );
+        if( def.isEos() )
+            break;
+    }
+    */
+
+    Bu::File fin( argv[1], Bu::File::Read );
+    
+    Bu::File f( argv[2], Bu::File::WriteNew );
+    Bu::Lzma def( f, 9 );
+
+    for(;;)
+    {
+        nRead = fin.read( buf, 1024 );
+        if( nRead > 0 )
+            def.write( buf, nRead );
+        if( fin.isEos() )
+            break;
+    }
 }
 
diff --git a/src/tests/myriadfs.cpp b/src/tests/myriadfs.cpp
index f57f02d..cb6c6c3 100644
--- a/src/tests/myriadfs.cpp
+++ b/src/tests/myriadfs.cpp
@@ -8,41 +8,41 @@ using namespace Bu;
 
 int main()
 {
-//      Bu::MemBuf mb;
-        Bu::File mb("store.myr", File::Read|File::Write|File::Create );
-        Bu::MyriadFs mfs( mb, 512 );
+//  Bu::MemBuf mb;
+    Bu::File mb("store.myr", File::Read|File::Write|File::Create );
+    Bu::MyriadFs mfs( mb, 512 );
 
-        sio << "Creating dirs..." << sio.nl;
-        mfs.create("/etc", Bu::MyriadFs::typeDir|0755 );
-        mfs.create("/dev", Bu::MyriadFs::typeDir|0755 );
-        mfs.create("/usr", Bu::MyriadFs::typeDir|0755 );
+    sio << "Creating dirs..." << sio.nl;
+    mfs.create("/etc", Bu::MyriadFs::typeDir|0755 );
+    mfs.create("/dev", Bu::MyriadFs::typeDir|0755 );
+    mfs.create("/usr", Bu::MyriadFs::typeDir|0755 );
 
-        mfs.create("/dev/null", Bu::MyriadFs::typeChrDev|0666, 1, 3 );
-        mfs.create("/dev/zero", Bu::MyriadFs::typeChrDev|0666, 1, 5 );
-        mfs.create("/dev/sda", Bu::MyriadFs::typeBlkDev|0660, 8, 0 );
+    mfs.create("/dev/null", Bu::MyriadFs::typeChrDev|0666, 1, 3 );
+    mfs.create("/dev/zero", Bu::MyriadFs::typeChrDev|0666, 1, 5 );
+    mfs.create("/dev/sda", Bu::MyriadFs::typeBlkDev|0660, 8, 0 );
 
-        sio << "Creating files..." << sio.nl;
-        {
-                Bu::MyriadStream ms = mfs.open("/hello", Bu::MyriadFs::Read );
-                ms.write("world!");
-        }
-        {
-                Bu::MyriadStream ms = mfs.open("/etc/hello", Bu::MyriadFs::Read );
-                ms.write("world, again!");
-        }
+    sio << "Creating files..." << sio.nl;
+    {
+        Bu::MyriadStream ms = mfs.open("/hello", Bu::MyriadFs::Read );
+        ms.write("world!");
+    }
+    {
+        Bu::MyriadStream ms = mfs.open("/etc/hello", Bu::MyriadFs::Read );
+        ms.write("world, again!");
+    }
 
-        sio << "Reading files..." << sio.nl;
-        {
-                Bu::MyriadStream ms = mfs.open("/hello", Bu::MyriadFs::Read );
-                char buf[512];
-                buf[ms.read( buf, 512 )] = '\0';
-                sio << "read: '" << buf << "'" << sio.nl;
-        }
-        {
-                Bu::MyriadStream ms = mfs.open("/etc/hello", Bu::MyriadFs::Read );
-                char buf[512];
-                buf[ms.read( buf, 512 )] = '\0';
-                sio << "read: '" << buf << "'" << sio.nl;
-        }
+    sio << "Reading files..." << sio.nl;
+    {
+        Bu::MyriadStream ms = mfs.open("/hello", Bu::MyriadFs::Read );
+        char buf[512];
+        buf[ms.read( buf, 512 )] = '\0';
+        sio << "read: '" << buf << "'" << sio.nl;
+    }
+    {
+        Bu::MyriadStream ms = mfs.open("/etc/hello", Bu::MyriadFs::Read );
+        char buf[512];
+        buf[ms.read( buf, 512 )] = '\0';
+        sio << "read: '" << buf << "'" << sio.nl;
+    }
 }
 
diff --git a/src/tests/optparser.cpp b/src/tests/optparser.cpp
index 772cebc..05e5168 100644
--- a/src/tests/optparser.cpp
+++ b/src/tests/optparser.cpp
@@ -12,82 +12,82 @@ using namespace Bu;
 class Opts : public Bu::OptParser
 {
 public:
-        Opts() :
-                iBob( 542 ),
-                bVal( false )
-        {
-                addHelpBanner("optparser - Test some option things...");
+    Opts() :
+        iBob( 542 ),
+        bVal( false )
+    {
+        addHelpBanner("optparser - Test some option things...");
 
-                addHelpBanner("\nThis section represents options that actually have "
-                        "callbacks, or in the case of the new system, signals/slots.  They "
-                        "all take parameters, but if they return 0 then it will be as "
-                        "though they hadn't and the next thing will be processed normally.",
-                        true
-                        );
-                addOption( slot( this, &Opts::yesparam ), 'x', "things",
-                        "This is the first test parameter.  It calls a function, and "
-                        "takes a parameter."
-                        );
-                addOption( slot( this, &Opts::noparam ), 'y', "stuff",
-                        "This is the second test parameter.  It does not take "
-                        "parameters.  However, I do want to make this part much longer to "
-                        "see how it looks when you add way too much text to one of these "
-                        "things.  It can't really be that bad, right?"
-                        );
+        addHelpBanner("\nThis section represents options that actually have "
+            "callbacks, or in the case of the new system, signals/slots.  They "
+            "all take parameters, but if they return 0 then it will be as "
+            "though they hadn't and the next thing will be processed normally.",
+            true
+            );
+        addOption( slot( this, &Opts::yesparam ), 'x', "things",
+            "This is the first test parameter.  It calls a function, and "
+            "takes a parameter."
+            );
+        addOption( slot( this, &Opts::noparam ), 'y', "stuff",
+            "This is the second test parameter.  It does not take "
+            "parameters.  However, I do want to make this part much longer to "
+            "see how it looks when you add way too much text to one of these "
+            "things.  It can't really be that bad, right?"
+            );
 
-                addHelpBanner("\nThis section represents options with no callback or "
-                        "signal, but do have a variable to update.  They use the Formatter "
-                        "system and therefore it's very, very flexible.  Any data type "
-                        "you can read with a formatter you can set via parameter.",
-                        true
-                        );
-                addOption( sVar, 's', "str", "Set a variable, see what it does.");
-                addOption( bVal, 'b', "bool", "It's a thing.");
-                addOption( iBob, "bob", "Change iBob to whatever you want.");
-                addOption( dBob, 'd', "Change dBob to whatever you want.");
+        addHelpBanner("\nThis section represents options with no callback or "
+            "signal, but do have a variable to update.  They use the Formatter "
+            "system and therefore it's very, very flexible.  Any data type "
+            "you can read with a formatter you can set via parameter.",
+            true
+            );
+        addOption( sVar, 's', "str", "Set a variable, see what it does.");
+        addOption( bVal, 'b', "bool", "It's a thing.");
+        addOption( iBob, "bob", "Change iBob to whatever you want.");
+        addOption( dBob, 'd', "Change dBob to whatever you want.");
 
-                setOverride("str", "Bob!");
-                setHelpDefault("bob", "=542");
-                setOverride("bool", true );
-        
-                addHelpOption();
+        setOverride("str", "Bob!");
+        setHelpDefault("bob", "=542");
+        setOverride("bool", true );
+    
+        addHelpOption();
 
-                setNonOption( slot( this, &Opts::nonOption ) );
-        }
+        setNonOption( slot( this, &Opts::nonOption ) );
+    }
 
-        int yesparam( StrArray aParams )
-        {
-                sio << " - yesparam" << aParams << sio.nl;
-                return 1;
-        }
+    int yesparam( StrArray aParams )
+    {
+        sio << " - yesparam" << aParams << sio.nl;
+        return 1;
+    }
 
-        int noparam( StrArray aParams )
-        {
-                sio << " - noparam" << aParams << sio.nl;
-                return 0;
-        }
+    int noparam( StrArray aParams )
+    {
+        sio << " - noparam" << aParams << sio.nl;
+        return 0;
+    }
 
-        int nonOption( StrArray aParams )
-        {
-                sio << " - nonOption" << aParams << sio.nl;
-                return aParams.getSize()-1;
-        }
+    int nonOption( StrArray aParams )
+    {
+        sio << " - nonOption" << aParams << sio.nl;
+        return aParams.getSize()-1;
+    }
 
-        int iBob;
-        float dBob;
-        Bu::String sVar;
-        bool bVal;
+    int iBob;
+    float dBob;
+    Bu::String sVar;
+    bool bVal;
 };
 
 int main( int argc, char *argv[] )
 {
-        Opts o;
+    Opts o;
 
-        o.parse( argc, argv );
+    o.parse( argc, argv );
 
-        sio << "sVar = \"" << o.sVar << "\"" << sio.nl;
-        sio << "iBob = " << o.iBob << sio.nl;
-        sio << "dBob = " << o.dBob << sio.nl;
-        sio << "bVal = " << o.bVal << sio.nl;
+    sio << "sVar = \"" << o.sVar << "\"" << sio.nl;
+    sio << "iBob = " << o.iBob << sio.nl;
+    sio << "dBob = " << o.dBob << sio.nl;
+    sio << "bVal = " << o.bVal << sio.nl;
 }
 
diff --git a/src/tests/parser.cpp b/src/tests/parser.cpp
index af53bc8..6ad722f 100644
--- a/src/tests/parser.cpp
+++ b/src/tests/parser.cpp
@@ -16,185 +16,185 @@ using namespace Bu;
 
 enum Tok
 {
-        tokNumber,
-        tokPlus,
-        tokMinus,
-        tokDivide,
-        tokMultiply,
-        tokOpenParen,
-        tokCloseParen,
-        tokCompute,
-        tokEndOfInput=-1
+    tokNumber,
+    tokPlus,
+    tokMinus,
+    tokDivide,
+    tokMultiply,
+    tokOpenParen,
+    tokCloseParen,
+    tokCompute,
+    tokEndOfInput=-1
 };
 
 Bu::Formatter &operator<<( Bu::Formatter &f, Tok e )
 {
-        switch( e )
-        {
-                case tokNumber: return f << "tokNumber";
-                case tokPlus: return f << "tokPlus";
-                case tokMinus: return f << "tokMinus";
-                case tokDivide: return f << "tokDivide";
-                case tokMultiply: return f << "tokMultiply";
-                case tokOpenParen: return f << "tokOpenParen";
-                case tokCloseParen: return f << "tokCloseParen";
-                case tokCompute: return f << "tokCompute";
-                case tokEndOfInput: return f << "tokEndOfInput";
-        }
-
-        return f << "***error***";
+    switch( e )
+    {
+        case tokNumber: return f << "tokNumber";
+        case tokPlus: return f << "tokPlus";
+        case tokMinus: return f << "tokMinus";
+        case tokDivide: return f << "tokDivide";
+        case tokMultiply: return f << "tokMultiply";
+        case tokOpenParen: return f << "tokOpenParen";
+        case tokCloseParen: return f << "tokCloseParen";
+        case tokCompute: return f << "tokCompute";
+        case tokEndOfInput: return f << "tokEndOfInput";
+    }
+
+    return f << "***error***";
 }
 
 class MathLexer : public Lexer
 {
 public:
-        MathLexer( Bu::Stream &rSrc ) :
-                rSrc( rSrc )
-        {
-        }
-
-        virtual ~MathLexer()
-        {
-        }
-
-        enum TokenTypes
-        {
-                tokStuff
-        };
-
-        virtual Token *nextToken()
-        {
-                for(;;)
-                {
-                        if( qbIn.getSize() == 0 )
-                        {
-                                char buf[4096];
-                                qbIn.write( buf, rSrc.read( buf, 4096 ) );
-
-                                if( rSrc.isEos() && qbIn.getSize() == 0 )
-                                        return new Token( tokEndOfInput );
-                        }
-
-                        char b;
-                        qbIn.peek( &b, 1 );
-                        switch( b )
-                        {
-                                case '+':
-                                        qbIn.seek( 1 );
-                                        return new Token( tokPlus );
-
-                                case '-':
-                                        qbIn.seek( 1 );
-                                        return new Token( tokMinus );
-
-                                case '/':
-                                        qbIn.seek( 1 );
-                                        return new Token( tokDivide );
-
-                                case '*':
-                                        qbIn.seek( 1 );
-                                        return new Token( tokMultiply );
-
-                                case ' ':
-                                case '\t':
-                                case '\n':
-                                        qbIn.seek( 1 );
-                                        break;
-
-                                case '=':
-                                        qbIn.seek( 1 );
-                                        return new Token( tokCompute );
-
-                                case '(':
-                                        qbIn.seek( 1 );
-                                        return new Token( tokOpenParen );
-
-                                case ')':
-                                        qbIn.seek( 1 );
-                                        return new Token( tokCloseParen );
-
-                                case '.':
-                                case '0':
-                                case '1':
-                                case '2':
-                                case '3':
-                                case '4':
-                                case '5':
-                                case '6':
-                                case '7':
-                                case '8':
-                                case '9':
-                                        {
-                                                Bu::String sTmp;
-                                                sTmp += b;
-                                                qbIn.seek( 1 );
-                                                for(;;)
-                                                {
-                                                        qbIn.peek( &b, 1 );
-                                                        if( b != '.' && (b < '0' || b > '9') )
-                                                        {
-                                                                sio << "!! Convert '" << sTmp << "' to "
-                                                                        << strtod( sTmp.getStr(), NULL ) << sio.nl;
-                                                                return new Token(
-                                                                        tokNumber, strtod( sTmp.getStr(), NULL )
-                                                                        );
-                                                        }
-                                                        qbIn.seek( 1 );
-                                                        sTmp += b;
-                                                }
-                                        }
-                                        break;
-
-                                default:
-                                        throw Bu::ExceptionBase("Unexpected character '%c'.", b );
-                        }
-                }
-        }
+    MathLexer( Bu::Stream &rSrc ) :
+        rSrc( rSrc )
+    {
+    }
+
+    virtual ~MathLexer()
+    {
+    }
+
+    enum TokenTypes
+    {
+        tokStuff
+    };
+
+    virtual Token *nextToken()
+    {
+        for(;;)
+        {
+            if( qbIn.getSize() == 0 )
+            {
+                char buf[4096];
+                qbIn.write( buf, rSrc.read( buf, 4096 ) );
+
+                if( rSrc.isEos() && qbIn.getSize() == 0 )
+                    return new Token( tokEndOfInput );
+            }
+
+            char b;
+            qbIn.peek( &b, 1 );
+            switch( b )
+            {
+                case '+':
+                    qbIn.seek( 1 );
+                    return new Token( tokPlus );
+
+                case '-':
+                    qbIn.seek( 1 );
+                    return new Token( tokMinus );
+
+                case '/':
+                    qbIn.seek( 1 );
+                    return new Token( tokDivide );
+
+                case '*':
+                    qbIn.seek( 1 );
+                    return new Token( tokMultiply );
+
+                case ' ':
+                case '\t':
+                case '\n':
+                    qbIn.seek( 1 );
+                    break;
+
+                case '=':
+                    qbIn.seek( 1 );
+                    return new Token( tokCompute );
+
+                case '(':
+                    qbIn.seek( 1 );
+                    return new Token( tokOpenParen );
+
+                case ')':
+                    qbIn.seek( 1 );
+                    return new Token( tokCloseParen );
+
+                case '.':
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                    {
+                        Bu::String sTmp;
+                        sTmp += b;
+                        qbIn.seek( 1 );
+                        for(;;)
+                        {
+                            qbIn.peek( &b, 1 );
+                            if( b != '.' && (b < '0' || b > '9') )
+                            {
+                                sio << "!! Convert '" << sTmp << "' to "
+                                    << strtod( sTmp.getStr(), NULL ) << sio.nl;
+                                return new Token(
+                                    tokNumber, strtod( sTmp.getStr(), NULL )
+                                    );
+                            }
+                            qbIn.seek( 1 );
+                            sTmp += b;
+                        }
+                    }
+                    break;
+
+                default:
+                    throw Bu::ExceptionBase("Unexpected character '%c'.", b );
+            }
+        }
+    }
 
 private:
-        Bu::Stream &rSrc;
-        QueueBuf qbIn;
+    Bu::Stream &rSrc;
+    QueueBuf qbIn;
 };
 
 void redAdd( Bu::Parser &p )
 {
-        Lexer::Token *a = p.popToken();
-        Lexer::Token *b = p.popToken();
+    Lexer::Token *a = p.popToken();
+    Lexer::Token *b = p.popToken();
 
-        sio << "Add!  " << b->vExtra.get<double>() << " + "
-                << a->vExtra.get<double>() << sio.nl;
+    sio << "Add!  " << b->vExtra.get<double>() << " + "
+        << a->vExtra.get<double>() << sio.nl;
 
-        Lexer::Token *c = new Lexer::Token( tokNumber, 
-                b->vExtra.get<double>() + a->vExtra.get<double>()
-                );
-        p.pushToken( c );
+    Lexer::Token *c = new Lexer::Token( tokNumber, 
+        b->vExtra.get<double>() + a->vExtra.get<double>()
+        );
+    p.pushToken( c );
 
-        delete a;
-        delete b;
+    delete a;
+    delete b;
 }
 
 void redSubtract( Bu::Parser &p )
 {
-        Lexer::Token *a = p.popToken();
-        Lexer::Token *b = p.popToken();
+    Lexer::Token *a = p.popToken();
+    Lexer::Token *b = p.popToken();
 
-        sio << "Subtract!  " << b->vExtra.get<double>() << " - "
-                << a->vExtra.get<double>() << sio.nl;
+    sio << "Subtract!  " << b->vExtra.get<double>() << " - "
+        << a->vExtra.get<double>() << sio.nl;
 
-        Lexer::Token *c = new Lexer::Token( tokNumber, 
-                b->vExtra.get<double>() - a->vExtra.get<double>()
-                );
-        p.pushToken( c );
+    Lexer::Token *c = new Lexer::Token( tokNumber, 
+        b->vExtra.get<double>() - a->vExtra.get<double>()
+        );
+    p.pushToken( c );
 
-        delete a;
-        delete b;
+    delete a;
+    delete b;
 }
 
 void redPrint( Bu::Parser &p )
 {
-        Lexer::Token *a = p.popToken();
-        sio << "Print! = " << a->vExtra.get<double>() << sio.nl;
-        delete a;
+    Lexer::Token *a = p.popToken();
+    sio << "Print! = " << a->vExtra.get<double>() << sio.nl;
+    delete a;
 }
 
 /* Basic grammer example:
@@ -227,143 +227,143 @@ void redPrint( Bu::Parser &p )
 
 int main( int argc, char *argv[] )
 {
-        if( argc < 2 )
-        {
-                println("Provide an input filename as the first parameter.");
-                return 0;
-        }
-        File fIn( argv[1], File::Read );
-
-        Parser p;
-
-        p.addNonTerminal("expr");
-        p.addNonTerminal("expr-sub1");
-        p.addNonTerminal("expr-sub2");
-        {
-                Parser::NonTerminal nt;
-                nt.addProduction(
-                        Parser::Production(
-                                Parser::State(
-                                        Parser::State::typeTerminal,
-                                        tokPlus
-                                        )
-                                ).append(
-                                Parser::State(
-                                        Parser::State::typeNonTerminal,
-                                        p.getNonTerminalId("expr")
-                                        )
-                                ).append(
-                                Parser::State(
-                                        Parser::State::typeReduction,
-                                        p.addReduction("add")
-                                        )
-                                )
-                        );
-                nt.addProduction(
-                        Parser::Production(
-                                Parser::State(
-                                        Parser::State::typeTerminal,
-                                        tokMinus
-                                        )
-                                ).append(
-                                Parser::State(
-                                        Parser::State::typeNonTerminal,
-                                        p.getNonTerminalId("expr")
-                                        )
-                                ).append(
-                                Parser::State(
-                                        Parser::State::typeReduction,
-                                        p.addReduction("subtract")
-                                        )
-                                )
-                        );
-                nt.addProduction(
-                        Parser::Production(
-                                )
-                        );
-                nt.setCanSkip();
-                p.setNonTerminal("expr-sub2", nt );
-        }
-        {
-                Parser::NonTerminal nt;
-                nt.addProduction(
-                        Parser::Production(
-                                Parser::State(
-                                        Parser::State::typeTerminalPush,
-                                        tokNumber
-                                        )
-                                )
-                        );
-                nt.addProduction(
-                        Parser::Production(
-                                Parser::State(
-                                        Parser::State::typeTerminal,
-                                        tokOpenParen
-                                        )
-                                ).append(
-                                Parser::State(
-                                        Parser::State::typeNonTerminal,
-                                        p.getNonTerminalId("expr")
-                                        )
-                                ).append(
-                                Parser::State(
-                                        Parser::State::typeTerminal,
-                                        tokCloseParen
-                                        )
-                                )
-                        );
-                p.setNonTerminal("expr-sub1", nt );
-        }
-        {
-                Parser::NonTerminal nt;
-                nt.addProduction(
-                        Parser::Production(
-                                Parser::State(
-                                        Parser::State::typeNonTerminal,
-                                        p.getNonTerminalId("expr-sub1")
-                                        )
-                                ).append(
-                                Parser::State(
-                                        Parser::State::typeNonTerminal,
-                                        p.getNonTerminalId("expr-sub2")
-                                        )
-                                )
-                        );
-                p.setNonTerminal("expr", nt );
-        }
-        {
-                Parser::NonTerminal nt;
-                nt.addProduction(
-                        Parser::Production(
-                                Parser::State(
-                                        Parser::State::typeNonTerminal,
-                                        p.getNonTerminalId("expr")
-                                        )
-                                ).append(
-                                Parser::State(
-                                        Parser::State::typeTerminal,
-                                        tokCompute
-                                        )
-                                ).append(
-                                Parser::State(
-                                        Parser::State::typeReduction,
-                                        p.addReduction("print")
-                                        )
-                                )
-                        );
-                p.addNonTerminal("input", nt );
-        }
-
-        p.setRootNonTerminal("input");
-
-        p.setReduction("add", Bu::slot( &redAdd ) );
-        p.setReduction("subtract", Bu::slot( &redSubtract ) );
-        p.setReduction("print", Bu::slot( &redPrint ) );
-
-        p.pushLexer( new MathLexer( fIn ) );
-
-        p.parse();
-
-        return 0;
+    if( argc < 2 )
+    {
+        println("Provide an input filename as the first parameter.");
+        return 0;
+    }
+    File fIn( argv[1], File::Read );
+
+    Parser p;
+
+    p.addNonTerminal("expr");
+    p.addNonTerminal("expr-sub1");
+    p.addNonTerminal("expr-sub2");
+    {
+        Parser::NonTerminal nt;
+        nt.addProduction(
+            Parser::Production(
+                Parser::State(
+                    Parser::State::typeTerminal,
+                    tokPlus
+                    )
+                ).append(
+                Parser::State(
+                    Parser::State::typeNonTerminal,
+                    p.getNonTerminalId("expr")
+                    )
+                ).append(
+                Parser::State(
+                    Parser::State::typeReduction,
+                    p.addReduction("add")
+                    )
+                )
+            );
+        nt.addProduction(
+            Parser::Production(
+                Parser::State(
+                    Parser::State::typeTerminal,
+                    tokMinus
+                    )
+                ).append(
+                Parser::State(
+                    Parser::State::typeNonTerminal,
+                    p.getNonTerminalId("expr")
+                    )
+                ).append(
+                Parser::State(
+                    Parser::State::typeReduction,
+                    p.addReduction("subtract")
+                    )
+                )
+            );
+        nt.addProduction(
+            Parser::Production(
+                )
+            );
+        nt.setCanSkip();
+        p.setNonTerminal("expr-sub2", nt );
+    }
+    {
+        Parser::NonTerminal nt;
+        nt.addProduction(
+            Parser::Production(
+                Parser::State(
+                    Parser::State::typeTerminalPush,
+                    tokNumber
+                    )
+                )
+            );
+        nt.addProduction(
+            Parser::Production(
+                Parser::State(
+                    Parser::State::typeTerminal,
+                    tokOpenParen
+                    )
+                ).append(
+                Parser::State(
+                    Parser::State::typeNonTerminal,
+                    p.getNonTerminalId("expr")
+                    )
+                ).append(
+                Parser::State(
+                    Parser::State::typeTerminal,
+                    tokCloseParen
+                    )
+                )
+            );
+        p.setNonTerminal("expr-sub1", nt );
+    }
+    {
+        Parser::NonTerminal nt;
+        nt.addProduction(
+            Parser::Production(
+                Parser::State(
+                    Parser::State::typeNonTerminal,
+                    p.getNonTerminalId("expr-sub1")
+                    )
+                ).append(
+                Parser::State(
+                    Parser::State::typeNonTerminal,
+                    p.getNonTerminalId("expr-sub2")
+                    )
+                )
+            );
+        p.setNonTerminal("expr", nt );
+    }
+    {
+        Parser::NonTerminal nt;
+        nt.addProduction(
+            Parser::Production(
+                Parser::State(
+                    Parser::State::typeNonTerminal,
+                    p.getNonTerminalId("expr")
+                    )
+                ).append(
+                Parser::State(
+                    Parser::State::typeTerminal,
+                    tokCompute
+                    )
+                ).append(
+                Parser::State(
+                    Parser::State::typeReduction,
+                    p.addReduction("print")
+                    )
+                )
+            );
+        p.addNonTerminal("input", nt );
+    }
+
+    p.setRootNonTerminal("input");
+
+    p.setReduction("add", Bu::slot( &redAdd ) );
+    p.setReduction("subtract", Bu::slot( &redSubtract ) );
+    p.setReduction("print", Bu::slot( &redPrint ) );
+
+    p.pushLexer( new MathLexer( fIn ) );
+
+    p.parse();
+
+    return 0;
 }
 
diff --git a/src/tests/print.cpp b/src/tests/print.cpp
index c6fe053..bee8cf8 100644
--- a/src/tests/print.cpp
+++ b/src/tests/print.cpp
@@ -2,30 +2,30 @@
 
 int upper()
 {
-        static int iVal = 1;
-        return iVal++;
+    static int iVal = 1;
+    return iVal++;
 }
 
 int main()
 {
-        Bu::print("hello there %1!\n").arg("Bob");
+    Bu::print("hello there %1!\n").arg("Bob");
 
-        Bu::println("This is %1 crazy, like %2 times over!").
-                arg("totally").arg( 47.2 ).end();
-        Bu::println("This is unsubstituted?");
+    Bu::println("This is %1 crazy, like %2 times over!").
+        arg("totally").arg( 47.2 ).end();
+    Bu::println("This is unsubstituted?");
 
-        Bu::serr << "This is error text." << Bu::serr.nl;
-        Bu::println( Bu::serr, "This is also error text?");
+    Bu::serr << "This is error text." << Bu::serr.nl;
+    Bu::println( Bu::serr, "This is also error text?");
 
-        Bu::println("This is %{1}000  - %{1}.").arg( 34, Bu::Fmt().width(10).fill('0') );
+    Bu::println("This is %{1}000  - %{1}.").arg( 34, Bu::Fmt().width(10).fill('0') );
 
-        Bu::String s = Bu::String("hello %1").arg("bob %1").end().toLower().arg("yo");
+    Bu::String s = Bu::String("hello %1").arg("bob %1").end().toLower().arg("yo");
 
-        Bu::println( s );
-        Bu::println("Hello %%1");
+    Bu::println( s );
+    Bu::println("Hello %%1");
 
-        Bu::println("Nums: %1, %2, %3, %4, %5, %6").arg( upper() ).arg( upper() ).arg( upper() ).arg( upper() ).arg( upper() ).arg( upper() );
+    Bu::println("Nums: %1, %2, %3, %4, %5, %6").arg( upper() ).arg( upper() ).arg( upper() ).arg( upper() ).arg( upper() ).arg( upper() );
 
-        return 0;
+    return 0;
 }
 
diff --git a/src/tests/random.cpp b/src/tests/random.cpp
index 3799803..e48c543 100644
--- a/src/tests/random.cpp
+++ b/src/tests/random.cpp
@@ -9,41 +9,41 @@ using namespace Bu;
 template<typename T>
 void coverage()
 {
-        T rand;
-        rand.seed( time( NULL ) );
-
-        uint32_t uBucket[78];
-        memset( uBucket, 0, sizeof(uint32_t)*78 );
-
-        for( int j = 0; j < 1000000; j++ )
-        {
-                uBucket[(int)(((uint32_t)rand.rand())/(double)(0xfffffffful)*78+0.5)]++;
-        }
-
-        uint32_t uMax = 0;
-        for( int j = 0; j < 78; j++ )
-        {
-                if( uMax < uBucket[j] )
-                        uMax = uBucket[j];
-        }
-
-        for( int y = 20; y >= 1; y-- )
-        {
-                uint32_t iT = (uint32_t)((y/20.0)*uMax);
-                for( int x = 0; x < 78; x++ )
-                {
-                        sio << ((iT<=uBucket[x])?"#":" ");
-                }
-                sio << sio.nl;
-        }
+    T rand;
+    rand.seed( time( NULL ) );
+
+    uint32_t uBucket[78];
+    memset( uBucket, 0, sizeof(uint32_t)*78 );
+
+    for( int j = 0; j < 1000000; j++ )
+    {
+        uBucket[(int)(((uint32_t)rand.rand())/(double)(0xfffffffful)*78+0.5)]++;
+    }
+
+    uint32_t uMax = 0;
+    for( int j = 0; j < 78; j++ )
+    {
+        if( uMax < uBucket[j] )
+            uMax = uBucket[j];
+    }
+
+    for( int y = 20; y >= 1; y-- )
+    {
+        uint32_t iT = (uint32_t)((y/20.0)*uMax);
+        for( int x = 0; x < 78; x++ )
+        {
+            sio << ((iT<=uBucket[x])?"#":" ");
+        }
+        sio << sio.nl;
+    }
 }
 
 int main()
 {
-        coverage<RandomBasic>();
-        coverage<RandomCmwc>();
-        coverage<RandomSystem>();
+    coverage<RandomBasic>();
+    coverage<RandomCmwc>();
+    coverage<RandomSystem>();
 
-        return 0;
+    return 0;
 }
 
diff --git a/src/tests/regex.cpp b/src/tests/regex.cpp
index 82c3466..7e4188e 100644
--- a/src/tests/regex.cpp
+++ b/src/tests/regex.cpp
@@ -6,35 +6,35 @@ using namespace Bu;
 
 void compile( const Bu::String &s, Bu::RegExEngine<char> &ree )
 {
-        int iRoot = ree.addState();
-        int iCur = iRoot;
-        for( Bu::String::const_iterator i = s.begin(); i; i++ )
-        {
-                int iNext = -1;
-                if( i+1 )
-                        iNext = ree.addState();
-                ree.addCompletion( iCur, *i, *i, iNext );
-                iCur = iNext;
-        }
+    int iRoot = ree.addState();
+    int iCur = iRoot;
+    for( Bu::String::const_iterator i = s.begin(); i; i++ )
+    {
+        int iNext = -1;
+        if( i+1 )
+            iNext = ree.addState();
+        ree.addCompletion( iCur, *i, *i, iNext );
+        iCur = iNext;
+    }
 }
 
 int main()
 {
-        Bu::String sRegEx("abcd");
-        Bu::String sMatch("abcdefg");
+    Bu::String sRegEx("abcd");
+    Bu::String sMatch("abcdefg");
 
-        Bu::RegExEngine<char> ree;
+    Bu::RegExEngine<char> ree;
 
-        compile( sRegEx, ree );
+    compile( sRegEx, ree );
 
-        bool bRet;
-        int iSize, iCompletion;
-        bRet = ree.match( sMatch, iSize, iCompletion );
+    bool bRet;
+    int iSize, iCompletion;
+    bRet = ree.match( sMatch, iSize, iCompletion );
 
-        sio << "Matched: " << bRet << sio.nl
-                << "Size: " << iSize << sio.nl
-                << "Completion: " << iCompletion << sio.nl;
+    sio << "Matched: " << bRet << sio.nl
+        << "Size: " << iSize << sio.nl
+        << "Completion: " << iCompletion << sio.nl;
 
-        return 0;
+    return 0;
 }
 
diff --git a/src/tests/settings.cpp b/src/tests/settings.cpp
index 2caa015..cf998ed 100644
--- a/src/tests/settings.cpp
+++ b/src/tests/settings.cpp
@@ -5,14 +5,14 @@ using namespace Bu;
 
 int main()
 {
-        Bu::Settings s("Xagasoft", "Settings");
+    Bu::Settings s("Xagasoft", "Settings");
 
-        sio << s.get("Something", "BAD").get() << sio.nl;
-        sio << s.get("general/path", "BAD").get() << sio.nl;
-        sio << s.get("general/magic", "BAD").get() << sio.nl;
+    sio << s.get("Something", "BAD").get() << sio.nl;
+    sio << s.get("general/path", "BAD").get() << sio.nl;
+    sio << s.get("general/magic", "BAD").get() << sio.nl;
 
-        s.set("Something", "bob");
-        s.set("general/path", "E:\\Place");
+    s.set("Something", "bob");
+    s.set("general/path", "E:\\Place");
 
 }
 
diff --git a/src/tests/synchroqueue.cpp b/src/tests/synchroqueue.cpp
index 980a4a3..9e8c787 100644
--- a/src/tests/synchroqueue.cpp
+++ b/src/tests/synchroqueue.cpp
@@ -5,14 +5,14 @@
 class Thing
 {
 public:
-        Thing( int x ) :
-                x( x ),
-                y( 0 )
-        {
-        }
-
-        int x;
-        int y;
+    Thing( int x ) :
+        x( x ),
+        y( 0 )
+    {
+    }
+
+    int x;
+    int y;
 };
 
 typedef Bu::SynchroQueue<Thing *> ThingQueue;
@@ -23,109 +23,109 @@ Bu::Condition cWorkDone;
 
 void workDone()
 {
-        mWorkDone.lock();
-        iWorkDone--;
-        if( iWorkDone == 0 )
-        {
-                mWorkDone.unlock();
-                cWorkDone.lock();
-                cWorkDone.signal();
-                cWorkDone.unlock();
-                return;
-        }
-        mWorkDone.unlock();
+    mWorkDone.lock();
+    iWorkDone--;
+    if( iWorkDone == 0 )
+    {
+        mWorkDone.unlock();
+        cWorkDone.lock();
+        cWorkDone.signal();
+        cWorkDone.unlock();
+        return;
+    }
+    mWorkDone.unlock();
 }
 
 class ThingEater : public Bu::Thread
 {
 public:
-        ThingEater( ThingQueue &qThing ) :
-                qThing( qThing )
-        {
-        }
-
-        bool bRunning;
-
-        void setRunning( bool b )
-        {
-                mRunning.lock();
-                bRunning = b;
-                mRunning.unlock();
-        }
-
-        bool isRunning()
-        {
-                mRunning.lock();
-                bool b = bRunning;
-                mRunning.unlock();
-                return b;
-        }
+    ThingEater( ThingQueue &qThing ) :
+        qThing( qThing )
+    {
+    }
+
+    bool bRunning;
+
+    void setRunning( bool b )
+    {
+        mRunning.lock();
+        bRunning = b;
+        mRunning.unlock();
+    }
+
+    bool isRunning()
+    {
+        mRunning.lock();
+        bool b = bRunning;
+        mRunning.unlock();
+        return b;
+    }
 
 protected:
-        virtual void run()
-        {
-                setRunning( true );
-                while( isRunning() )
-                {
-                        Thing *pThing = qThing.dequeue( 0, 250000 );
-                        if( pThing == NULL )
-                                continue;
-
-                        pThing->y = pThing->x*2;
-                        usleep( 10000 );
-
-                        workDone();
-                }
-        }
-
-        ThingQueue &qThing;
-        Bu::Mutex mRunning;
+    virtual void run()
+    {
+        setRunning( true );
+        while( isRunning() )
+        {
+            Thing *pThing = qThing.dequeue( 0, 250000 );
+            if( pThing == NULL )
+                continue;
+
+            pThing->y = pThing->x*2;
+            usleep( 10000 );
+
+            workDone();
+        }
+    }
+
+    ThingQueue &qThing;
+    Bu::Mutex mRunning;
 };
 
 typedef Bu::List<ThingEater *> ThingEaterList;
 
 int main()
 {
-        ThingQueue qThing;
-        ThingEaterList lEater;
-        
-        mWorkDone.lock();
-        iWorkDone = 1000;
-        mWorkDone.unlock();
-
-        for( int j = 0; j < 5; j++ )
-                lEater.append( new ThingEater( qThing ) );
-
-        for( ThingEaterList::iterator i = lEater.begin(); i; i++ )
-                (*i)->start();
-
-        for( int j = 0; j < 1000; j++ )
-        {
-                qThing.enqueue( new Thing( j ) );
-        }
-
-        mWorkDone.lock();
-        mWorkDone.unlock();
-        cWorkDone.lock();
-        for(;;)
-        {
-                mWorkDone.lock();
-                if( iWorkDone == 0 )
-                {
-                        mWorkDone.unlock();
-                        break;
-                }
-                mWorkDone.unlock();
-                cWorkDone.wait();
-        }
-        cWorkDone.unlock();
-
-        for( ThingEaterList::iterator i = lEater.begin(); i; i++ )
-                (*i)->setRunning( false );
-
-        for( ThingEaterList::iterator i = lEater.begin(); i; i++ )
-                (*i)->join();
-
-        return 0;
+    ThingQueue qThing;
+    ThingEaterList lEater;
+    
+    mWorkDone.lock();
+    iWorkDone = 1000;
+    mWorkDone.unlock();
+
+    for( int j = 0; j < 5; j++ )
+        lEater.append( new ThingEater( qThing ) );
+
+    for( ThingEaterList::iterator i = lEater.begin(); i; i++ )
+        (*i)->start();
+
+    for( int j = 0; j < 1000; j++ )
+    {
+        qThing.enqueue( new Thing( j ) );
+    }
+
+    mWorkDone.lock();
+    mWorkDone.unlock();
+    cWorkDone.lock();
+    for(;;)
+    {
+        mWorkDone.lock();
+        if( iWorkDone == 0 )
+        {
+            mWorkDone.unlock();
+            break;
+        }
+        mWorkDone.unlock();
+        cWorkDone.wait();
+    }
+    cWorkDone.unlock();
+
+    for( ThingEaterList::iterator i = lEater.begin(); i; i++ )
+        (*i)->setRunning( false );
+
+    for( ThingEaterList::iterator i = lEater.begin(); i; i++ )
+        (*i)->join();
+
+    return 0;
 }
 
diff --git a/src/tests/taf.cpp b/src/tests/taf.cpp
index e4354f7..0ba551f 100644
--- a/src/tests/taf.cpp
+++ b/src/tests/taf.cpp
@@ -10,35 +10,35 @@
 
 int main( int argc, char *argv[] )
 {
-        if( argc == 1 )
-        {
-                Bu::File f("test.taf", Bu::File::Read );
-                Bu::TafReader tr( f );
+    if( argc == 1 )
+    {
+        Bu::File f("test.taf", Bu::File::Read );
+        Bu::TafReader tr( f );
 
-                Bu::TafGroup *pGroup = tr.readGroup();
-                
-                {
-                        Bu::File fo("out.taf", Bu::File::Write|Bu::File::Create );
-                        Bu::TafWriter tw( fo );
-                        tw.writeGroup( pGroup );
-                }
+        Bu::TafGroup *pGroup = tr.readGroup();
+        
+        {
+            Bu::File fo("out.taf", Bu::File::Write|Bu::File::Create );
+            Bu::TafWriter tw( fo );
+            tw.writeGroup( pGroup );
+        }
 
-                delete pGroup;
-        }
-        else if( argc == 3 )
-        {
-                Bu::File f( argv[1], Bu::File::Read );
-                Bu::TafReader tr( f );
+        delete pGroup;
+    }
+    else if( argc == 3 )
+    {
+        Bu::File f( argv[1], Bu::File::Read );
+        Bu::TafReader tr( f );
 
-                Bu::TafGroup *pGroup = tr.readGroup();
-                
-                {
-                        Bu::File fo( argv[2], Bu::File::Write|Bu::File::Create );
-                        Bu::TafWriter tw( fo );
-                        tw.writeGroup( pGroup );
-                }
+        Bu::TafGroup *pGroup = tr.readGroup();
+        
+        {
+            Bu::File fo( argv[2], Bu::File::Write|Bu::File::Create );
+            Bu::TafWriter tw( fo );
+            tw.writeGroup( pGroup );
+        }
 
-                delete pGroup;
-        }
+        delete pGroup;
+    }
 }
 
diff --git a/src/tests/threadid.cpp b/src/tests/threadid.cpp
index 9ff99df..dfea504 100644
--- a/src/tests/threadid.cpp
+++ b/src/tests/threadid.cpp
@@ -9,64 +9,64 @@ using namespace Bu;
 class CopyThing
 {
 public:
-        CopyThing()
-        {
-                TRACE();
-                tidHome = Thread::currentThread();
-        }
-
-        CopyThing( const CopyThing &rSrc )
-        {
-                TRACE();
-                tidHome = Thread::currentThread();
-                sio << "Same thread?  " << (tidHome == rSrc.tidHome) << sio.nl;
-        }
-
-        void doThings()
-        {
-                TRACE();
-                if( tidHome != Thread::currentThread() )
-                        sio << "Different threads, hard copy here." << sio.nl;
-                else
-                        sio << "Same thread, everything is cool." << sio.nl;
-        }
+    CopyThing()
+    {
+        TRACE();
+        tidHome = Thread::currentThread();
+    }
+
+    CopyThing( const CopyThing &rSrc )
+    {
+        TRACE();
+        tidHome = Thread::currentThread();
+        sio << "Same thread?  " << (tidHome == rSrc.tidHome) << sio.nl;
+    }
+
+    void doThings()
+    {
+        TRACE();
+        if( tidHome != Thread::currentThread() )
+            sio << "Different threads, hard copy here." << sio.nl;
+        else
+            sio << "Same thread, everything is cool." << sio.nl;
+    }
 
 private:
-        ThreadId tidHome;
+    ThreadId tidHome;
 };
 
 class SubThread : public Thread
 {
 public:
-        SubThread( CopyThing &src ) :
-                src( src )
-        {
-                src.doThings();
-        }
+    SubThread( CopyThing &src ) :
+        src( src )
+    {
+        src.doThings();
+    }
 
 protected:
-        void run()
-        {
-                src.doThings();
-                sio << "run-Child is me? " << (getId() == Thread::currentThread()) << sio.nl;
-        }
+    void run()
+    {
+        src.doThings();
+        sio << "run-Child is me? " << (getId() == Thread::currentThread()) << sio.nl;
+    }
 
 private:
-        CopyThing src;
+    CopyThing src;
 };
 
 int main( int argc, char *argv[] )
 {
-        CopyThing a;
+    CopyThing a;
 
-        SubThread st( a );
-        st.start();
+    SubThread st( a );
+    st.start();
 
-        sio << "Child is me? " << (st.getId() == Thread::currentThread()) << sio.nl;
+    sio << "Child is me? " << (st.getId() == Thread::currentThread()) << sio.nl;
 
-        st.join();
+    st.join();
 
 
-        return 0;
+    return 0;
 }
 
diff --git a/src/tests/utf.cpp b/src/tests/utf.cpp
index 923b611..40d4194 100644
--- a/src/tests/utf.cpp
+++ b/src/tests/utf.cpp
@@ -7,65 +7,65 @@ using namespace Bu;
 
 int main()
 {
-        sio << "Code: " << Bu::__calcHashCode( Bu::UtfString("Hello there") )
-                << sio.nl;
+    sio << "Code: " << Bu::__calcHashCode( Bu::UtfString("Hello there") )
+        << sio.nl;
 
-        Bu::File fIn("utf8.in", Bu::File::Read );
-        Bu::String sUtf8;
-        char buf[4096];
-        while( !fIn.isEos() )
-        {
-                int iAmnt = fIn.read( buf, 4096 );
-                sUtf8.append( buf, iAmnt );
-        }
-        Bu::UtfString us( sUtf8, Bu::UtfString::Utf8 );
-        us.debug();
-        {
-                Bu::File fOut("utf8.out", Bu::File::WriteNew );
-                us.write( fOut, Bu::UtfString::Utf8 );
-        }
-        {
-                Bu::File fOut("utf16.out", Bu::File::WriteNew );
-                us.write( fOut, Bu::UtfString::Utf16 );
-        }
-        {
-                Bu::File fOut("utf16le.out", Bu::File::WriteNew );
-                us.write( fOut, Bu::UtfString::Utf16le );
-        }
-        {
-                Bu::File fOut("utf16be.out", Bu::File::WriteNew );
-                us.write( fOut, Bu::UtfString::Utf16be );
-        }
-        {
-                Bu::File fOut("utf32.out", Bu::File::WriteNew );
-                us.write( fOut, Bu::UtfString::Utf32 );
-        }
-        {
-                Bu::File fOut("utf32le.out", Bu::File::WriteNew );
-                us.write( fOut, Bu::UtfString::Utf32le );
-        }
-        {
-                Bu::File fOut("utf32be.out", Bu::File::WriteNew );
-                us.write( fOut, Bu::UtfString::Utf32be );
-        }
+    Bu::File fIn("utf8.in", Bu::File::Read );
+    Bu::String sUtf8;
+    char buf[4096];
+    while( !fIn.isEos() )
+    {
+        int iAmnt = fIn.read( buf, 4096 );
+        sUtf8.append( buf, iAmnt );
+    }
+    Bu::UtfString us( sUtf8, Bu::UtfString::Utf8 );
+    us.debug();
+    {
+        Bu::File fOut("utf8.out", Bu::File::WriteNew );
+        us.write( fOut, Bu::UtfString::Utf8 );
+    }
+    {
+        Bu::File fOut("utf16.out", Bu::File::WriteNew );
+        us.write( fOut, Bu::UtfString::Utf16 );
+    }
+    {
+        Bu::File fOut("utf16le.out", Bu::File::WriteNew );
+        us.write( fOut, Bu::UtfString::Utf16le );
+    }
+    {
+        Bu::File fOut("utf16be.out", Bu::File::WriteNew );
+        us.write( fOut, Bu::UtfString::Utf16be );
+    }
+    {
+        Bu::File fOut("utf32.out", Bu::File::WriteNew );
+        us.write( fOut, Bu::UtfString::Utf32 );
+    }
+    {
+        Bu::File fOut("utf32le.out", Bu::File::WriteNew );
+        us.write( fOut, Bu::UtfString::Utf32le );
+    }
+    {
+        Bu::File fOut("utf32be.out", Bu::File::WriteNew );
+        us.write( fOut, Bu::UtfString::Utf32be );
+    }
 
-        /*
-        argc--, argv++;
+    /*
+    argc--, argv++;
 
-        for( char **sFile = argv; *sFile; sFile++ )
-        {
-                Bu::File fIn( *sFile, Bu::File::Read );
-                Bu::String sUtf8;
-                char buf[4096];
-                while( !fIn.isEos() )
-                {
-                        int iAmnt = fIn.read( buf, 4096 );
-                        sUtf8.append( buf, iAmnt );
-                }
-                Bu::UtfString us( sUtf8, Bu::UtfString::Utf16 );
+    for( char **sFile = argv; *sFile; sFile++ )
+    {
+        Bu::File fIn( *sFile, Bu::File::Read );
+        Bu::String sUtf8;
+        char buf[4096];
+        while( !fIn.isEos() )
+        {
+            int iAmnt = fIn.read( buf, 4096 );
+            sUtf8.append( buf, iAmnt );
+        }
+        Bu::UtfString us( sUtf8, Bu::UtfString::Utf16 );
 
-                us.debug();
-        }
-        */
+        us.debug();
+    }
+    */
 }
 
diff --git a/src/tests/uuid.cpp b/src/tests/uuid.cpp
index d612ad5..152ba26 100644
--- a/src/tests/uuid.cpp
+++ b/src/tests/uuid.cpp
@@ -12,11 +12,11 @@ using namespace Bu;
 
 int main()
 {
-        Uuid i = Uuid::gen();
+    Uuid i = Uuid::gen();
 
-        sio << i.toString() << sio.nl;
-        sio << "Version: " << i.getVersion() << sio.nl;
+    sio << i.toString() << sio.nl;
+    sio << "Version: " << i.getVersion() << sio.nl;
 
-        return 0;
+    return 0;
 }
 
diff --git a/src/tools/bin2cpp.cpp b/src/tools/bin2cpp.cpp
index 0b822f0..4214b34 100644
--- a/src/tools/bin2cpp.cpp
+++ b/src/tools/bin2cpp.cpp
@@ -16,244 +16,244 @@ using namespace Bu;
 class Options : public OptParser
 {
 public:
-        Options( int argc, char *argv[] ) :
-                sClass("Datafiles")
-        {
-                addHelpBanner("bin2cpp - convert files into executable-embeddable C++ code.\n");
-                addHelpBanner("Each file in the input is loaded, filtered according to your options, and written as stack allocated, static variables in a generated class.  You can then access the files as though they were on disk through that class.");
-                addHelpBanner("\nUsage: bin2cpp [options] [input1] [input2] [...] [inputN]");
-                addHelpBanner(  "   Or: bin2cpp -s <taf spec file>\n");
-                addOption( sClass, 'c', "Class name [default=\"Datafiles\"]");
-                addOption( sOutBase, 'o', "Output base filename [defaults to classname]");
-                addOption( sOutDir, 'd', "Output directory [defaults to current dir]");
-                addOption( slot(this, &Options::addFilter), 'f', "Add filter: deflate, bzip2, lzma, base64, hex");
-                addOption( sSpecFile, 's', "Use the specified spec file instead of providing options on the command line.  If you use this option all others are ignored.");
-                setNonOption( slot(this, &Options::addInput) );
-                addHelpOption();
+    Options( int argc, char *argv[] ) :
+        sClass("Datafiles")
+    {
+        addHelpBanner("bin2cpp - convert files into executable-embeddable C++ code.\n");
+        addHelpBanner("Each file in the input is loaded, filtered according to your options, and written as stack allocated, static variables in a generated class.  You can then access the files as though they were on disk through that class.");
+        addHelpBanner("\nUsage: bin2cpp [options] [input1] [input2] [...] [inputN]");
+        addHelpBanner(  "   Or: bin2cpp -s <taf spec file>\n");
+        addOption( sClass, 'c', "Class name [default=\"Datafiles\"]");
+        addOption( sOutBase, 'o', "Output base filename [defaults to classname]");
+        addOption( sOutDir, 'd', "Output directory [defaults to current dir]");
+        addOption( slot(this, &Options::addFilter), 'f', "Add filter: deflate, bzip2, lzma, base64, hex");
+        addOption( sSpecFile, 's', "Use the specified spec file instead of providing options on the command line.  If you use this option all others are ignored.");
+        setNonOption( slot(this, &Options::addInput) );
+        addHelpOption();
 
-                parse( argc, argv );
+        parse( argc, argv );
 
-                if( !sOutBase.isSet() )
-                        sOutBase = sClass.toLower();
-                if( sOutDir.isSet() )
-                        sOutDir += "/";
-        }
+        if( !sOutBase.isSet() )
+            sOutBase = sClass.toLower();
+        if( sOutDir.isSet() )
+            sOutDir += "/";
+    }
 
-        virtual ~Options()
-        {
-        }
+    virtual ~Options()
+    {
+    }
 
-        int addFilter( Bu::StrArray aArgs )
-        {
-                slFilter.append( aArgs[1] );
-                return 1;
-        }
+    int addFilter( Bu::StrArray aArgs )
+    {
+        slFilter.append( aArgs[1] );
+        return 1;
+    }
 
-        int addInput( Bu::StrArray aArgs )
-        {
-                slInput.append( aArgs[0] );
-                return 0;
-        }
+    int addInput( Bu::StrArray aArgs )
+    {
+        slInput.append( aArgs[0] );
+        return 0;
+    }
 
-        Bu::String sClass;
-        Bu::String sOutBase;
-        Bu::String sOutDir;
-        Bu::StringList slInput;
-        Bu::StringList slFilter;
-        Bu::String sSpecFile;
+    Bu::String sClass;
+    Bu::String sOutBase;
+    Bu::String sOutDir;
+    Bu::StringList slInput;
+    Bu::StringList slFilter;
+    Bu::String sSpecFile;
 };
 
 int main( int argc, char *argv[] )
 {
-        Options opt( argc, argv );
+    Options opt( argc, argv );
 
-        if( !opt.sSpecFile.isEmpty() )
-        {
-                Bu::File fTaf( opt.sSpecFile, Bu::File::Read );
-                Bu::TafReader rTaf( fTaf );
-                Bu::TafGroup *pRoot = rTaf.readGroup();
+    if( !opt.sSpecFile.isEmpty() )
+    {
+        Bu::File fTaf( opt.sSpecFile, Bu::File::Read );
+        Bu::TafReader rTaf( fTaf );
+        Bu::TafGroup *pRoot = rTaf.readGroup();
 
-                if( pRoot == NULL || pRoot->getName() != "bin2cpp" )
-                {
-                        sio << "Specfied spec file does not appear to be a bin2cpp taf "
-                                "specifications file." << sio.nl;
-                        return 5;
-                }
+        if( pRoot == NULL || pRoot->getName() != "bin2cpp" )
+        {
+            sio << "Specfied spec file does not appear to be a bin2cpp taf "
+                "specifications file." << sio.nl;
+            return 5;
+        }
 
-                opt.sOutBase = opt.sClass = pRoot->getProperty("class");
-                if( pRoot->hasProperty("output") )
-                        opt.sOutBase = pRoot->getProperty("output");
-                opt.sOutDir = pRoot->getProperty("dir", ".") + "/";
+        opt.sOutBase = opt.sClass = pRoot->getProperty("class");
+        if( pRoot->hasProperty("output") )
+            opt.sOutBase = pRoot->getProperty("output");
+        opt.sOutDir = pRoot->getProperty("dir", ".") + "/";
 
-                delete pRoot;
-        }
+        delete pRoot;
+    }
 
-        File fHdrOut( opt.sOutDir + opt.sOutBase + ".h", File::WriteNew );
-        File fSrcOut( opt.sOutDir + opt.sOutBase + ".cpp", File::WriteNew );
+    File fHdrOut( opt.sOutDir + opt.sOutBase + ".h", File::WriteNew );
+    File fSrcOut( opt.sOutDir + opt.sOutBase + ".cpp", File::WriteNew );
 
-        Bu::Hash<char, bool> hFilters;
+    Bu::Hash<char, bool> hFilters;
 
-        Formatter fHdr( fHdrOut );
-        Formatter fSrc( fSrcOut );
-        fHdr << "#ifndef BIN2CPP_" << opt.sClass.toUpper() << "_H" << fHdr.nl
-                << "#define BIN2CPP_" << opt.sClass.toUpper() << "_H" << fHdr.nl << fHdr.nl
-                << "#include <bu/string.h>" << fHdr.nl
-                << "#include <bu/streamstack.h>" << fHdr.nl
-                << fHdr.nl
-                << "class " << opt.sClass << fHdr.nl
-                << "{" << fHdr.nl
-                << "public:" << fHdr.nl
-                << "\tclass File { public: int iSize; const char *data; const char *flt; };" << fHdr.nl << fHdr.nl
-                << "\tstatic const File &getFile( const Bu::String &sName );" << fHdr.nl
-                << "\tstatic Bu::StreamStack *open( const Bu::String &sName );" << fHdr.nl
-                << "\tstatic Bu::StreamStack *openRaw( const Bu::String &sName );" << fHdr.nl
-                << "\tstatic Bu::String getString( const Bu::String &sName );" << fHdr.nl
-                << "\tstatic Bu::String getStringRaw( const Bu::String &sName );" << fHdr.nl
-                << fHdr.nl;
-        fHdr << "public:" << fHdr.nl
-                << "\tstatic const File aFile[];" << fHdr.nl
-                << "};" << fHdr.nl << fHdr.nl;
-        fHdr << "#endif";
+    Formatter fHdr( fHdrOut );
+    Formatter fSrc( fSrcOut );
+    fHdr << "#ifndef BIN2CPP_" << opt.sClass.toUpper() << "_H" << fHdr.nl
+        << "#define BIN2CPP_" << opt.sClass.toUpper() << "_H" << fHdr.nl << fHdr.nl
+        << "#include <bu/string.h>" << fHdr.nl
+        << "#include <bu/streamstack.h>" << fHdr.nl
+        << fHdr.nl
+        << "class " << opt.sClass << fHdr.nl
+        << "{" << fHdr.nl
+        << "public:" << fHdr.nl
+        << "\tclass File { public: int iSize; const char *data; const char *flt; };" << fHdr.nl << fHdr.nl
+        << "\tstatic const File &getFile( const Bu::String &sName );" << fHdr.nl
+        << "\tstatic Bu::StreamStack *open( const Bu::String &sName );" << fHdr.nl
+        << "\tstatic Bu::StreamStack *openRaw( const Bu::String &sName );" << fHdr.nl
+        << "\tstatic Bu::String getString( const Bu::String &sName );" << fHdr.nl
+        << "\tstatic Bu::String getStringRaw( const Bu::String &sName );" << fHdr.nl
+        << fHdr.nl;
+    fHdr << "public:" << fHdr.nl
+        << "\tstatic const File aFile[];" << fHdr.nl
+        << "};" << fHdr.nl << fHdr.nl;
+    fHdr << "#endif";
 
-        fSrc << "#include \"" << opt.sOutBase << ".h\"" << fSrc.nl 
-                << "#include <bu/deflate.h>" << fSrc.nl
-                << "#include <bu/bzip2.h>" << fSrc.nl
-                << "#include <bu/base64.h>" << fSrc.nl
-                << "#include <bu/lzma.h>" << fSrc.nl
-                << "#include <bu/hex.h>" << fSrc.nl
-                << "#include <bu/strfilter.h>" << fSrc.nl
-                << "#include <bu/staticmembuf.h>" << fSrc.nl << fSrc.nl
-                << "const " << opt.sClass << "::File " << opt.sClass << "::aFile[] = {" << fSrc.nl;
+    fSrc << "#include \"" << opt.sOutBase << ".h\"" << fSrc.nl 
+        << "#include <bu/deflate.h>" << fSrc.nl
+        << "#include <bu/bzip2.h>" << fSrc.nl
+        << "#include <bu/base64.h>" << fSrc.nl
+        << "#include <bu/lzma.h>" << fSrc.nl
+        << "#include <bu/hex.h>" << fSrc.nl
+        << "#include <bu/strfilter.h>" << fSrc.nl
+        << "#include <bu/staticmembuf.h>" << fSrc.nl << fSrc.nl
+        << "const " << opt.sClass << "::File " << opt.sClass << "::aFile[] = {" << fSrc.nl;
 
-        for( Bu::StringList::iterator i = opt.slInput.begin(); i; i++ )
-        {
-                File fIn( *i, File::Read );
-                Bu::String sDat;
-                char buf[1024];
-                while( !fIn.isEos() )
-                {
-                        sDat.append( buf, fIn.read( buf, 1024 ) );
-                }
+    for( Bu::StringList::iterator i = opt.slInput.begin(); i; i++ )
+    {
+        File fIn( *i, File::Read );
+        Bu::String sDat;
+        char buf[1024];
+        while( !fIn.isEos() )
+        {
+            sDat.append( buf, fIn.read( buf, 1024 ) );
+        }
 
-                Bu::String sFltDesc;
-                for( Bu::StringList::iterator f = opt.slFilter.begin(); f; f++ )
-                {
-                        if( *f == "deflate" )
-                        {
-                                sDat = encodeStr<Deflate>( sDat );
-                                sFltDesc.prepend("d");
-                                hFilters.insert('d', true );
-                        }
-                        else if( *f == "bzip2" )
-                        {
-                                sDat = encodeStr<BZip2>( sDat );
-                                sFltDesc.prepend("b");
-                                hFilters.insert('b', true );
-                        }
-                        else if( *f == "lzma" )
-                        {
-                                sDat = encodeStr<Lzma>( sDat );
-                                sFltDesc.prepend("l");
-                                hFilters.insert('l', true );
-                        }
-                        else if( *f == "base64" )
-                        {
-                                sDat = encodeStr<Base64>( sDat );
-                                sFltDesc.prepend("6");
-                                hFilters.insert('6', true );
-                        }
-                        else if( *f == "hex" )
-                        {
-                                sDat = encodeStr<Hex>( sDat );
-                                sFltDesc.prepend("h");
-                                hFilters.insert('h', true );
-                        }
-                        else
-                        {
-                                sio << "No known filter named " << *f << sio.nl;
-                                return 1;
-                        }
-                }
-                
-                fSrc << "  {" << sDat.getSize() << ", \"";
+        Bu::String sFltDesc;
+        for( Bu::StringList::iterator f = opt.slFilter.begin(); f; f++ )
+        {
+            if( *f == "deflate" )
+            {
+                sDat = encodeStr<Deflate>( sDat );
+                sFltDesc.prepend("d");
+                hFilters.insert('d', true );
+            }
+            else if( *f == "bzip2" )
+            {
+                sDat = encodeStr<BZip2>( sDat );
+                sFltDesc.prepend("b");
+                hFilters.insert('b', true );
+            }
+            else if( *f == "lzma" )
+            {
+                sDat = encodeStr<Lzma>( sDat );
+                sFltDesc.prepend("l");
+                hFilters.insert('l', true );
+            }
+            else if( *f == "base64" )
+            {
+                sDat = encodeStr<Base64>( sDat );
+                sFltDesc.prepend("6");
+                hFilters.insert('6', true );
+            }
+            else if( *f == "hex" )
+            {
+                sDat = encodeStr<Hex>( sDat );
+                sFltDesc.prepend("h");
+                hFilters.insert('h', true );
+            }
+            else
+            {
+                sio << "No known filter named " << *f << sio.nl;
+                return 1;
+            }
+        }
+        
+        fSrc << "  {" << sDat.getSize() << ", \"";
 
                 for( Bu::String::iterator j = sDat.begin(); j; j++ )
                 {
                         fSrc << "\\x" << Fmt::hex() << (unsigned char)*j;
                 }
                 fSrc << "\", \"" << sFltDesc << "\"}," << fSrc.nl;
-        }
-        fSrc << "};" << fSrc.nl << fSrc.nl;
+    }
+    fSrc << "};" << fSrc.nl << fSrc.nl;
 
-        fSrc << "const " << opt.sClass << "::File &" << opt.sClass << "::getFile( const Bu::String &sName )"
-                << fSrc.nl
-                << "{" << fSrc.nl
-                << "\tswitch( Bu::__calcHashCode( sName ) )" << fSrc.nl
-                << "\t{" << fSrc.nl;
+    fSrc << "const " << opt.sClass << "::File &" << opt.sClass << "::getFile( const Bu::String &sName )"
+        << fSrc.nl
+        << "{" << fSrc.nl
+        << "\tswitch( Bu::__calcHashCode( sName ) )" << fSrc.nl
+        << "\t{" << fSrc.nl;
 
-        int idx = 0;
-        for( Bu::StringList::iterator i = opt.slInput.begin(); i; i++ )
-        {
-                fSrc << "\t\tcase " << Bu::__calcHashCode( *i ) << "UL:" << fSrc.nl
-                        << "\t\t\treturn aFile[" << idx << "];" << fSrc.nl;
-                idx++;
-        }
-        fSrc << "\t}" << fSrc.nl
-                << "\tthrow Bu::ExceptionBase(\"No file matching \\\"%s\\\" found.\", sName.getStr() );" << fSrc.nl
-                << "}" << fSrc.nl << fSrc.nl;
-        
-        fSrc << "Bu::StreamStack *" << opt.sClass << "::open( const Bu::String &sName )" << fSrc.nl
-                << "{" << fSrc.nl
-                << "\tconst File &f = getFile( sName );" << fSrc.nl
-                << "\tBu::StreamStack *s = new Bu::StreamStack( new Bu::StaticMemBuf( f.data, f.iSize ) );" << fSrc.nl;
+    int idx = 0;
+    for( Bu::StringList::iterator i = opt.slInput.begin(); i; i++ )
+    {
+        fSrc << "\t\tcase " << Bu::__calcHashCode( *i ) << "UL:" << fSrc.nl
+            << "\t\t\treturn aFile[" << idx << "];" << fSrc.nl;
+        idx++;
+    }
+    fSrc << "\t}" << fSrc.nl
+        << "\tthrow Bu::ExceptionBase(\"No file matching \\\"%s\\\" found.\", sName.getStr() );" << fSrc.nl
+        << "}" << fSrc.nl << fSrc.nl;
+    
+    fSrc << "Bu::StreamStack *" << opt.sClass << "::open( const Bu::String &sName )" << fSrc.nl
+        << "{" << fSrc.nl
+        << "\tconst File &f = getFile( sName );" << fSrc.nl
+        << "\tBu::StreamStack *s = new Bu::StreamStack( new Bu::StaticMemBuf( f.data, f.iSize ) );" << fSrc.nl;
 
-        if( !hFilters.isEmpty() )
-        {
-                fSrc << "\tfor( const char *t = f.flt; *t; t++ )" << fSrc.nl
-                        << "\t{" << fSrc.nl
-                        << "\t\tswitch( *t )" << fSrc.nl
-                        << "\t\t{" << fSrc.nl;
-                if( hFilters.has('d') )
-                        fSrc << "\t\t\tcase 'd': s->pushFilter<Bu::Deflate>(); break;" << fSrc.nl;
-                if( hFilters.has('b') )
-                        fSrc << "\t\t\tcase 'b': s->pushFilter<Bu::BZip2>(); break;" << fSrc.nl;
-                if( hFilters.has('l') )
-                        fSrc << "\t\t\tcase 'l': s->pushFilter<Bu::Lzma>(); break;" << fSrc.nl;
-                if( hFilters.has('6') )
-                        fSrc << "\t\t\tcase '6': s->pushFilter<Bu::Base64>(); break;" << fSrc.nl;
-                if( hFilters.has('h') )
-                        fSrc << "\t\t\tcase 'h': s->pushFilter<Bu::Hex>(); break;" << fSrc.nl;
-                fSrc << "\t\t}" << fSrc.nl
-                        << "\t}" << fSrc.nl;
-        }
-        fSrc << "\treturn s;" << fSrc.nl
-                << "}" << fSrc.nl << fSrc.nl;
+    if( !hFilters.isEmpty() )
+    {
+        fSrc << "\tfor( const char *t = f.flt; *t; t++ )" << fSrc.nl
+            << "\t{" << fSrc.nl
+            << "\t\tswitch( *t )" << fSrc.nl
+            << "\t\t{" << fSrc.nl;
+        if( hFilters.has('d') )
+            fSrc << "\t\t\tcase 'd': s->pushFilter<Bu::Deflate>(); break;" << fSrc.nl;
+        if( hFilters.has('b') )
+            fSrc << "\t\t\tcase 'b': s->pushFilter<Bu::BZip2>(); break;" << fSrc.nl;
+        if( hFilters.has('l') )
+            fSrc << "\t\t\tcase 'l': s->pushFilter<Bu::Lzma>(); break;" << fSrc.nl;
+        if( hFilters.has('6') )
+            fSrc << "\t\t\tcase '6': s->pushFilter<Bu::Base64>(); break;" << fSrc.nl;
+        if( hFilters.has('h') )
+            fSrc << "\t\t\tcase 'h': s->pushFilter<Bu::Hex>(); break;" << fSrc.nl;
+        fSrc << "\t\t}" << fSrc.nl
+            << "\t}" << fSrc.nl;
+    }
+    fSrc << "\treturn s;" << fSrc.nl
+        << "}" << fSrc.nl << fSrc.nl;
 
-        fSrc << "Bu::StreamStack *" << opt.sClass << "::openRaw( const Bu::String &sName )" << fSrc.nl
-                << "{" << fSrc.nl
-                << "\tconst File &f = getFile( sName );" << fSrc.nl
-                << "\treturn new Bu::StreamStack( new Bu::StaticMemBuf( f.data, f.iSize ) );" << fSrc.nl
-                << "}" << fSrc.nl << fSrc.nl;
+    fSrc << "Bu::StreamStack *" << opt.sClass << "::openRaw( const Bu::String &sName )" << fSrc.nl
+        << "{" << fSrc.nl
+        << "\tconst File &f = getFile( sName );" << fSrc.nl
+        << "\treturn new Bu::StreamStack( new Bu::StaticMemBuf( f.data, f.iSize ) );" << fSrc.nl
+        << "}" << fSrc.nl << fSrc.nl;
 
-        fSrc << "Bu::String " << opt.sClass << "::getString( const Bu::String &sName )" << fSrc.nl
-                << "{" << fSrc.nl
-                << "\tBu::StreamStack *ss = open( sName );" << fSrc.nl
-                << "\tBu::String s;" << fSrc.nl
-                << "\tchar buf[1024];" << fSrc.nl
-                << "\twhile( !ss->isEos() )" << fSrc.nl
-                << "\t{" << fSrc.nl
-                << "\t\ts.append( buf, ss->read( buf, 1024 ) );" << fSrc.nl
-                << "\t}" << fSrc.nl
-                << "\tdelete ss;" << fSrc.nl
-                << "\treturn s;" << fSrc.nl
-                << "}" << fSrc.nl << fSrc.nl;
-        
-        fSrc << "Bu::String " << opt.sClass << "::getStringRaw( const Bu::String &sName )" << fSrc.nl
-                << "{" << fSrc.nl
-                << "\tconst File &f = getFile( sName );" << fSrc.nl
-                << "\treturn Bu::String( f.data, f.iSize );" << fSrc.nl
-                << "}" << fSrc.nl << fSrc.nl;
+    fSrc << "Bu::String " << opt.sClass << "::getString( const Bu::String &sName )" << fSrc.nl
+        << "{" << fSrc.nl
+        << "\tBu::StreamStack *ss = open( sName );" << fSrc.nl
+        << "\tBu::String s;" << fSrc.nl
+        << "\tchar buf[1024];" << fSrc.nl
+        << "\twhile( !ss->isEos() )" << fSrc.nl
+        << "\t{" << fSrc.nl
+        << "\t\ts.append( buf, ss->read( buf, 1024 ) );" << fSrc.nl
+        << "\t}" << fSrc.nl
+        << "\tdelete ss;" << fSrc.nl
+        << "\treturn s;" << fSrc.nl
+        << "}" << fSrc.nl << fSrc.nl;
+    
+    fSrc << "Bu::String " << opt.sClass << "::getStringRaw( const Bu::String &sName )" << fSrc.nl
+        << "{" << fSrc.nl
+        << "\tconst File &f = getFile( sName );" << fSrc.nl
+        << "\treturn Bu::String( f.data, f.iSize );" << fSrc.nl
+        << "}" << fSrc.nl << fSrc.nl;
 
-        return 0;
+    return 0;
 }
 
diff --git a/src/tools/mkunit.cpp b/src/tools/mkunit.cpp
index d634feb..96deb6b 100644
--- a/src/tools/mkunit.cpp
+++ b/src/tools/mkunit.cpp
@@ -17,236 +17,236 @@ using namespace Bu;
 class Test
 {
 public:
-        Test() :
-                bExpectPass( true )
-        {
-        }
+    Test() :
+        bExpectPass( true )
+    {
+    }
 
-        Bu::String sName;
-        bool bExpectPass;
+    Bu::String sName;
+    bool bExpectPass;
 };
 typedef Bu::List<Test> TestList;
 
 class Suite
 {
 public:
-        Bu::String sName;
-        TestList lTest;
+    Bu::String sName;
+    TestList lTest;
 };
 //typedef Bu::List<Suite> SuiteList;
 
 enum TokType
 {
-        tokFluff,
-        tokSuite,
-        tokTest,
-        tokChar,
-        tokBlock,
-        tokEof
+    tokFluff,
+    tokSuite,
+    tokTest,
+    tokChar,
+    tokBlock,
+    tokEof
 };
 
 Bu::Formatter &operator<<( Bu::Formatter &f, TokType t )
 {
-        switch( t )
-        {
-                case tokFluff:          return f << "tokFluff";
-                case tokSuite:          return f << "tokSuite";
-                case tokTest:           return f << "tokTest";
-                case tokChar:           return f << "tokChar";
-                case tokBlock:          return f << "tokBlock";
-                case tokEof:            return f << "tokEof";
-        }
-
-        return f;
+    switch( t )
+    {
+        case tokFluff:      return f << "tokFluff";
+        case tokSuite:      return f << "tokSuite";
+        case tokTest:       return f << "tokTest";
+        case tokChar:       return f << "tokChar";
+        case tokBlock:      return f << "tokBlock";
+        case tokEof:        return f << "tokEof";
+    }
+
+    return f;
 }
 
 Bu::Formatter &operator<<( Bu::Formatter &f, const Test &t )
 {
-        return f << "{" << t.sName << ", bExpectPass=" << t.bExpectPass << "}";
+    return f << "{" << t.sName << ", bExpectPass=" << t.bExpectPass << "}";
 }
 
 Bu::Formatter &operator<<( Bu::Formatter &f, const Suite &s )
 {
-        return f << "Suite[" << s.sName << "] = " << s.lTest << f.nl;
+    return f << "Suite[" << s.sName << "] = " << s.lTest << f.nl;
 }
 
 class Parser
 {
 public:
-        Parser( const Bu::String &sFile ) :
-                sIn( sFile ),
-                fIn( sFile, File::Read ),
-                bIn( fIn ),
-                cBuf( 0 ),
-                bAvail( false ),
-                eMode( mRoot ),
-                iLine( 1 ),
-                iChar( 0 ),
-                iDepth( 0 )
-        {
-        }
-
-        char nextChar()
-        {
-                if( bAvail )
-                        return cBuf;
-
-                if( bIn.read( &cBuf, 1 ) < 1 )
-                        throw Bu::ExceptionBase("End of stream");
-                bAvail = true;
-
-                if( cBuf == '\n' )
-                {
-                        iLine++;
-                        iChar = 0;
-                }
-                else
-                        iChar++;
-
-                return cBuf;
-        }
-        
-        TokType nextToken( Variant &v, Bu::String &sWsOut, int &iLineStart,
-                        int &iCharStart )
-        {
-                Bu::String sTok, sWs;
-        
-                char buf;
-                try
-                {
-                        buf = nextChar();
-                }
-                catch(...)
-                {
-                        return tokEof;
-                }
-
-                for(;;)
-                {
-                        if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
-                        {
-                                sWs += buf;
-                                bAvail = false;
-                        }
-                        else
-                                break;
-
-                        try
-                        {
-                                buf = nextChar();
-                        }
-                        catch(...)
-                        {
-                                sWsOut = sWs;
-                                return tokEof;
-                        }
-                }
-
-                sWsOut = sWs;
-
-                iLineStart = iLine;
-                iCharStart = iChar;
-                bool bInStr = false;
-                bool bDblStr;
-
-                for(;;)
-                {
-                        switch( eMode )
-                        {
-                                case mRoot:
-                                        if( buf == ' ' || buf == '\t' || buf == '\n'
-                                                || buf == '\r' )
-                                        {
-                                                if( sTok == "suite" )
-                                                        return tokSuite;
-                                                else
-                                                {
-                                                        v = sTok;
-                                                        return tokFluff;
-                                                }
-                                        }
-                                        else if( buf == '(' || buf == ')' || buf == '{'
-                                                || buf == '}' || buf == ';' )
-                                        {
-                                                if( sTok.getSize() == 0 )
-                                                {
-                                                        bAvail = false;
-                                                        v = buf;
-                                                        return tokChar;
-                                                }
-                                                else
-                                                {
-                                                        v = sTok;
-                                                        return tokFluff;
-                                                }
-                                        }
-                                        else
-                                        {
-                                                sTok += buf;
-                                                bAvail = false;
-                                        }
-                                        break;
-
-                                case mSuite:
-                                        if( buf == ' ' || buf == '\t' || buf == '\n'
-                                                || buf == '\r' )
-                                        {
-                                                if( sTok == "test" )
-                                                        return tokTest;
-                                                else
-                                                {
-                                                        v = sTok;
-                                                        return tokFluff;
-                                                }
-                                        }
-                                        else if( buf == '(' || buf == ')'
-                                                || buf == '}' || buf == ';' )
-                                        {
-                                                if( sTok.getSize() == 0 )
-                                                {
-                                                        bAvail = false;
-                                                        v = buf;
-                                                        return tokChar;
-                                                }
-                                                else
-                                                {
-                                                        v = sTok;
-                                                        return tokFluff;
-                                                }
-                                        }
-                                        else if( buf == '{' )
-                                        {
-                                                if( sTok.getSize() > 0 )
-                                                {
-                                                        v = sTok;
-                                                        return tokFluff;
-                                                }
-                                                else
-                                                {
-                                                        sTok += buf;
-                                                        bAvail = false;
-                                                        eMode = mBlock;
-                                                        iDepth = 1;
-                                                }
-                                        }
-                                        else
-                                        {
-                                                sTok += buf;
-                                                bAvail = false;
-                                        }
-                                        break;
-
-                                case mBlock:
-                                        if( bInStr )
-                                        {
-                                                if( buf == '\\' )
-                                                {
-                                                        sTok += buf;
-                                                        bAvail = false;
-                                                        sTok += nextChar();
-                                                        bAvail = false;
-                                                }
-                                                else if( bDblStr == true && buf == '\"' )
+    Parser( const Bu::String &sFile ) :
+        sIn( sFile ),
+        fIn( sFile, File::Read ),
+        bIn( fIn ),
+        cBuf( 0 ),
+        bAvail( false ),
+        eMode( mRoot ),
+        iLine( 1 ),
+        iChar( 0 ),
+        iDepth( 0 )
+    {
+    }
+
+    char nextChar()
+    {
+        if( bAvail )
+            return cBuf;
+
+        if( bIn.read( &cBuf, 1 ) < 1 )
+            throw Bu::ExceptionBase("End of stream");
+        bAvail = true;
+
+        if( cBuf == '\n' )
+        {
+            iLine++;
+            iChar = 0;
+        }
+        else
+            iChar++;
+
+        return cBuf;
+    }
+    
+    TokType nextToken( Variant &v, Bu::String &sWsOut, int &iLineStart,
+            int &iCharStart )
+    {
+        Bu::String sTok, sWs;
+    
+        char buf;
+        try
+        {
+            buf = nextChar();
+        }
+        catch(...)
+        {
+            return tokEof;
+        }
+
+        for(;;)
+        {
+            if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
+            {
+                sWs += buf;
+                bAvail = false;
+            }
+            else
+                break;
+
+            try
+            {
+                buf = nextChar();
+            }
+            catch(...)
+            {
+                sWsOut = sWs;
+                return tokEof;
+            }
+        }
+
+        sWsOut = sWs;
+
+        iLineStart = iLine;
+        iCharStart = iChar;
+        bool bInStr = false;
+        bool bDblStr;
+
+        for(;;)
+        {
+            switch( eMode )
+            {
+                case mRoot:
+                    if( buf == ' ' || buf == '\t' || buf == '\n'
+                        || buf == '\r' )
+                    {
+                        if( sTok == "suite" )
+                            return tokSuite;
+                        else
+                        {
+                            v = sTok;
+                            return tokFluff;
+                        }
+                    }
+                    else if( buf == '(' || buf == ')' || buf == '{'
+                        || buf == '}' || buf == ';' )
+                    {
+                        if( sTok.getSize() == 0 )
+                        {
+                            bAvail = false;
+                            v = buf;
+                            return tokChar;
+                        }
+                        else
+                        {
+                            v = sTok;
+                            return tokFluff;
+                        }
+                    }
+                    else
+                    {
+                        sTok += buf;
+                        bAvail = false;
+                    }
+                    break;
+
+                case mSuite:
+                    if( buf == ' ' || buf == '\t' || buf == '\n'
+                        || buf == '\r' )
+                    {
+                        if( sTok == "test" )
+                            return tokTest;
+                        else
+                        {
+                            v = sTok;
+                            return tokFluff;
+                        }
+                    }
+                    else if( buf == '(' || buf == ')'
+                        || buf == '}' || buf == ';' )
+                    {
+                        if( sTok.getSize() == 0 )
+                        {
+                            bAvail = false;
+                            v = buf;
+                            return tokChar;
+                        }
+                        else
+                        {
+                            v = sTok;
+                            return tokFluff;
+                        }
+                    }
+                    else if( buf == '{' )
+                    {
+                        if( sTok.getSize() > 0 )
+                        {
+                            v = sTok;
+                            return tokFluff;
+                        }
+                        else
+                        {
+                            sTok += buf;
+                            bAvail = false;
+                            eMode = mBlock;
+                            iDepth = 1;
+                        }
+                    }
+                    else
+                    {
+                        sTok += buf;
+                        bAvail = false;
+                    }
+                    break;
+
+                case mBlock:
+                    if( bInStr )
+                    {
+                        if( buf == '\\' )
+                        {
+                            sTok += buf;
+                            bAvail = false;
+                            sTok += nextChar();
+                            bAvail = false;
+                        }
+                        else if( bDblStr == true && buf == '\"' )
                                                 {
                                                         sTok += buf;
                                                         bAvail = false;
@@ -267,295 +267,295 @@ public:
                                         else
                                         {
                                                 if( buf == '\"' )
-                                                {
-                                                        bInStr = true;
-                                                        bDblStr = true;
-                                                        sTok += buf;
-                                                        bAvail = false;
-                                                }
-                                                else if( buf == '\'' )
-                                                {
-                                                        bInStr = true;
-                                                        bDblStr = false;
-                                                        sTok += buf;
-                                                        bAvail = false;
-                                                }
-                                                else if( buf == '}' )
-                                                {
-                                                        sTok += buf;
-                                                        bAvail = false;
-                                                        iDepth--;
-                                                        if( iDepth == 0 )
-                                                        {
-                                                                v = sTok;
-                                                                eMode = mSuite;
-                                                                return tokBlock;
-                                                        }
-                                                }
-                                                else if( buf == '{' )
-                                                {
-                                                        sTok += buf;
-                                                        bAvail = false;
-                                                        iDepth++;
-                                                }
-                                                else
-                                                {
-                                                        sTok += buf;
-                                                        bAvail = false;
-                                                }
-                                        }
-                                        break;
-                        }
-                
-                        buf = nextChar();
-                }
-        }
-
-        void firstPass()
-        {
-                Variant v;
-                Bu::String sWs;
-                int iL, iC;
-                for(;;)
-                {
-                        TokType t = nextToken( v, sWs, iL, iC );
-                        if( t == tokEof )
-                                return;
-                        switch( eMode )
-                        {
-                                case mRoot:
-                                        if( t == tokSuite )
-                                        {
-                                                if( nextToken( v, sWs, iL, iC ) != tokFluff )
-                                                        throw Bu::ExceptionBase("%d:%d: Expected string "
-                                                                "following suite.", iL, iC );
-                                                s.sName = v.get<Bu::String>();
-                                                if( nextToken( v, sWs, iL, iC ) != tokChar ||
-                                                        v.get<char>() != '{' )
-                                                        throw Bu::ExceptionBase("%d:%d: Expected {, got "
-                                                                "'%s'", iL, iC, v.toString().getStr() );
-                                                eMode = mSuite;
-                                        }
-                                        break;
-
-                                case mSuite:
-                                        switch( t )
-                                        {
-                                                case tokFluff:
-                                                        break;
-
-                                                case tokBlock:
-                                                        break;
-
-                                                case tokTest:
-                                                        {
-                                                                if( nextToken( v, sWs, iL, iC ) != tokFluff )
-                                                                        throw Bu::ExceptionBase("%d:%d: Expected "
-                                                                                "string following test.", iL, iC );
-                                                                Test t;
-                                                                t.sName = v.get<Bu::String>();
-                                                                if( nextToken( v, sWs, iL, iC ) != tokBlock )
-                                                                        throw Bu::ExceptionBase("%d:%d: Expected "
-                                                                                "{...} block.",
-                                                                                iL, iC );
-                                                                s.lTest.append( t );
-                                                        }
-                                                        break;
-
-                                                case tokChar:
-                                                        if( v.get<char>() == '}' )
-                                                        {
-                                                                eMode = mRoot;
-                                                        }
-                                                        else
-                                                        {
-                                                        }
-                                                        break;
-
-                                                default:
-                                                        sio << iL << ":" << iC << ": Unexpected "
-                                                                << t << " found." << sio.nl;
-                                                        return;
-                                                        break;
-                                        }
-                                        break;
-
-                                default:
-                                        sio << "???" << sio.nl;
-                                        break;
-                        }
-                }
-        }
-
-        void secondPass( const Bu::String &sOut )
-        {
-                File fOut( sOut, File::WriteNew );
-                Formatter f( fOut );
-                fIn.setPos( 0 );
-                bIn.stop();
-                bIn.start();
-                bAvail = false;
-                eMode = mRoot;
-                iLine = 1;
-                iChar = 0;
-                bool bHasIncluded = false;
-
-                Bu::String sWs;
-                Variant v;
-                int iL, iC;
-                for(;;)
-                {
-                        TokType t = nextToken( v, sWs, iL, iC );
-                        switch( eMode )
-                        {
-                                case mRoot:
-                                        if( t == tokSuite )
-                                        {
-                                                fOut.write( sWs );
-                                                if( nextToken( v, sWs, iL, iC ) != tokFluff )
-                                                        throw Bu::ExceptionBase("%d:%d: Expected string "
-                                                                "following suite.", iL, iC );
-                                                s.sName = v.get<Bu::String>();
-                                                if( nextToken( v, sWs, iL, iC ) != tokChar ||
-                                                        v.get<char>() != '{' )
-                                                        throw Bu::ExceptionBase("%d:%d: Expected {",
-                                                                iL, iC );
-                                                eMode = mSuite;
-
-                                                if( bHasIncluded == false )
-                                                {
-                                                        fOut.write("#include <bu/unitsuite.h>\n");
-                                                        bHasIncluded = true;
-                                                }
-
-                                                Bu::String sClass = "_UnitSuite_" + s.sName;
-                                                f << "class " << sClass
-                                                        << " : public Bu::UnitSuite" << f.nl
-                                                        << "{" << f.nl << "public:" << f.nl
-                                                        << "\t" << sClass << "()" << f.nl
-                                                        << "\t{" << f.nl
-                                                        << "\t\tsetName(\"" << s.sName << "\");" << f.nl;
-                                                for( TestList::iterator i = s.lTest.begin(); i; i++ )
-                                                {
-                                                        f << "\t\tadd( static_cast<Bu::UnitSuite::Test>("
-                                                                "&" << sClass << "::" << (*i).sName << "), \""
+                        {
+                            bInStr = true;
+                            bDblStr = true;
+                            sTok += buf;
+                            bAvail = false;
+                        }
+                        else if( buf == '\'' )
+                        {
+                            bInStr = true;
+                            bDblStr = false;
+                            sTok += buf;
+                            bAvail = false;
+                        }
+                        else if( buf == '}' )
+                        {
+                            sTok += buf;
+                            bAvail = false;
+                            iDepth--;
+                            if( iDepth == 0 )
+                            {
+                                v = sTok;
+                                eMode = mSuite;
+                                return tokBlock;
+                            }
+                        }
+                        else if( buf == '{' )
+                        {
+                            sTok += buf;
+                            bAvail = false;
+                            iDepth++;
+                        }
+                        else
+                        {
+                            sTok += buf;
+                            bAvail = false;
+                        }
+                    }
+                    break;
+            }
+        
+            buf = nextChar();
+        }
+    }
+
+    void firstPass()
+    {
+        Variant v;
+        Bu::String sWs;
+        int iL, iC;
+        for(;;)
+        {
+            TokType t = nextToken( v, sWs, iL, iC );
+            if( t == tokEof )
+                return;
+            switch( eMode )
+            {
+                case mRoot:
+                    if( t == tokSuite )
+                    {
+                        if( nextToken( v, sWs, iL, iC ) != tokFluff )
+                            throw Bu::ExceptionBase("%d:%d: Expected string "
+                                "following suite.", iL, iC );
+                        s.sName = v.get<Bu::String>();
+                        if( nextToken( v, sWs, iL, iC ) != tokChar ||
+                            v.get<char>() != '{' )
+                            throw Bu::ExceptionBase("%d:%d: Expected {, got "
+                                "'%s'", iL, iC, v.toString().getStr() );
+                        eMode = mSuite;
+                    }
+                    break;
+
+                case mSuite:
+                    switch( t )
+                    {
+                        case tokFluff:
+                            break;
+
+                        case tokBlock:
+                            break;
+
+                        case tokTest:
+                            {
+                                if( nextToken( v, sWs, iL, iC ) != tokFluff )
+                                    throw Bu::ExceptionBase("%d:%d: Expected "
+                                        "string following test.", iL, iC );
+                                Test t;
+                                t.sName = v.get<Bu::String>();
+                                if( nextToken( v, sWs, iL, iC ) != tokBlock )
+                                    throw Bu::ExceptionBase("%d:%d: Expected "
+                                        "{...} block.",
+                                        iL, iC );
+                                s.lTest.append( t );
+                            }
+                            break;
+
+                        case tokChar:
+                            if( v.get<char>() == '}' )
+                            {
+                                eMode = mRoot;
+                            }
+                            else
+                            {
+                            }
+                            break;
+
+                        default:
+                            sio << iL << ":" << iC << ": Unexpected "
+                                << t << " found." << sio.nl;
+                            return;
+                            break;
+                    }
+                    break;
+
+                default:
+                    sio << "???" << sio.nl;
+                    break;
+            }
+        }
+    }
+
+    void secondPass( const Bu::String &sOut )
+    {
+        File fOut( sOut, File::WriteNew );
+        Formatter f( fOut );
+        fIn.setPos( 0 );
+        bIn.stop();
+        bIn.start();
+        bAvail = false;
+        eMode = mRoot;
+        iLine = 1;
+        iChar = 0;
+        bool bHasIncluded = false;
+
+        Bu::String sWs;
+        Variant v;
+        int iL, iC;
+        for(;;)
+        {
+            TokType t = nextToken( v, sWs, iL, iC );
+            switch( eMode )
+            {
+                case mRoot:
+                    if( t == tokSuite )
+                    {
+                        fOut.write( sWs );
+                        if( nextToken( v, sWs, iL, iC ) != tokFluff )
+                            throw Bu::ExceptionBase("%d:%d: Expected string "
+                                "following suite.", iL, iC );
+                        s.sName = v.get<Bu::String>();
+                        if( nextToken( v, sWs, iL, iC ) != tokChar ||
+                            v.get<char>() != '{' )
+                            throw Bu::ExceptionBase("%d:%d: Expected {",
+                                iL, iC );
+                        eMode = mSuite;
+
+                        if( bHasIncluded == false )
+                        {
+                            fOut.write("#include <bu/unitsuite.h>\n");
+                            bHasIncluded = true;
+                        }
+
+                        Bu::String sClass = "_UnitSuite_" + s.sName;
+                        f << "class " << sClass
+                            << " : public Bu::UnitSuite" << f.nl
+                            << "{" << f.nl << "public:" << f.nl
+                            << "\t" << sClass << "()" << f.nl
+                            << "\t{" << f.nl
+                            << "\t\tsetName(\"" << s.sName << "\");" << f.nl;
+                        for( TestList::iterator i = s.lTest.begin(); i; i++ )
+                        {
+                            f << "\t\tadd( static_cast<Bu::UnitSuite::Test>("
+                                "&" << sClass << "::" << (*i).sName << "), \""
                                                                 << (*i).sName << "\", Bu::UnitSuite::"
-                                                                "expectPass );" << f.nl;
-                                                }
-                                                f << "\t}" << f.nl << f.nl
-                                                        << "\tvirtual ~" << sClass << "() { }" << f.nl
-                                                        << f.nl;
-                                        }
-                                        else if( t == tokEof )
-                                        {
-                                                Bu::String sClass = "_UnitSuite_" + s.sName;
-                                                f << sWs << f.nl << "int main( int argc, char *argv[] )"
-                                                        << f.nl << "{" << f.nl << "\treturn " << sClass
-                                                        << "().run( argc, argv );" << f.nl << "}" << f.nl;
-                                        }
-                                        else
-                                        {
-                                                fOut.write( sWs );
-                                                f << v;
-                                        }
-                                        break;
-
-                                case mSuite:
-                                        switch( t )
-                                        {
-                                                case tokFluff:
-                                                        fOut.write( sWs );
-                                                        fOut.write( v.get<Bu::String>() );
-                                                        break;
-
-                                                case tokTest:
-                                                        {
-                                                                fOut.write( sWs );
-                                                                if( nextToken( v, sWs, iL, iC ) != tokFluff )
-                                                                        throw Bu::ExceptionBase("%d:%d: Expected "
-                                                                                "string following test.", iL, iC );
-                                                                Test t;
-                                                                t.sName = v.get<Bu::String>();
-                                                                if( nextToken( v, sWs, iL, iC ) != tokBlock )
-                                                                        throw Bu::ExceptionBase("%d:%d: Expected "
-                                                                                "{...} block.",
-                                                                                iL, iC );
-                                                                
-                                                                f << "\tvoid " << t.sName << "()"
-                                                                        << f.nl << "#line " << iL
-                                                                        << " \"" << sIn << "\"" << f.nl
-                                                                        << v << f.nl;
-                                                        }
-                                                        break;
-
-                                                case tokChar:
-                                                        if( v.get<char>() == '}' )
-                                                        {
-                                                                f << "};" << f.nl << f.nl;
-                                                                eMode = mRoot;
-                                                        }
-                                                        else
-                                                        {
-                                                                char buf = v.get<char>();
-                                                                fOut.write( sWs );
-                                                                fOut.write( &buf, 1 );
-                                                        }
-                                                        break;
-                                                
-                                                case tokBlock:
-                                                        fOut.write( sWs );
-                                                        f << f.nl << "#line " << iL << " \"" << sIn
+                                "expectPass );" << f.nl;
+                        }
+                        f << "\t}" << f.nl << f.nl
+                            << "\tvirtual ~" << sClass << "() { }" << f.nl
+                            << f.nl;
+                    }
+                    else if( t == tokEof )
+                    {
+                        Bu::String sClass = "_UnitSuite_" + s.sName;
+                        f << sWs << f.nl << "int main( int argc, char *argv[] )"
+                            << f.nl << "{" << f.nl << "\treturn " << sClass
+                            << "().run( argc, argv );" << f.nl << "}" << f.nl;
+                    }
+                    else
+                    {
+                        fOut.write( sWs );
+                        f << v;
+                    }
+                    break;
+
+                case mSuite:
+                    switch( t )
+                    {
+                        case tokFluff:
+                            fOut.write( sWs );
+                            fOut.write( v.get<Bu::String>() );
+                            break;
+
+                        case tokTest:
+                            {
+                                fOut.write( sWs );
+                                if( nextToken( v, sWs, iL, iC ) != tokFluff )
+                                    throw Bu::ExceptionBase("%d:%d: Expected "
+                                        "string following test.", iL, iC );
+                                Test t;
+                                t.sName = v.get<Bu::String>();
+                                if( nextToken( v, sWs, iL, iC ) != tokBlock )
+                                    throw Bu::ExceptionBase("%d:%d: Expected "
+                                        "{...} block.",
+                                        iL, iC );
+                                
+                                f << "\tvoid " << t.sName << "()"
+                                    << f.nl << "#line " << iL
+                                    << " \"" << sIn << "\"" << f.nl
+                                    << v << f.nl;
+                            }
+                            break;
+
+                        case tokChar:
+                            if( v.get<char>() == '}' )
+                            {
+                                f << "};" << f.nl << f.nl;
+                                eMode = mRoot;
+                            }
+                            else
+                            {
+                                char buf = v.get<char>();
+                                fOut.write( sWs );
+                                fOut.write( &buf, 1 );
+                            }
+                            break;
+                        
+                        case tokBlock:
+                            fOut.write( sWs );
+                            f << f.nl << "#line " << iL << " \"" << sIn
                                                                 << "\"" << f.nl;
-                                                        fOut.write( v.get<Bu::String>() );
-
-                                                        break;
-
-                                                default:
-                                                        sio << iL << ":" << iC << ": Unexpected "
-                                                                << t << " found." << sio.nl;
-                                                        return;
-                                                        break;
-                                        }
-                                        break;
-
-                                default:
-                                        sio << "???" << sio.nl;
-                                        break;
-                        }
-                        if( t == tokEof )
-                                return;
-                }
-        }
+                            fOut.write( v.get<Bu::String>() );
+
+                            break;
+
+                        default:
+                            sio << iL << ":" << iC << ": Unexpected "
+                                << t << " found." << sio.nl;
+                            return;
+                            break;
+                    }
+                    break;
+
+                default:
+                    sio << "???" << sio.nl;
+                    break;
+            }
+            if( t == tokEof )
+                return;
+        }
+    }
 
 private:
-        Bu::String sIn;
-        File fIn;
-        Buffer bIn;
-        char cBuf;
-        bool bAvail;
-        enum Mode
-        {
-                mRoot,
-                mSuite,
-                mBlock
-        };
-        Mode eMode;
-        int iLine, iChar;
-        int iDepth;
-        Suite s;
+    Bu::String sIn;
+    File fIn;
+    Buffer bIn;
+    char cBuf;
+    bool bAvail;
+    enum Mode
+    {
+        mRoot,
+        mSuite,
+        mBlock
+    };
+    Mode eMode;
+    int iLine, iChar;
+    int iDepth;
+    Suite s;
 };
 
 int main( int argc, char *argv[] )
 {
-        if( argc < 3 )
-        {
-                sio << "Too few parameters." << sio.nl;
-                return 0;
-        }
-        Parser p( argv[1] );
+    if( argc < 3 )
+    {
+        sio << "Too few parameters." << sio.nl;
+        return 0;
+    }
+    Parser p( argv[1] );
 
-        p.firstPass();
+    p.firstPass();
 
-        p.secondPass( argv[2] );
+    p.secondPass( argv[2] );
 }
 
diff --git a/src/tools/myriad.cpp b/src/tools/myriad.cpp
index 7cab628..8a288b0 100644
--- a/src/tools/myriad.cpp
+++ b/src/tools/myriad.cpp
@@ -17,237 +17,237 @@ using namespace Bu;
 
 enum Mode
 {
-        modeCreate,
-        modeInfo,
-        modeStreamNew,
-        modeStreamDump,
-        modeStreamPut,
-        modeStreamGet,
-
-        modeNone
+    modeCreate,
+    modeInfo,
+    modeStreamNew,
+    modeStreamDump,
+    modeStreamPut,
+    modeStreamGet,
+
+    modeNone
 };
 
 class Options : public OptParser
 {
 public:
-        Options( int argc, char *argv[] ) :
-                eMode( modeNone ),
-                iBlockSize( 64 ),
-                iPreallocate( 0 ),
-                iStream( 0 )
-        {
-                addHelpBanner("Mode of operation:");
-                addOption( eMode, 'c', "create",
-                                "Create a new Myriad file." );
-                addOption( eMode, 'i', "info",
-                                "Display some info about a Myriad file." );
-                addOption( eMode, 'n', "new",
-                                "Create a new sub-stream in a Myriad file.");
-                addOption( eMode, 'd', "dump",
-                                "Display a hexdump of a stream from a Myriad file.");
-                addOption( eMode, "get",
-                                "Get a file out of a Myriad stream (use --dst).");
-                addOption( eMode, "put",
-                                "Put a file into a Myriad stream (usr --src).");
-                addHelpOption();
-
-                addHelpBanner("\nGeneral options:");
-                addOption( iBlockSize, 'b', "block-size", "Set the block size." );
-                addOption( iPreallocate, 'p', "preallocate",
-                        "Number of blocks to preallocate." );
-                addOption( sFile, 'f', "file", "Set the Myriad filename." );
-                addOption( iStream, 's', "stream", "Substream to work with.");
-                addOption( sSrc, "src", "Source file for copying into a Myriad file.");
-                addOption( sDst, "dst",
-                                "Destination file for copying out of a Myriad file.");
-
-                setOverride( "create", modeCreate );
-                setOverride( "info", modeInfo );
-                setOverride( "new", modeStreamNew );
-                setOverride( "dump", modeStreamDump );
-                setOverride( "put", modeStreamPut );
-                setOverride( "get", modeStreamGet );
-
-                parse( argc, argv );
-        }
-
-        Mode eMode;
-        int iBlockSize;
-        int iPreallocate;
-        int iStream;
-        Bu::String sFile;
-        Bu::String sSrc;
-        Bu::String sDst;
+    Options( int argc, char *argv[] ) :
+        eMode( modeNone ),
+        iBlockSize( 64 ),
+        iPreallocate( 0 ),
+        iStream( 0 )
+    {
+        addHelpBanner("Mode of operation:");
+        addOption( eMode, 'c', "create",
+                "Create a new Myriad file." );
+        addOption( eMode, 'i', "info",
+                "Display some info about a Myriad file." );
+        addOption( eMode, 'n', "new",
+                "Create a new sub-stream in a Myriad file.");
+        addOption( eMode, 'd', "dump",
+                "Display a hexdump of a stream from a Myriad file.");
+        addOption( eMode, "get",
+                "Get a file out of a Myriad stream (use --dst).");
+        addOption( eMode, "put",
+                "Put a file into a Myriad stream (usr --src).");
+        addHelpOption();
+
+        addHelpBanner("\nGeneral options:");
+        addOption( iBlockSize, 'b', "block-size", "Set the block size." );
+        addOption( iPreallocate, 'p', "preallocate",
+            "Number of blocks to preallocate." );
+        addOption( sFile, 'f', "file", "Set the Myriad filename." );
+        addOption( iStream, 's', "stream", "Substream to work with.");
+        addOption( sSrc, "src", "Source file for copying into a Myriad file.");
+        addOption( sDst, "dst",
+                "Destination file for copying out of a Myriad file.");
+
+        setOverride( "create", modeCreate );
+        setOverride( "info", modeInfo );
+        setOverride( "new", modeStreamNew );
+        setOverride( "dump", modeStreamDump );
+        setOverride( "put", modeStreamPut );
+        setOverride( "get", modeStreamGet );
+
+        parse( argc, argv );
+    }
+
+    Mode eMode;
+    int iBlockSize;
+    int iPreallocate;
+    int iStream;
+    Bu::String sFile;
+    Bu::String sSrc;
+    Bu::String sDst;
 };
 
 Bu::Formatter &operator>>( Bu::Formatter &f, Mode & /*e*/ )
 {
-        sio << "Uh oh, the formatter was called..." << sio.nl;
-        return f;
+    sio << "Uh oh, the formatter was called..." << sio.nl;
+    return f;
 }
 
 int main( int argc, char *argv[] )
 {
-        Options opts( argc, argv );
-
-        switch( opts.eMode )
-        {
-                case modeCreate:
-                        if( !opts.sFile.isSet() )
-                        {
-                                sio << "Please specify a file to create." << sio.nl;
-                                return 0;
-                        }
-                        else
-                        {
-                                File fOut( opts.sFile, File::WriteNew|File::Read );
-                                Myriad m( fOut, opts.iBlockSize, opts.iPreallocate );
-                        }
-                        break;
-
-                case modeInfo:
-                        if( !opts.sFile.isSet() )
-                        {
-                                sio << "Please specify a file to display info about." << sio.nl;
-                                return 0;
-                        }
-                        else
-                        {
-                                File fIn( opts.sFile, File::Read );
-                                Myriad m( fIn );
-                                sio << "Myriad info:" << sio.nl
-                                        << "  Block size:   " << m.getBlockSize() << sio.nl
-                                        << "  Block count:  " << m.getNumBlocks() << sio.nl
-                                        << "  Blocks used:  " << m.getNumUsedBlocks() << " ("
-                                        << m.getNumUsedBlocks()*100/m.getNumBlocks() << "%)"
-                                        << sio.nl
-                                        << "  Stream count: " << m.getNumStreams() << sio.nl
-                                        << "  Used space:   " << m.getTotalUsedBytes() << sio.nl
-                                        << "  Unused space: " << m.getTotalUnusedBytes() << sio.nl
-                                        << "  % of files:   " << (double)(m.getNumBlocks()*m.getBlockSize())/(double)(m.getTotalUsedBytes() + m.getTotalUnusedBytes( 4096 ))*100.0 << sio.nl;
-/*                              Bu::Array<int> aStreams = m.getStreamIds();
-                                sio << "  Stream info:" << sio.nl;
-                                for( Bu::Array<int>::iterator i = aStreams.begin(); i; i++ )
-                                {
-                                        sio << "    " << Fmt(4) << *i << ") "
-                                                << m.getStreamSize( *i ) << "b" << sio.nl;
-                                } */
-                        }
-                        break;
-
-                case modeStreamNew:
-                        if( !opts.sFile.isSet() )
-                        {
-                                sio << "Please specify a file manipulate." << sio.nl;
-                                return 0;
-                        }
-                        else
-                        {
-                                File fOut( opts.sFile, File::Write|File::Read );
-                                Myriad m( fOut );
-                                m.createStream( opts.iPreallocate );
-                        }
-                        break;
-
-                case modeStreamDump:
-                        if( !opts.sFile.isSet() )
-                        {
-                                sio << "Please specify a file to manipulate." << sio.nl;
-                                return 0;
-                        }
-                        else
-                        {
-                                File fOut( opts.sFile, File::Read );
-                                Myriad m( fOut );
-                                MyriadStream s = m.openStream( opts.iStream );
-                                sio << "Stream " << opts.iStream << ":" << sio.nl;
-                                char buf[8];
-                                int iPos = 0;
-                                while( !s.isEos() )
-                                {
-                                        size_t sAmnt = s.read( buf, 8 );
-                                        sio << Fmt(5) << iPos << ": ";
-                                        iPos += sAmnt;
-                                        for( size_t j = 0; j < sAmnt; j++ )
-                                        {
-                                                sio << Fmt::hex(2) << (int)((unsigned char)buf[j])
-                                                        << " ";
-                                        }
-                                        for( size_t j = sAmnt; j < 8; j++ )
-                                        {
-                                                sio << "-- ";
-                                        }
-                                        sio << "| ";
-                                        for( size_t j = 0; j < sAmnt; j++ )
-                                        {
-                                                if( buf[j] >= 32 && buf[j] <= 126 )
-                                                        sio << buf[j] << " ";
-                                                else
-                                                        sio << "  ";
-                                        }
-                                        sio << sio.nl;
-                                }
-                                sio << "Position: " << s.tell() << ", isEos()=" << s.isEos()
-                                        << sio.nl;
-                        }
-                        break;
-
-                case modeStreamPut:
-                        if( !opts.sFile.isSet() )
-                        {
-                                sio << "Please specify a file manipulate." << sio.nl;
-                                return 0;
-                        }
-                        else if( !opts.sSrc.isSet() )
-                        {
-                                sio << "Please specify a source file to read." << sio.nl;
-                        }
-                        else
-                        {
-                                File fOut( opts.sFile, File::Write|File::Read );
-                                Myriad m( fOut );
-                                MyriadStream sOut = m.openStream(
-                                        m.createStream( opts.iPreallocate )
-                                        );
-                                File fIn( opts.sSrc, File::Read );
-                                char buf[1024];
-                                while( !fIn.isEos() )
-                                {
-                                        sOut.write( buf, fIn.read( buf, 1024 ) );
-                                }
-                        }
-                        break;
-
-                case modeStreamGet:
-                        if( !opts.sFile.isSet() )
-                        {
-                                sio << "Please specify a file manipulate." << sio.nl;
-                                return 0;
-                        }
-                        else if( !opts.sDst.isSet() )
-                        {
-                                sio << "Please specify a destination file to write." << sio.nl;
-                        }
-                        else
-                        {
-                                File fIn( opts.sFile, File::Write|File::Read );
-                                Myriad m( fIn );
-                                MyriadStream sIn = m.openStream( opts.iStream );
-                                File fOut( opts.sDst, File::Write|File::Create|File::Truncate );
-                                char buf[1024];
-                                while( !sIn.isEos() )
-                                {
-                                        fOut.write( buf, sIn.read( buf, 1024 ) );
-                                }
-                        }
-                        break;
-
-                case modeNone:
-                        sio << "Please select a mode, for more info, try --help."
-                                << sio.nl << sio.nl;
-                        break;
-        }
-
-        return 0;
+    Options opts( argc, argv );
+
+    switch( opts.eMode )
+    {
+        case modeCreate:
+            if( !opts.sFile.isSet() )
+            {
+                sio << "Please specify a file to create." << sio.nl;
+                return 0;
+            }
+            else
+            {
+                File fOut( opts.sFile, File::WriteNew|File::Read );
+                Myriad m( fOut, opts.iBlockSize, opts.iPreallocate );
+            }
+            break;
+
+        case modeInfo:
+            if( !opts.sFile.isSet() )
+            {
+                sio << "Please specify a file to display info about." << sio.nl;
+                return 0;
+            }
+            else
+            {
+                File fIn( opts.sFile, File::Read );
+                Myriad m( fIn );
+                sio << "Myriad info:" << sio.nl
+                    << "  Block size:   " << m.getBlockSize() << sio.nl
+                    << "  Block count:  " << m.getNumBlocks() << sio.nl
+                    << "  Blocks used:  " << m.getNumUsedBlocks() << " ("
+                    << m.getNumUsedBlocks()*100/m.getNumBlocks() << "%)"
+                    << sio.nl
+                    << "  Stream count: " << m.getNumStreams() << sio.nl
+                    << "  Used space:   " << m.getTotalUsedBytes() << sio.nl
+                    << "  Unused space: " << m.getTotalUnusedBytes() << sio.nl
+                    << "  % of files:   " << (double)(m.getNumBlocks()*m.getBlockSize())/(double)(m.getTotalUsedBytes() + m.getTotalUnusedBytes( 4096 ))*100.0 << sio.nl;
+/*              Bu::Array<int> aStreams = m.getStreamIds();
+                sio << "  Stream info:" << sio.nl;
+                for( Bu::Array<int>::iterator i = aStreams.begin(); i; i++ )
+                {
+                    sio << "    " << Fmt(4) << *i << ") "
+                        << m.getStreamSize( *i ) << "b" << sio.nl;
+                } */
+            }
+            break;
+
+        case modeStreamNew:
+            if( !opts.sFile.isSet() )
+            {
+                sio << "Please specify a file manipulate." << sio.nl;
+                return 0;
+            }
+            else
+            {
+                File fOut( opts.sFile, File::Write|File::Read );
+                Myriad m( fOut );
+                m.createStream( opts.iPreallocate );
+            }
+            break;
+
+        case modeStreamDump:
+            if( !opts.sFile.isSet() )
+            {
+                sio << "Please specify a file to manipulate." << sio.nl;
+                return 0;
+            }
+            else
+            {
+                File fOut( opts.sFile, File::Read );
+                Myriad m( fOut );
+                MyriadStream s = m.openStream( opts.iStream );
+                sio << "Stream " << opts.iStream << ":" << sio.nl;
+                char buf[8];
+                int iPos = 0;
+                while( !s.isEos() )
+                {
+                    size_t sAmnt = s.read( buf, 8 );
+                    sio << Fmt(5) << iPos << ": ";
+                    iPos += sAmnt;
+                    for( size_t j = 0; j < sAmnt; j++ )
+                    {
+                        sio << Fmt::hex(2) << (int)((unsigned char)buf[j])
+                            << " ";
+                    }
+                    for( size_t j = sAmnt; j < 8; j++ )
+                    {
+                        sio << "-- ";
+                    }
+                    sio << "| ";
+                    for( size_t j = 0; j < sAmnt; j++ )
+                    {
+                        if( buf[j] >= 32 && buf[j] <= 126 )
+                            sio << buf[j] << " ";
+                        else
+                            sio << "  ";
+                    }
+                    sio << sio.nl;
+                }
+                sio << "Position: " << s.tell() << ", isEos()=" << s.isEos()
+                    << sio.nl;
+            }
+            break;
+
+        case modeStreamPut:
+            if( !opts.sFile.isSet() )
+            {
+                sio << "Please specify a file manipulate." << sio.nl;
+                return 0;
+            }
+            else if( !opts.sSrc.isSet() )
+            {
+                sio << "Please specify a source file to read." << sio.nl;
+            }
+            else
+            {
+                File fOut( opts.sFile, File::Write|File::Read );
+                Myriad m( fOut );
+                MyriadStream sOut = m.openStream(
+                    m.createStream( opts.iPreallocate )
+                    );
+                File fIn( opts.sSrc, File::Read );
+                char buf[1024];
+                while( !fIn.isEos() )
+                {
+                    sOut.write( buf, fIn.read( buf, 1024 ) );
+                }
+            }
+            break;
+
+        case modeStreamGet:
+            if( !opts.sFile.isSet() )
+            {
+                sio << "Please specify a file manipulate." << sio.nl;
+                return 0;
+            }
+            else if( !opts.sDst.isSet() )
+            {
+                sio << "Please specify a destination file to write." << sio.nl;
+            }
+            else
+            {
+                File fIn( opts.sFile, File::Write|File::Read );
+                Myriad m( fIn );
+                MyriadStream sIn = m.openStream( opts.iStream );
+                File fOut( opts.sDst, File::Write|File::Create|File::Truncate );
+                char buf[1024];
+                while( !sIn.isEos() )
+                {
+                    fOut.write( buf, sIn.read( buf, 1024 ) );
+                }
+            }
+            break;
+
+        case modeNone:
+            sio << "Please select a mode, for more info, try --help."
+                << sio.nl << sio.nl;
+            break;
+    }
+
+    return 0;
 }
 
diff --git a/src/tools/viewcsv.cpp b/src/tools/viewcsv.cpp
index 5009ea8..328cafc 100644
--- a/src/tools/viewcsv.cpp
+++ b/src/tools/viewcsv.cpp
@@ -20,33 +20,33 @@ using namespace Bu;
 class Options : public Bu::OptParser
 {
 public:
-        Options( int argc, char *argv[] ) :
-                bHeader( true )
-        {
-                addOption( bHeader, "no-header",
-                        "Don't use the first line as a header row.  This behaviour can "
-                        "also be toggled while running with 'h'." );
-                setNonOption( slot( this, &Options::onNonOption ) );
-                addHelpOption();
-
-                setOverride( "no-header", "true" );
-                parse( argc, argv );
-        }
-
-        virtual ~Options()
-        {
-        }
-
-        int onNonOption( StrArray aParams )
-        {
-                //sio << aParams << sio.nl;
-                sFileIn = aParams[0];
-
-                return 0;
-        }
-
-        Bu::String sFileIn;
-        bool bHeader;
+    Options( int argc, char *argv[] ) :
+        bHeader( true )
+    {
+        addOption( bHeader, "no-header",
+            "Don't use the first line as a header row.  This behaviour can "
+            "also be toggled while running with 'h'." );
+        setNonOption( slot( this, &Options::onNonOption ) );
+        addHelpOption();
+
+        setOverride( "no-header", "true" );
+        parse( argc, argv );
+    }
+
+    virtual ~Options()
+    {
+    }
+
+    int onNonOption( StrArray aParams )
+    {
+        //sio << aParams << sio.nl;
+        sFileIn = aParams[0];
+
+        return 0;
+    }
+
+    Bu::String sFileIn;
+    bool bHeader;
 };
 
 typedef Bu::Array<StrArray> StrGrid;
@@ -54,421 +54,421 @@ typedef Bu::Array<int> IntArray;
 class CsvDoc
 {
 public:
-        CsvDoc() :
-                iMaxCols( 0 )
-        {
-        }
-
-        virtual ~CsvDoc()
-        {
-        }
-
-        void addRow( StrArray aStr )
-        {
-                sgData.append( aStr );
-                if( iMaxCols < aStr.getSize() )
-                        iMaxCols = aStr.getSize();
-                while( aWidths.getSize() < iMaxCols )
-                {
-                        aWidths.append( 0 );
-                }
-                for( int j = 0; j < aStr.getSize(); j++ )
-                {
-                        if( aWidths[j] < aStr[j].getSize() )
-                                aWidths[j] = aStr[j].getSize();
-                }
-        }
-
-        int iMaxCols;
-        StrGrid sgData;
-        IntArray aWidths;
+    CsvDoc() :
+        iMaxCols( 0 )
+    {
+    }
+
+    virtual ~CsvDoc()
+    {
+    }
+
+    void addRow( StrArray aStr )
+    {
+        sgData.append( aStr );
+        if( iMaxCols < aStr.getSize() )
+            iMaxCols = aStr.getSize();
+        while( aWidths.getSize() < iMaxCols )
+        {
+            aWidths.append( 0 );
+        }
+        for( int j = 0; j < aStr.getSize(); j++ )
+        {
+            if( aWidths[j] < aStr[j].getSize() )
+                aWidths[j] = aStr[j].getSize();
+        }
+    }
+
+    int iMaxCols;
+    StrGrid sgData;
+    IntArray aWidths;
 };
 
 class CsvView
 {
 public:
-        CsvView( CsvDoc &doc ) :
-                doc( doc ),
-                iXOff( 0 ),
-                iYOff( 0 ),
-                bHeaderRow( false )
-        {
-        }
-
-        virtual ~CsvView()
-        {
-        }
-
-        void render()
-        {
-                erase();
-                int maxx, maxy;
-                getmaxyx( stdscr, maxy, maxx );
-
-                int iRows = buMin( (int)doc.sgData.getSize(), maxy-((bHeaderRow)?(4):(3)) );
-                int iCols = buMin( doc.iMaxCols, (int)maxx-1 );
-
-                int iHdrHeight = 1;
-                if( bHeaderRow )
-                        iHdrHeight++;
-
-                // Draw the headers
-                for( int iRow = 0; iRow < iRows; iRow++ )
-                {
-                        if( iRow+iYOff >= doc.sgData.getSize() )
-                                break;
-                        char buf[6];
-                        snprintf( buf, 6, "%5d", iRow+iYOff );
-                        mvaddnstr( iRow+iHdrHeight+1, 0, buf, 5 );
-                        mvaddch( iRow+iHdrHeight+1, 6, ACS_VLINE );
-                }
-                int iXPos = 6;
-                try
-                {
-                        for( int iCol = 0; iCol < iCols; iCol++ )
-                        {
-                                if( iXPos >= maxx )
-                                        break;
-                                int iWidth = buMin( doc.aWidths[iCol+iXOff], maxx-iXPos-1 );
-                                char buf[6];
-                                snprintf( buf, 6, "%d", iCol+iXOff );
-                                mvaddch( 0, iXPos, ACS_VLINE );
-                                mvaddch( iHdrHeight, iXPos, ACS_PLUS );
-                                mvaddnstr( 0, iXPos+1, buf, 5 );
-                                if( bHeaderRow )
-                                {
-                                        mvaddnstr(
-                                                1, iXPos+1, doc.sgData[0][iCol+iXOff].getStr(), iWidth
-                                                );
-                                        mvaddch( 1, iXPos, ACS_VLINE );
-                                }
-                                for( int j = 0; j < iWidth; j++ )
-                                {
-                                        mvaddch( iHdrHeight, iXPos+j+1, ACS_HLINE );
-                                }
-                                iXPos += iWidth+1;
-                        }
-                }
-                catch(...) { }
-                for( int j = 0; j < 6; j++ )
-                {
-                        mvaddch( iHdrHeight, j, ACS_HLINE );
-                }
-
-                // Draw some data
-                for( int iRow = 0; iRow < iRows; iRow++ )
-                {
-                        try
-                        {
-                        int iXPos = 6;
-                        for( int iCol = 0; iCol < iCols; iCol++ )
-                        {
-                                if( iXPos >= maxx )
-                                        break;
-                                int iWidth = buMin( doc.aWidths[iCol+iXOff], maxx-iXPos-1 );
-                                mvaddch( iRow+iHdrHeight+1, iXPos, ACS_VLINE );
-                                mvaddnstr( iRow+iHdrHeight+1, iXPos+1,
-                                                doc.sgData[iRow+iYOff][iCol+iXOff].getStr(), iWidth );
-                                iXPos += iWidth+1;
-                        }
-                        } catch(...) { }
-                }
-
-                attron( A_REVERSE );
-                for( int j = 0; j < maxx; j++ )
-                {
-                        mvaddch( maxy-1, j, ' ' );
-                }
-                mvaddstr( maxy-1, 1, "q) quit  h) toggle header row" );
-                char buf[30];
-                int iWidth = sprintf( buf, "[%dx%ld]",
-                        doc.iMaxCols, doc.sgData.getSize()
-                        );
-                mvaddstr( maxy-1, maxx-iWidth-1, buf );
-                attroff( A_REVERSE );
-        }
-
-        void move( int iX, int iY )
-        {
-                iXOff += iX;
-                iYOff += iY;
-                if( iXOff < 0 )
-                        iXOff = 0;
-
-                if( bHeaderRow )
-                {
-                        if( iYOff < 1 )
-                                iYOff = 1;
-                }
-                else
-                {
-                        if( iYOff < 0 )
-                                iYOff = 0;
-                }
-
-                if( iYOff >= doc.sgData.getSize() )
-                        iYOff = doc.sgData.getSize()-1;
-
-                if( iXOff >= doc.iMaxCols )
-                        iXOff = doc.iMaxCols-1;
-        }
-
-        void pageDown()
-        {
-                int maxx, maxy;
-                getmaxyx( stdscr, maxy, maxx );
-                move( 0, maxy-((bHeaderRow)?(4):(3)) );
-        }
-
-        void pageUp()
-        {
-                int maxx, maxy;
-                getmaxyx( stdscr, maxy, maxx );
-                move( 0, -(maxy-((bHeaderRow)?(4):(3))) );
-        }
-
-        void home()
-        {
-                iYOff = 0;
-                if( bHeaderRow ) iYOff++;
-        }
-
-        void end()
-        {
-                iYOff = doc.sgData.getSize()-1;
-        }
-
-        void setHeaderRow( bool bOn )
-        {
-                if( bHeaderRow == bOn )
-                        return;
-
-                bHeaderRow = bOn;
-                move( 0, ((bOn)?(1):(-1)) );
-        }
-
-        void toggleHeaderRow()
-        {
-                setHeaderRow( !bHeaderRow );
-        }
-
-        Bu::String prompt( const Bu::String &sPrompt )
-        {
-                int maxx, maxy;
-                Bu::String sStr;
-
-                RegEx re( sPrompt );
-
-                curs_set( 1 );
-                for(;;)
-                {
-                        getmaxyx( stdscr, maxy, maxx );
-                        for( int j = 0; j < maxx; j++ )
-                        {
-                                mvaddch( maxy-1, j, ' ' );
-                        }
-                        mvaddstr( maxy-1, 0, sPrompt.getStr() );
-
-                        mvaddstr( maxy-1, sPrompt.getSize(), sStr.getStr() );
-
-                        int iCh = getch();
-                        switch( iCh )
-                        {
-                                case '\n':
-                                case '\r':
-                                case KEY_ENTER:
-                                        curs_set( 0 );
-                                        return sStr;
-                                        break;
-
-                                case KEY_BACKSPACE:
-                                        if( sStr.getSize() > 0 )
-                                                sStr.resize( sStr.getSize()-1 );
-                                        break;
-
-                                default:
-                                        if( iCh < 127 )
-                                                sStr += (char)iCh;
-                                        break;
-                        }
-                }
-        }
-
-        void resetCaret()
-        {
-                sysCaret.reset();
-        }
-
-        void findNext( const Bu::String &sTerm )
-        {
-                RegEx re( sTerm );
-
-                int y = sysCaret.iRow;
-                if( y < 0 )
-                        y = 0;
-                int x = sysCaret.iCol+1;
-                for( ; y < doc.sgData.getSize(); y++ )
-                {
-                        StrArray &aRow = doc.sgData[y];
-                        for( ; x < aRow.getSize(); x++ )
-                        {
-                                if( re.execute( aRow[x] ) ) //aRow[x].find( sTerm ) )
-                                {
-                                        sysCaret.iRow = y;
-                                        sysCaret.iCol = x;
-                                        scrollToCaret();
-                                        return;
-                                }
-                        }
-                        x = 0;
-                }
-        }
-
-        void scrollToCaret()
-        {
-                iXOff = sysCaret.iCol;
-                iYOff = sysCaret.iRow;
-        }
-
-        CsvDoc &doc;
-        int iXOff;
-        int iYOff;
-        bool bHeaderRow;
-
-        class Caret
-        {
-        public:
-                Caret() :
-                        iRow( -1 ),
-                        iCol( -1 )
-                {
-                }
-
-                virtual ~Caret()
-                {
-                }
-
-
-                void reset()
-                {
-                        iRow = iCol = -1;
-                }
-
-                bool isSet()
-                {
-                        if( iRow < 0 || iCol < 0 )
-                                return false;
-                        return true;
-                }
-
-                int iRow;
-                int iCol;
-        };
-
-        Caret sysCaret;
+    CsvView( CsvDoc &doc ) :
+        doc( doc ),
+        iXOff( 0 ),
+        iYOff( 0 ),
+        bHeaderRow( false )
+    {
+    }
+
+    virtual ~CsvView()
+    {
+    }
+
+    void render()
+    {
+        erase();
+        int maxx, maxy;
+        getmaxyx( stdscr, maxy, maxx );
+
+        int iRows = buMin( (int)doc.sgData.getSize(), maxy-((bHeaderRow)?(4):(3)) );
+        int iCols = buMin( doc.iMaxCols, (int)maxx-1 );
+
+        int iHdrHeight = 1;
+        if( bHeaderRow )
+            iHdrHeight++;
+
+        // Draw the headers
+        for( int iRow = 0; iRow < iRows; iRow++ )
+        {
+            if( iRow+iYOff >= doc.sgData.getSize() )
+                break;
+            char buf[6];
+            snprintf( buf, 6, "%5d", iRow+iYOff );
+            mvaddnstr( iRow+iHdrHeight+1, 0, buf, 5 );
+            mvaddch( iRow+iHdrHeight+1, 6, ACS_VLINE );
+        }
+        int iXPos = 6;
+        try
+        {
+            for( int iCol = 0; iCol < iCols; iCol++ )
+            {
+                if( iXPos >= maxx )
+                    break;
+                int iWidth = buMin( doc.aWidths[iCol+iXOff], maxx-iXPos-1 );
+                char buf[6];
+                snprintf( buf, 6, "%d", iCol+iXOff );
+                mvaddch( 0, iXPos, ACS_VLINE );
+                mvaddch( iHdrHeight, iXPos, ACS_PLUS );
+                mvaddnstr( 0, iXPos+1, buf, 5 );
+                if( bHeaderRow )
+                {
+                    mvaddnstr(
+                        1, iXPos+1, doc.sgData[0][iCol+iXOff].getStr(), iWidth
+                        );
+                    mvaddch( 1, iXPos, ACS_VLINE );
+                }
+                for( int j = 0; j < iWidth; j++ )
+                {
+                    mvaddch( iHdrHeight, iXPos+j+1, ACS_HLINE );
+                }
+                iXPos += iWidth+1;
+            }
+        }
+        catch(...) { }
+        for( int j = 0; j < 6; j++ )
+        {
+            mvaddch( iHdrHeight, j, ACS_HLINE );
+        }
+
+        // Draw some data
+        for( int iRow = 0; iRow < iRows; iRow++ )
+        {
+            try
+            {
+            int iXPos = 6;
+            for( int iCol = 0; iCol < iCols; iCol++ )
+            {
+                if( iXPos >= maxx )
+                    break;
+                int iWidth = buMin( doc.aWidths[iCol+iXOff], maxx-iXPos-1 );
+                mvaddch( iRow+iHdrHeight+1, iXPos, ACS_VLINE );
+                mvaddnstr( iRow+iHdrHeight+1, iXPos+1,
+                        doc.sgData[iRow+iYOff][iCol+iXOff].getStr(), iWidth );
+                iXPos += iWidth+1;
+            }
+            } catch(...) { }
+        }
+
+        attron( A_REVERSE );
+        for( int j = 0; j < maxx; j++ )
+        {
+            mvaddch( maxy-1, j, ' ' );
+        }
+        mvaddstr( maxy-1, 1, "q) quit  h) toggle header row" );
+        char buf[30];
+        int iWidth = sprintf( buf, "[%dx%ld]",
+            doc.iMaxCols, doc.sgData.getSize()
+            );
+        mvaddstr( maxy-1, maxx-iWidth-1, buf );
+        attroff( A_REVERSE );
+    }
+
+    void move( int iX, int iY )
+    {
+        iXOff += iX;
+        iYOff += iY;
+        if( iXOff < 0 )
+            iXOff = 0;
+
+        if( bHeaderRow )
+        {
+            if( iYOff < 1 )
+                iYOff = 1;
+        }
+        else
+        {
+            if( iYOff < 0 )
+                iYOff = 0;
+        }
+
+        if( iYOff >= doc.sgData.getSize() )
+            iYOff = doc.sgData.getSize()-1;
+
+        if( iXOff >= doc.iMaxCols )
+            iXOff = doc.iMaxCols-1;
+    }
+
+    void pageDown()
+    {
+        int maxx, maxy;
+        getmaxyx( stdscr, maxy, maxx );
+        move( 0, maxy-((bHeaderRow)?(4):(3)) );
+    }
+
+    void pageUp()
+    {
+        int maxx, maxy;
+        getmaxyx( stdscr, maxy, maxx );
+        move( 0, -(maxy-((bHeaderRow)?(4):(3))) );
+    }
+
+    void home()
+    {
+        iYOff = 0;
+        if( bHeaderRow ) iYOff++;
+    }
+
+    void end()
+    {
+        iYOff = doc.sgData.getSize()-1;
+    }
+
+    void setHeaderRow( bool bOn )
+    {
+        if( bHeaderRow == bOn )
+            return;
+
+        bHeaderRow = bOn;
+        move( 0, ((bOn)?(1):(-1)) );
+    }
+
+    void toggleHeaderRow()
+    {
+        setHeaderRow( !bHeaderRow );
+    }
+
+    Bu::String prompt( const Bu::String &sPrompt )
+    {
+        int maxx, maxy;
+        Bu::String sStr;
+
+        RegEx re( sPrompt );
+
+        curs_set( 1 );
+        for(;;)
+        {
+            getmaxyx( stdscr, maxy, maxx );
+            for( int j = 0; j < maxx; j++ )
+            {
+                mvaddch( maxy-1, j, ' ' );
+            }
+            mvaddstr( maxy-1, 0, sPrompt.getStr() );
+
+            mvaddstr( maxy-1, sPrompt.getSize(), sStr.getStr() );
+
+            int iCh = getch();
+            switch( iCh )
+            {
+                case '\n':
+                case '\r':
+                case KEY_ENTER:
+                    curs_set( 0 );
+                    return sStr;
+                    break;
+
+                case KEY_BACKSPACE:
+                    if( sStr.getSize() > 0 )
+                        sStr.resize( sStr.getSize()-1 );
+                    break;
+
+                default:
+                    if( iCh < 127 )
+                        sStr += (char)iCh;
+                    break;
+            }
+        }
+    }
+
+    void resetCaret()
+    {
+        sysCaret.reset();
+    }
+
+    void findNext( const Bu::String &sTerm )
+    {
+        RegEx re( sTerm );
+
+        int y = sysCaret.iRow;
+        if( y < 0 )
+            y = 0;
+        int x = sysCaret.iCol+1;
+        for( ; y < doc.sgData.getSize(); y++ )
+        {
+            StrArray &aRow = doc.sgData[y];
+            for( ; x < aRow.getSize(); x++ )
+            {
+                if( re.execute( aRow[x] ) ) //aRow[x].find( sTerm ) )
+                {
+                    sysCaret.iRow = y;
+                    sysCaret.iCol = x;
+                    scrollToCaret();
+                    return;
+                }
+            }
+            x = 0;
+        }
+    }
+
+    void scrollToCaret()
+    {
+        iXOff = sysCaret.iCol;
+        iYOff = sysCaret.iRow;
+    }
+
+    CsvDoc &doc;
+    int iXOff;
+    int iYOff;
+    bool bHeaderRow;
+
+    class Caret
+    {
+    public:
+        Caret() :
+            iRow( -1 ),
+            iCol( -1 )
+        {
+        }
+
+        virtual ~Caret()
+        {
+        }
+
+
+        void reset()
+        {
+            iRow = iCol = -1;
+        }
+
+        bool isSet()
+        {
+            if( iRow < 0 || iCol < 0 )
+                return false;
+            return true;
+        }
+
+        int iRow;
+        int iCol;
+    };
+
+    Caret sysCaret;
 };
 
 int main( int argc, char *argv[] )
 {
-        Options opt( argc, argv );
-
-        if( !opt.sFileIn.isSet() )
-        {
-                sio << "No file specified." << sio.nl;
-                return 1;
-        }
-
-        CsvDoc doc;
-        {
-                File fIn( opt.sFileIn, File::Read );
-                NewLine nlIn( fIn );
-                Buffer bIn( nlIn );
-                CsvReader cr( bIn );
-
-                while( !fIn.isEos() )
-                {
-                        StrArray sa = cr.readLine();
-                        if( fIn.isEos() )
-                                break;
-                        doc.addRow( sa );
-                }
-        }
-
-        initscr();
-        cbreak();
-        noecho();
-        nonl();
-        intrflush( stdscr, FALSE );
-        keypad( stdscr, TRUE ); 
-        curs_set( 0 );
-
-        CsvView view( doc );
-        view.setHeaderRow( opt.bHeader );
-
-        Bu::String sSearchTerm;
-
-        bool bRun = true;
-        do
-        {
-                view.render();
-
-                int ch = getch();
-                switch( ch )
-                {
-                        case 'q':
-                                bRun = false;
-                                break;
-
-                        case KEY_DOWN:
-                                view.move( 0, 1 );
-                                break;
-
-                        case KEY_UP:
-                                view.move( 0, -1 );
-                                break;
-
-                        case KEY_LEFT:
-                                view.move( -1, 0 );
-                                break;
-
-                        case KEY_RIGHT:
-                                view.move( 1, 0 );
-                                break;
-
-                        case KEY_NPAGE:
-                                view.pageDown();
-                                break;
-
-                        case KEY_PPAGE:
-                                view.pageUp();
-                                break;
-
-                        case KEY_HOME:
-                                view.home();
-                                break;
-
-                        case KEY_END:
-                                view.end();
-                                break;
-
-                        case '/':
-                                sSearchTerm = view.prompt("find: ");
-                                view.resetCaret();
-                                view.findNext( sSearchTerm );
-                                break;
-
-                        case 'n':
-                                view.findNext( sSearchTerm );
-                                break;
-
-                        case 'h':
-                                view.toggleHeaderRow();
-                                break;
-                }
-        } while( bRun );
-
-        endwin();
-
-        return 0;
+    Options opt( argc, argv );
+
+    if( !opt.sFileIn.isSet() )
+    {
+        sio << "No file specified." << sio.nl;
+        return 1;
+    }
+
+    CsvDoc doc;
+    {
+        File fIn( opt.sFileIn, File::Read );
+        NewLine nlIn( fIn );
+        Buffer bIn( nlIn );
+        CsvReader cr( bIn );
+
+        while( !fIn.isEos() )
+        {
+            StrArray sa = cr.readLine();
+            if( fIn.isEos() )
+                break;
+            doc.addRow( sa );
+        }
+    }
+
+    initscr();
+    cbreak();
+    noecho();
+    nonl();
+    intrflush( stdscr, FALSE );
+    keypad( stdscr, TRUE ); 
+    curs_set( 0 );
+
+    CsvView view( doc );
+    view.setHeaderRow( opt.bHeader );
+
+    Bu::String sSearchTerm;
+
+    bool bRun = true;
+    do
+    {
+        view.render();
+
+        int ch = getch();
+        switch( ch )
+        {
+            case 'q':
+                bRun = false;
+                break;
+
+            case KEY_DOWN:
+                view.move( 0, 1 );
+                break;
+
+            case KEY_UP:
+                view.move( 0, -1 );
+                break;
+
+            case KEY_LEFT:
+                view.move( -1, 0 );
+                break;
+
+            case KEY_RIGHT:
+                view.move( 1, 0 );
+                break;
+
+            case KEY_NPAGE:
+                view.pageDown();
+                break;
+
+            case KEY_PPAGE:
+                view.pageUp();
+                break;
+
+            case KEY_HOME:
+                view.home();
+                break;
+
+            case KEY_END:
+                view.end();
+                break;
+
+            case '/':
+                sSearchTerm = view.prompt("find: ");
+                view.resetCaret();
+                view.findNext( sSearchTerm );
+                break;
+
+            case 'n':
+                view.findNext( sSearchTerm );
+                break;
+
+            case 'h':
+                view.toggleHeaderRow();
+                break;
+        }
+    } while( bRun );
+
+    endwin();
+
+    return 0;
 }
 
diff --git a/src/unit/archive.unit b/src/unit/archive.unit
index 359f380..d0427a5 100644
--- a/src/unit/archive.unit
+++ b/src/unit/archive.unit
@@ -14,183 +14,183 @@ using namespace Bu;
 
 suite Archive
 {
-        test primitives
-        {
-                MemBuf mb;
-                {
-                        Archive ar( mb, Archive::save );
-                        ar << (int8_t)1;
-                        ar << (uint8_t)2;
-                        ar << (int16_t)3;
-                        ar << (uint16_t)4;
-                        ar << (int32_t)5;
-                        ar << (uint32_t)6;
-                        ar << (int64_t)7;
-                        ar << (uint64_t)8;
-                        ar << (char)9;
-                        ar << (unsigned char)10;
-                        ar << (short)11;
-                        ar << (unsigned short)12;
-                        ar << (int)13;
-                        ar << (unsigned int)14;
-                        ar << (long)15;
-                        ar << (unsigned long)16;
-                        ar << (long long)17;
-                        ar << (unsigned long long)18;
-                        ar.close();
-                }
-                mb.setPos( 0 );
-                {
-                        Archive ar( mb, Archive::load );
-                        int8_t p1;
-                        uint8_t p2;
-                        int16_t p3;
-                        uint16_t p4;
-                        int32_t p5;
-                        uint32_t p6;
-                        int64_t p7;
-                        uint64_t p8;
-                        char p9;
-                        unsigned char p10;
-                        short p11;
-                        unsigned short p12;
-                        int p13;
-                        unsigned int p14;
-                        long p15;
-                        unsigned long p16;
-                        long long p17;
-                        unsigned long long p18;
-                        ar >> p1;
-                        ar >> p2;
-                        ar >> p3;
-                        ar >> p4;
-                        ar >> p5;
-                        ar >> p6;
-                        ar >> p7;
-                        ar >> p8;
-                        ar >> p9;
-                        ar >> p10;
-                        ar >> p11;
-                        ar >> p12;
-                        ar >> p13;
-                        ar >> p14;
-                        ar >> p15;
-                        ar >> p16;
-                        ar >> p17;
-                        ar >> p18;
-                        unitTest( p1 == 1 );
-                        unitTest( p2 == 2 );
-                        unitTest( p3 == 3 );
-                        unitTest( p4 == 4 );
-                        unitTest( p5 == 5 );
-                        unitTest( p6 == 6 );
-                        unitTest( p7 == 7 );
-                        unitTest( p8 == 8 );
-                        unitTest( p9 == 9 );
-                        unitTest( p10 == 10 );
-                        unitTest( p11 == 11 );
-                        unitTest( p12 == 12 );
-                        unitTest( p13 == 13 );
-                        unitTest( p14 == 14 );
-                        unitTest( p15 == 15 );
-                        unitTest( p16 == 16 );
-                        unitTest( p17 == 17 );
-                        unitTest( p18 == 18 );
-                        ar.close();
-                }
-        }
+    test primitives
+    {
+        MemBuf mb;
+        {
+            Archive ar( mb, Archive::save );
+            ar << (int8_t)1;
+            ar << (uint8_t)2;
+            ar << (int16_t)3;
+            ar << (uint16_t)4;
+            ar << (int32_t)5;
+            ar << (uint32_t)6;
+            ar << (int64_t)7;
+            ar << (uint64_t)8;
+            ar << (char)9;
+            ar << (unsigned char)10;
+            ar << (short)11;
+            ar << (unsigned short)12;
+            ar << (int)13;
+            ar << (unsigned int)14;
+            ar << (long)15;
+            ar << (unsigned long)16;
+            ar << (long long)17;
+            ar << (unsigned long long)18;
+            ar.close();
+        }
+        mb.setPos( 0 );
+        {
+            Archive ar( mb, Archive::load );
+            int8_t p1;
+            uint8_t p2;
+            int16_t p3;
+            uint16_t p4;
+            int32_t p5;
+            uint32_t p6;
+            int64_t p7;
+            uint64_t p8;
+            char p9;
+            unsigned char p10;
+            short p11;
+            unsigned short p12;
+            int p13;
+            unsigned int p14;
+            long p15;
+            unsigned long p16;
+            long long p17;
+            unsigned long long p18;
+            ar >> p1;
+            ar >> p2;
+            ar >> p3;
+            ar >> p4;
+            ar >> p5;
+            ar >> p6;
+            ar >> p7;
+            ar >> p8;
+            ar >> p9;
+            ar >> p10;
+            ar >> p11;
+            ar >> p12;
+            ar >> p13;
+            ar >> p14;
+            ar >> p15;
+            ar >> p16;
+            ar >> p17;
+            ar >> p18;
+            unitTest( p1 == 1 );
+            unitTest( p2 == 2 );
+            unitTest( p3 == 3 );
+            unitTest( p4 == 4 );
+            unitTest( p5 == 5 );
+            unitTest( p6 == 6 );
+            unitTest( p7 == 7 );
+            unitTest( p8 == 8 );
+            unitTest( p9 == 9 );
+            unitTest( p10 == 10 );
+            unitTest( p11 == 11 );
+            unitTest( p12 == 12 );
+            unitTest( p13 == 13 );
+            unitTest( p14 == 14 );
+            unitTest( p15 == 15 );
+            unitTest( p16 == 16 );
+            unitTest( p17 == 17 );
+            unitTest( p18 == 18 );
+            ar.close();
+        }
+    }
 
-        test containers1
-        {
-                MemBuf mb;
-                {
-                        Archive ar( mb, Archive::save );
-                        String sStr("This is a test string.");
-                        List<int> lList;
-                        lList.append( 10 );
-                        lList.append( 20 );
-                        lList.append( 30 );
-                        lList.append( 40 );
-                        ar << sStr;
-                        ar << lList;
-                        ar.close();
-                }
-                mb.setPos( 0 );
-                {
-                        Archive ar( mb, Archive::load );
-                        String sStr;
-                        List<int> lList;
-                        ar >> sStr;
-                        ar >> lList;
-                        unitTest( sStr == "This is a test string." );
-                        unitTest( lList.getSize() == 4 );
-                        List<int>::iterator i = lList.begin();
-                        unitTest( *i == 10 ); i++;
-                        unitTest( *i == 20 ); i++;
-                        unitTest( *i == 30 ); i++;
-                        unitTest( *i == 40 );
-                        ar.close();
-                }
-        }
+    test containers1
+    {
+        MemBuf mb;
+        {
+            Archive ar( mb, Archive::save );
+            String sStr("This is a test string.");
+            List<int> lList;
+            lList.append( 10 );
+            lList.append( 20 );
+            lList.append( 30 );
+            lList.append( 40 );
+            ar << sStr;
+            ar << lList;
+            ar.close();
+        }
+        mb.setPos( 0 );
+        {
+            Archive ar( mb, Archive::load );
+            String sStr;
+            List<int> lList;
+            ar >> sStr;
+            ar >> lList;
+            unitTest( sStr == "This is a test string." );
+            unitTest( lList.getSize() == 4 );
+            List<int>::iterator i = lList.begin();
+            unitTest( *i == 10 ); i++;
+            unitTest( *i == 20 ); i++;
+            unitTest( *i == 30 ); i++;
+            unitTest( *i == 40 );
+            ar.close();
+        }
+    }
 
-        test containers2
-        {
-                MemBuf mb;
-                {
-                        Archive ar( mb, Archive::save );
-                        String sStr("This is a test string.");
-                        Array<int> lArray;
-                        lArray.append( 10 );
-                        lArray.append( 20 );
-                        lArray.append( 30 );
-                        lArray.append( 40 );
-                        ar << sStr;
-                        ar << lArray;
-                        ar.close();
-                }
-                mb.setPos( 0 );
-                {
-                        Archive ar( mb, Archive::load );
-                        String sStr;
-                        Array<int> lArray;
-                        ar >> sStr;
-                        ar >> lArray;
-                        unitTest( sStr == "This is a test string." );
-                        unitTest( lArray.getSize() == 4 );
-                        Array<int>::iterator i = lArray.begin();
-                        unitTest( *i == 10 ); i++;
-                        unitTest( *i == 20 ); i++;
-                        unitTest( *i == 30 ); i++;
-                        unitTest( *i == 40 );
-                        ar.close();
-                }
-        }
+    test containers2
+    {
+        MemBuf mb;
+        {
+            Archive ar( mb, Archive::save );
+            String sStr("This is a test string.");
+            Array<int> lArray;
+            lArray.append( 10 );
+            lArray.append( 20 );
+            lArray.append( 30 );
+            lArray.append( 40 );
+            ar << sStr;
+            ar << lArray;
+            ar.close();
+        }
+        mb.setPos( 0 );
+        {
+            Archive ar( mb, Archive::load );
+            String sStr;
+            Array<int> lArray;
+            ar >> sStr;
+            ar >> lArray;
+            unitTest( sStr == "This is a test string." );
+            unitTest( lArray.getSize() == 4 );
+            Array<int>::iterator i = lArray.begin();
+            unitTest( *i == 10 ); i++;
+            unitTest( *i == 20 ); i++;
+            unitTest( *i == 30 ); i++;
+            unitTest( *i == 40 );
+            ar.close();
+        }
+    }
 
-        test containers3
-        {
-                MemBuf mb;
-                {
-                        Archive ar( mb, Archive::save );
-                        Array<String> lArray;
-                        lArray.append( "10" );
-                        lArray.append( "20" );
-                        lArray.append( "30" );
-                        lArray.append( "40" );
-                        ar << lArray;
-                        ar.close();
-                }
-                mb.setPos( 0 );
-                {
-                        Archive ar( mb, Archive::load );
-                        Array<String> lArray;
-                        ar >> lArray;
-                        unitTest( lArray.getSize() == 4 );
-                        Array<String>::iterator i = lArray.begin();
-                        unitTest( *i == "10" ); i++;
-                        unitTest( *i == "20" ); i++;
-                        unitTest( *i == "30" ); i++;
-                        unitTest( *i == "40" );
-                        ar.close();
-                }
-        }
+    test containers3
+    {
+        MemBuf mb;
+        {
+            Archive ar( mb, Archive::save );
+            Array<String> lArray;
+            lArray.append( "10" );
+            lArray.append( "20" );
+            lArray.append( "30" );
+            lArray.append( "40" );
+            ar << lArray;
+            ar.close();
+        }
+        mb.setPos( 0 );
+        {
+            Archive ar( mb, Archive::load );
+            Array<String> lArray;
+            ar >> lArray;
+            unitTest( lArray.getSize() == 4 );
+            Array<String>::iterator i = lArray.begin();
+            unitTest( *i == "10" ); i++;
+            unitTest( *i == "20" ); i++;
+            unitTest( *i == "30" ); i++;
+            unitTest( *i == "40" );
+            ar.close();
+        }
+    }
 }
diff --git a/src/unit/array.unit b/src/unit/array.unit
index 6e985d8..ca85b4d 100644
--- a/src/unit/array.unit
+++ b/src/unit/array.unit
@@ -14,91 +14,91 @@ using Bu::sio;
 
 suite Array
 {
-        test general
-        {
-                Bu::Array<int> ai;
-
-                ai.append( 5 );
-                ai.append( 10 );
-                unitTest( ai.getSize() == 2 );
-                unitTest( ai.getCapacity() == 10 );
-                unitTest( ai[0] == 5 );
-                unitTest( ai[1] == 10 );
-        }
-
-        test iterate1
-        {
-                Bu::Array<int> ai;
-                for( int j = 0; j < 10; j++ )
-                        ai.append( j );
-
-                int j = 0;
-                for( Bu::Array<int>::iterator i = ai.begin(); i != ai.end(); i++ )
-                        unitTest( (*i) == j++ );
-                unitTest( j == 10 );
-                
-                const Bu::Array<int> &ci = ai;
-                j = 0;
-                for( Bu::Array<int>::const_iterator i = ci.begin(); i; i++ )
-                        unitTest( (*i) == j++ );
-                unitTest( j == 10 );
-        }
-
-        test iterate2
-        {
-                Bu::Array<int> ai;
-                for( Bu::Array<int>::iterator i = ai.begin(); i != ai.end(); i++ )
-                        unitFailed("Empty lists shouldn't be iterated through.");
-                for( Bu::Array<int>::iterator i = ai.begin(); i; i++ )
-                        unitFailed("Empty lists shouldn't be iterated through.");
-        }
-
-        test copy
-        {
-                typedef Bu::Hash<Bu::String, Bu::String> StrHash;
-                typedef Bu::Array<StrHash> StrHashArray;
-
-                StrHash h1;
-                h1["Hi"] = "Yo";
-                h1["Bye"] = "Later";
-
-                StrHash h2;
-                h2["Test"] = "Bloop";
-                h2["Foo"] = "ooF";
-
-                StrHashArray a1;
-                a1.append( h1 );
-                a1.append( h2 );
-
-                StrHashArray a2(a1);
-
-                unitTest( a2[0].get("Hi") == "Yo" );
-                unitTest( a2[0].get("Bye") == "Later" );
-                unitTest( a2[1].get("Test") == "Bloop" );
-                unitTest( a2[1].get("Foo") == "ooF" );
-
-                StrHashArray a3;
-                a3 = a1;
-                
-                unitTest( a3[0].get("Hi") == "Yo" );
-                unitTest( a3[0].get("Bye") == "Later" );
-                unitTest( a3[1].get("Test") == "Bloop" );
-                unitTest( a3[1].get("Foo") == "ooF" );
-        }
-
-        test insert
-        {
-                Bu::Array<int> aInts;
-                aInts.insert( aInts.end(), 4 );
-                aInts.insert( aInts.begin(), 1 );
-                aInts.insert( aInts.end(), 5 );
-                aInts.insert( aInts.begin()+1, 3 );
-                aInts.insert( aInts.begin()+1, 2 );
-                aInts.insert( aInts.begin(), 0 );
-
-                for( int j = 0; j < 6; j++ )
-                {
-                        unitTest( aInts[j] == j );
-                }
-        }
+    test general
+    {
+        Bu::Array<int> ai;
+
+        ai.append( 5 );
+        ai.append( 10 );
+        unitTest( ai.getSize() == 2 );
+        unitTest( ai.getCapacity() == 10 );
+        unitTest( ai[0] == 5 );
+        unitTest( ai[1] == 10 );
+    }
+
+    test iterate1
+    {
+        Bu::Array<int> ai;
+        for( int j = 0; j < 10; j++ )
+            ai.append( j );
+
+        int j = 0;
+        for( Bu::Array<int>::iterator i = ai.begin(); i != ai.end(); i++ )
+            unitTest( (*i) == j++ );
+        unitTest( j == 10 );
+        
+        const Bu::Array<int> &ci = ai;
+        j = 0;
+        for( Bu::Array<int>::const_iterator i = ci.begin(); i; i++ )
+            unitTest( (*i) == j++ );
+        unitTest( j == 10 );
+    }
+
+    test iterate2
+    {
+        Bu::Array<int> ai;
+        for( Bu::Array<int>::iterator i = ai.begin(); i != ai.end(); i++ )
+            unitFailed("Empty lists shouldn't be iterated through.");
+        for( Bu::Array<int>::iterator i = ai.begin(); i; i++ )
+            unitFailed("Empty lists shouldn't be iterated through.");
+    }
+
+    test copy
+    {
+        typedef Bu::Hash<Bu::String, Bu::String> StrHash;
+        typedef Bu::Array<StrHash> StrHashArray;
+
+        StrHash h1;
+        h1["Hi"] = "Yo";
+        h1["Bye"] = "Later";
+
+        StrHash h2;
+        h2["Test"] = "Bloop";
+        h2["Foo"] = "ooF";
+
+        StrHashArray a1;
+        a1.append( h1 );
+        a1.append( h2 );
+
+        StrHashArray a2(a1);
+
+        unitTest( a2[0].get("Hi") == "Yo" );
+        unitTest( a2[0].get("Bye") == "Later" );
+        unitTest( a2[1].get("Test") == "Bloop" );
+        unitTest( a2[1].get("Foo") == "ooF" );
+
+        StrHashArray a3;
+        a3 = a1;
+        
+        unitTest( a3[0].get("Hi") == "Yo" );
+        unitTest( a3[0].get("Bye") == "Later" );
+        unitTest( a3[1].get("Test") == "Bloop" );
+        unitTest( a3[1].get("Foo") == "ooF" );
+    }
+
+    test insert
+    {
+        Bu::Array<int> aInts;
+        aInts.insert( aInts.end(), 4 );
+        aInts.insert( aInts.begin(), 1 );
+        aInts.insert( aInts.end(), 5 );
+        aInts.insert( aInts.begin()+1, 3 );
+        aInts.insert( aInts.begin()+1, 2 );
+        aInts.insert( aInts.begin(), 0 );
+
+        for( int j = 0; j < 6; j++ )
+        {
+            unitTest( aInts[j] == j );
+        }
+    }
 }
diff --git a/src/unit/base64.unit b/src/unit/base64.unit
index 5266b48..bd5bc97 100644
--- a/src/unit/base64.unit
+++ b/src/unit/base64.unit
@@ -11,18 +11,18 @@
 
 suite MemBuf
 {
-        test decode01
-        {
-                unitTest( Bu::decodeStr<Bu::Base64>("RnVu") == "Fun" );
-                unitTest( Bu::decodeStr<Bu::Base64>("V2hhdA==") == "What" );
-                unitTest( Bu::decodeStr<Bu::Base64>("SGVsbG8=") == "Hello" );
-        }
+    test decode01
+    {
+        unitTest( Bu::decodeStr<Bu::Base64>("RnVu") == "Fun" );
+        unitTest( Bu::decodeStr<Bu::Base64>("V2hhdA==") == "What" );
+        unitTest( Bu::decodeStr<Bu::Base64>("SGVsbG8=") == "Hello" );
+    }
 
-        test encode01
-        {
-                unitTest( Bu::decodeStr<Bu::Base64>("R n V  u") == "Fun" );
-                unitTest( Bu::decodeStr<Bu::Base64>("V2\n\n\thh   dA==") == "What" );
-                unitTest( Bu::decodeStr<Bu::Base64>("\n\n\t\t   SGV\r\ns\tbG8\n=") == "Hello" );
-        }
+    test encode01
+    {
+        unitTest( Bu::decodeStr<Bu::Base64>("R n V  u") == "Fun" );
+        unitTest( Bu::decodeStr<Bu::Base64>("V2\n\n\thh   dA==") == "What" );
+        unitTest( Bu::decodeStr<Bu::Base64>("\n\n\t\t   SGV\r\ns\tbG8\n=") == "Hello" );
+    }
 }
 
diff --git a/src/unit/blowfish.unit b/src/unit/blowfish.unit
index abab63d..1b4ca18 100644
--- a/src/unit/blowfish.unit
+++ b/src/unit/blowfish.unit
@@ -50,29 +50,29 @@ static const char *testdat[34][3] ={
 
 suite Blowfish
 {
-        test standard
-        {
-                for( int j = 0; j < 34; j++ )
-                {
-                        Bu::MemBuf mb;
-                        Bu::BlowfishEcb bf( mb );
-                        bf.setPassword( Bu::decodeStr<Bu::Hex>( testdat[j][0] ) );
-                        bf.write( Bu::decodeStr<Bu::Hex>( testdat[j][1] ) );
-                        unitTest(
-                                mb.getString() == Bu::decodeStr<Bu::Hex>( testdat[j][2] )
-                                );
+    test standard
+    {
+        for( int j = 0; j < 34; j++ )
+        {
+            Bu::MemBuf mb;
+            Bu::BlowfishEcb bf( mb );
+            bf.setPassword( Bu::decodeStr<Bu::Hex>( testdat[j][0] ) );
+            bf.write( Bu::decodeStr<Bu::Hex>( testdat[j][1] ) );
+            unitTest(
+                mb.getString() == Bu::decodeStr<Bu::Hex>( testdat[j][2] )
+                );
 
-                        mb.setPos( 0 );
-                        Bu::BlowfishEcb bf2( mb );
-                        bf2.setPassword( Bu::decodeStr<Bu::Hex>( testdat[j][0] ) );
-                        char buf[8];
-                        bf2.read( buf, 8 );
+            mb.setPos( 0 );
+            Bu::BlowfishEcb bf2( mb );
+            bf2.setPassword( Bu::decodeStr<Bu::Hex>( testdat[j][0] ) );
+            char buf[8];
+            bf2.read( buf, 8 );
 
-                        unitTest(
-                                Bu::String(testdat[j][1]) ==
-                                        Bu::encodeStr<Bu::Hex>(Bu::String(buf,8),true)
-                                );
-                }
-        }
+            unitTest(
+                Bu::String(testdat[j][1]) ==
+                    Bu::encodeStr<Bu::Hex>(Bu::String(buf,8),true)
+                );
+        }
+    }
 }
 
diff --git a/src/unit/buffer.unit b/src/unit/buffer.unit
index 8bfdc3d..8613c5b 100644
--- a/src/unit/buffer.unit
+++ b/src/unit/buffer.unit
@@ -12,16 +12,16 @@
 
 suite Buffer
 {
-        test emptyFile
-        {
-                Bu::String sTmp("empty-XXXXXX");
-                Bu::File fEmpty = tempFile(sTmp);
-                Bu::Buffer buf( fEmpty );
+    test emptyFile
+    {
+        Bu::String sTmp("empty-XXXXXX");
+        Bu::File fEmpty = tempFile(sTmp);
+        Bu::Buffer buf( fEmpty );
 
-                unitTest( buf.isEos() == false );
-                Bu::String sLine = buf.readLine();
-                unitTest( sLine == "" );
-                unitTest( fEmpty.isEos() == true );
-                unitTest( buf.isEos() == true );
-        }
+        unitTest( buf.isEos() == false );
+        Bu::String sLine = buf.readLine();
+        unitTest( sLine == "" );
+        unitTest( fEmpty.isEos() == true );
+        unitTest( buf.isEos() == true );
+    }
 }
diff --git a/src/unit/file.unit b/src/unit/file.unit
index 7140d03..c0358ac 100644
--- a/src/unit/file.unit
+++ b/src/unit/file.unit
@@ -14,87 +14,87 @@
 
 suite File
 {
-        test writeFull
-        {
-                Bu::File sf("testfile1", Bu::File::WriteNew );
-                for( int c = 0; c < 256; c++ )
-                {
-                        unsigned char ch = (unsigned char)c;
-                        sf.write( &ch, 1 );
-                        unitTest( sf.tell() == c+1 );
-                }
-                //unitTest( sf.canRead() == false );
-                //unitTest( sf.canWrite() == true );
-                //unitTest( sf.canSeek() == true );
-                sf.close();
-                struct stat sdat;
-                stat("testfile1", &sdat );
-                unitTest( sdat.st_size == 256 );
-        }
+    test writeFull
+    {
+        Bu::File sf("testfile1", Bu::File::WriteNew );
+        for( int c = 0; c < 256; c++ )
+        {
+            unsigned char ch = (unsigned char)c;
+            sf.write( &ch, 1 );
+            unitTest( sf.tell() == c+1 );
+        }
+        //unitTest( sf.canRead() == false );
+        //unitTest( sf.canWrite() == true );
+        //unitTest( sf.canSeek() == true );
+        sf.close();
+        struct stat sdat;
+        stat("testfile1", &sdat );
+        unitTest( sdat.st_size == 256 );
+    }
 
-        test readBlocks
-        {
-                Bu::File sf("testfile1", Bu::File::Read );
-                unsigned char buf[50];
-                size_t total = 0;
-                for(;;)
-                {
-                        size_t s = sf.read( buf, 50 );
-                        for( size_t c = 0; c < s; c++ )
-                        {
-                                unitTest( buf[c] == (unsigned char)(c+total) );
-                        }
-                        total += s;
-                        if( s < 50 )
-                        {
-                                unitTest( total == 256 );
-                                unitTest( sf.isEos() == false );
-                                unitTest( sf.read( buf, 1 ) == 0 );
-                                unitTest( sf.isEos() == true );
-                                // EOS is only set when an attempt to read past the end of
-                                // the stream is made, not when a short block is returned.
-                                break;
-                        }
-                }
-                sf.close();
-        }
+    test readBlocks
+    {
+        Bu::File sf("testfile1", Bu::File::Read );
+        unsigned char buf[50];
+        size_t total = 0;
+        for(;;)
+        {
+            size_t s = sf.read( buf, 50 );
+            for( size_t c = 0; c < s; c++ )
+            {
+                unitTest( buf[c] == (unsigned char)(c+total) );
+            }
+            total += s;
+            if( s < 50 )
+            {
+                unitTest( total == 256 );
+                unitTest( sf.isEos() == false );
+                unitTest( sf.read( buf, 1 ) == 0 );
+                unitTest( sf.isEos() == true );
+                // EOS is only set when an attempt to read past the end of
+                // the stream is made, not when a short block is returned.
+                break;
+            }
+        }
+        sf.close();
+    }
 
-        test readError1
-        {
-                try
-                {
-                        Bu::File sf("doesn'texist", Bu::File::Read );
-                        unitFailed("No exception thrown");
-                }
-                catch( Bu::FileException &e )
-                {
-                        return;
-                }
-        }
+    test readError1
+    {
+        try
+        {
+            Bu::File sf("doesn'texist", Bu::File::Read );
+            unitFailed("No exception thrown");
+        }
+        catch( Bu::FileException &e )
+        {
+            return;
+        }
+    }
 
-        test readError2
-        {
-                Bu::File sf("testfile1", Bu::File::Read );
-                char buf[256];
-                int r = sf.read( buf, 256 );
-                unitTest( r == 256 );
-                // You have to read past the end to set the EOS flag.
-                unitTest( sf.isEos() == false );
-                try
-                {
-                        if( sf.read( buf, 5 ) > 0 )
-                        {
-                                unitFailed("Non-zero read result");
-                        }
-                        else
-                        {
-                                sf.close();
-                        }
-                }
-                catch( Bu::FileException &e )
-                {
-                        sf.close();
-                        return;
-                }
-        }
+    test readError2
+    {
+        Bu::File sf("testfile1", Bu::File::Read );
+        char buf[256];
+        int r = sf.read( buf, 256 );
+        unitTest( r == 256 );
+        // You have to read past the end to set the EOS flag.
+        unitTest( sf.isEos() == false );
+        try
+        {
+            if( sf.read( buf, 5 ) > 0 )
+            {
+                unitFailed("Non-zero read result");
+            }
+            else
+            {
+                sf.close();
+            }
+        }
+        catch( Bu::FileException &e )
+        {
+            sf.close();
+            return;
+        }
+    }
 }
diff --git a/src/unit/hash.unit b/src/unit/hash.unit
index 3abc6a5..e30c62b 100644
--- a/src/unit/hash.unit
+++ b/src/unit/hash.unit
@@ -19,193 +19,193 @@ typedef Bu::Hash<int, Bu::String> IntStrHash;
 
 suite Hash
 {
-        test probe1
-        {
-                StrIntHash h;
-                char buf[20];
-                for(int i=1;i<10000;i++)
-                {
-                        sprintf(buf,"%d",i);
-                        Bu::String sTmp(buf);
-                        h[sTmp] = i;
-                        unitTest( h.has(sTmp) );
-                }
-        }
-
-        test insert1
-        {
-                StrIntHash h;
-                h["Hi"] = 42;
-                unitTest( h["Hi"] == 42 );
-        }
-
-        test insert2
-        {
-                StrStrHash h;
-                h["Hi"] = "Yo";
-                h["Bye"] = "Later";
-                unitTest( h["Hi"].getValue() == "Yo" );
-
-                StrStrHash h2(h);
-                unitTest( h2["Hi"].getValue() == "Yo" );
-                unitTest( h2["Bye"].getValue() == "Later" );
-
-                StrStrHash h3;
-                h3 = h;
-                unitTest( h3["Hi"].getValue() == "Yo" );
-                unitTest( h3["Bye"].getValue() == "Later" );
-        }
-
-        test insert3
-        {
-                IntStrHash h;
-
-                for( unsigned int i=1; i<50; i++ )
-                {
-                        h[i] = "testing";
-                        unitTest( h.getSize() == i );
-                }
-        }
-
-        test erase1
-        {
-                StrIntHash h;
-                h.insert("Number 1", 1 );
-                h.insert("Number 2", 2 );
-                h.insert("Number 3", 3 );
-                h.erase("Number 2");
-                h.get("Number 3");
-                try {
-                        h.get("Number 2");
-                        unitFailed("h.get(\"Number 2\") should have thrown an exception.");
-                } catch( Bu::HashException &e ) { }
-
-        /*      printf("\n");
-                for( StrIntHash::iterator i = h.begin(); i != h.end(); i++ )
-                {
-                        printf(" - \"%s\" = %d\n", i.getKey().getStr(), i.getValue() );
-                } */
-        }
-
-        test copy
-        {
-                StrIntHash h;
-                h.insert("hello", 55 );
-                h.insert("goodbye", -1812 );
-
-                StrIntHash h2 = h;
-                unitTest( h2.isCoreShared( h ) );
-
-                StrIntHash h3 = h.clone();
-                unitTest( !h3.isCoreShared( h ) );
-        }
-
-        test reHashSpecial
-        {
-                IntStrHash hTest;
-
-                setStepCount( 1000000 );
-                for( int i=0; i<1000000; ++i )
-                {
-                        char buf[40]; snprintf(buf,40,"num%d",i);
-                        incProgress();
-
-                        if( ((double)random()/(double)RAND_MAX)<.01 )
-                        {
-                                //printf("ERASE: %d (%s)\n",i%64,buf);
-                                hTest.erase(i%64);
-                        }
-                        else
-                        {
-                                hTest[i%64]=buf;
-                        }
-
-                        /*printf("(%d) size: %u fill: %u cap:%u\n",
-                                i,
-                                hTest.getSize(),
-                                hTest.getFill(),
-                                hTest.getCapacity()
-                                );*/
-                }
-        }
-
-        test stress
-        {
-                srandom(time(NULL));
-
-                IntStrHash hTest;
-                IntStrHash hReUse;
-                setStepCount( 100000 );
-
-                for( int i=0; i<100000; ++i )
-                {
-                        char buf[40]; snprintf(buf,40,"num%d",i);
-                        hTest[i] = buf;
-                        incProgress();
-
-                        
-                        if( ((double)random()/(double)RAND_MAX)<.01 )
-                        {
-                                Bu::List<int> lKeys = hReUse.getKeys();
-                                Bu::List<int>::const_iterator it = lKeys.begin();
-                                int iIdx = (int)(((double)random()/(double)RAND_MAX)
-                                        *lKeys.getSize());
-                                for( int l=0; it; ++it, ++l )
-                                {
-                                        if( l==iIdx )
-                                        {
-                                                int iVal = *it;
-                                                hReUse.erase( *it );
-                                                char buf[40]; snprintf(buf,40,"num%d",iVal);
-                                                hTest[i] = buf;
-                                                //printf("re-use: %s\n",buf);
-                                        }
-                                }
-                        }
-
-                        /*printf("(%s) size: %u fill: %u cap:%u\n",
-                                buf,
-                                hTest.getSize(),
-                                hTest.getFill(),
-                                hTest.getCapacity()
-                                );*/
-
-                        if( ((double)random()/(double)RAND_MAX)<.3 )
-                        {
-                                Bu::List<int> lKeys = hTest.getKeys();
-                                int iIdx = (int)(((double)random()/(double)RAND_MAX)
-                                        *lKeys.getSize());
-                                Bu::List<int>::const_iterator it = lKeys.begin();
-                                for( int k=0; it; ++it, ++k )
-                                {
-                                        if( k == iIdx )
-                                        {
-                                                hReUse.insert(*it,"yo");
-                                                hTest.erase( *it );
-                                        }
-                                }
-                        }
-
-                        if( hTest.getSize() > 100 )
-                        {
-                                int iK = (int)(((double)random()/(double)RAND_MAX)*50)+10;
-                                for( int j=0; j<iK; ++j )
-                                {
-                                        Bu::List<int> lKeys = hTest.getKeys();
-                                        int iIdx = (int)(((double)random()/(double)RAND_MAX)
-                                                *lKeys.getSize());
-                                        Bu::List<int>::const_iterator it = lKeys.begin();
-                                        for( int k=0; it; ++it, ++k )
-                                        {
-                                                if( k == iIdx )
-                                                {
-                                                        hReUse.insert(*it,"yo");
-                                                        hTest.erase( *it );
-                                                        break;
-                                                }
-                                        }
-                                }
-                        }
-                }
-        }
+    test probe1
+    {
+        StrIntHash h;
+        char buf[20];
+        for(int i=1;i<10000;i++)
+        {
+            sprintf(buf,"%d",i);
+            Bu::String sTmp(buf);
+            h[sTmp] = i;
+            unitTest( h.has(sTmp) );
+        }
+    }
+
+    test insert1
+    {
+        StrIntHash h;
+        h["Hi"] = 42;
+        unitTest( h["Hi"] == 42 );
+    }
+
+    test insert2
+    {
+        StrStrHash h;
+        h["Hi"] = "Yo";
+        h["Bye"] = "Later";
+        unitTest( h["Hi"].getValue() == "Yo" );
+
+        StrStrHash h2(h);
+        unitTest( h2["Hi"].getValue() == "Yo" );
+        unitTest( h2["Bye"].getValue() == "Later" );
+
+        StrStrHash h3;
+        h3 = h;
+        unitTest( h3["Hi"].getValue() == "Yo" );
+        unitTest( h3["Bye"].getValue() == "Later" );
+    }
+
+    test insert3
+    {
+        IntStrHash h;
+
+        for( unsigned int i=1; i<50; i++ )
+        {
+            h[i] = "testing";
+            unitTest( h.getSize() == i );
+        }
+    }
+
+    test erase1
+    {
+        StrIntHash h;
+        h.insert("Number 1", 1 );
+        h.insert("Number 2", 2 );
+        h.insert("Number 3", 3 );
+        h.erase("Number 2");
+        h.get("Number 3");
+        try {
+            h.get("Number 2");
+            unitFailed("h.get(\"Number 2\") should have thrown an exception.");
+        } catch( Bu::HashException &e ) { }
+
+    /*  printf("\n");
+        for( StrIntHash::iterator i = h.begin(); i != h.end(); i++ )
+        {
+            printf(" - \"%s\" = %d\n", i.getKey().getStr(), i.getValue() );
+        } */
+    }
+
+    test copy
+    {
+        StrIntHash h;
+        h.insert("hello", 55 );
+        h.insert("goodbye", -1812 );
+
+        StrIntHash h2 = h;
+        unitTest( h2.isCoreShared( h ) );
+
+        StrIntHash h3 = h.clone();
+        unitTest( !h3.isCoreShared( h ) );
+    }
+
+    test reHashSpecial
+    {
+        IntStrHash hTest;
+
+        setStepCount( 1000000 );
+        for( int i=0; i<1000000; ++i )
+        {
+            char buf[40]; snprintf(buf,40,"num%d",i);
+            incProgress();
+
+            if( ((double)random()/(double)RAND_MAX)<.01 )
+            {
+                //printf("ERASE: %d (%s)\n",i%64,buf);
+                hTest.erase(i%64);
+            }
+            else
+            {
+                hTest[i%64]=buf;
+            }
+
+            /*printf("(%d) size: %u fill: %u cap:%u\n",
+                i,
+                hTest.getSize(),
+                hTest.getFill(),
+                hTest.getCapacity()
+                );*/
+        }
+    }
+
+    test stress
+    {
+        srandom(time(NULL));
+
+        IntStrHash hTest;
+        IntStrHash hReUse;
+        setStepCount( 100000 );
+
+        for( int i=0; i<100000; ++i )
+        {
+            char buf[40]; snprintf(buf,40,"num%d",i);
+            hTest[i] = buf;
+            incProgress();
+
+            
+            if( ((double)random()/(double)RAND_MAX)<.01 )
+            {
+                Bu::List<int> lKeys = hReUse.getKeys();
+                Bu::List<int>::const_iterator it = lKeys.begin();
+                int iIdx = (int)(((double)random()/(double)RAND_MAX)
+                    *lKeys.getSize());
+                for( int l=0; it; ++it, ++l )
+                {
+                    if( l==iIdx )
+                    {
+                        int iVal = *it;
+                        hReUse.erase( *it );
+                        char buf[40]; snprintf(buf,40,"num%d",iVal);
+                        hTest[i] = buf;
+                        //printf("re-use: %s\n",buf);
+                    }
+                }
+            }
+
+            /*printf("(%s) size: %u fill: %u cap:%u\n",
+                buf,
+                hTest.getSize(),
+                hTest.getFill(),
+                hTest.getCapacity()
+                );*/
+
+            if( ((double)random()/(double)RAND_MAX)<.3 )
+            {
+                Bu::List<int> lKeys = hTest.getKeys();
+                int iIdx = (int)(((double)random()/(double)RAND_MAX)
+                    *lKeys.getSize());
+                Bu::List<int>::const_iterator it = lKeys.begin();
+                for( int k=0; it; ++it, ++k )
+                {
+                    if( k == iIdx )
+                    {
+                        hReUse.insert(*it,"yo");
+                        hTest.erase( *it );
+                    }
+                }
+            }
+
+            if( hTest.getSize() > 100 )
+            {
+                int iK = (int)(((double)random()/(double)RAND_MAX)*50)+10;
+                for( int j=0; j<iK; ++j )
+                {
+                    Bu::List<int> lKeys = hTest.getKeys();
+                    int iIdx = (int)(((double)random()/(double)RAND_MAX)
+                        *lKeys.getSize());
+                    Bu::List<int>::const_iterator it = lKeys.begin();
+                    for( int k=0; it; ++it, ++k )
+                    {
+                        if( k == iIdx )
+                        {
+                            hReUse.insert(*it,"yo");
+                            hTest.erase( *it );
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/src/unit/list.unit b/src/unit/list.unit
index ec92fd5..0b60e43 100644
--- a/src/unit/list.unit
+++ b/src/unit/list.unit
@@ -13,136 +13,136 @@ typedef Bu::List<int> IntList;
 
 suite List
 {
-        test append
-        {
-                IntList lst;
-                for( int j = 0; j < 50; j++ )
-                {
-                        lst.append( j );
-                }
-                int j = 0;
-                for( IntList::iterator i = lst.begin(); i; i++, j++ )
-                {
-                        unitTest( *i == j );
-                }
-        }
-
-        test prepend
-        {
-                IntList lst;
-                for( int j = 0; j < 50; j++ )
-                {
-                        lst.prepend( j );
-                }
-                int j = 49;
-                for( IntList::iterator i = lst.begin(); i; i++, j-- )
-                {
-                        unitTest( *i == j );
-                }
-        }
-
-        test copy
-        {
-                IntList lst;
-                int j;
-                for( j = 0; j < 50; j++ )
-                {
-                        lst.append( j );
-                }
-                IntList lst2 = lst;
-
-                j = 0;
-                for( IntList::iterator i = lst2.begin(); i; i++, j++ )
-                {
-                        unitTest( *i == j );
-                }
-                lst2.clear();
-                lst2 = lst;
-
-                j = 0;
-                for( IntList::iterator i = lst2.begin(); i; i++, j++ )
-                {
-                        unitTest( *i == j );
-                }
-        }
-
-        test sort1
-        {
-                IntList lst;
-
-                lst.insertSorted( 5 );
-                lst.insertSorted( 1 );
-                lst.insertSorted( 10 );
-                lst.insertSorted( 3 );
-
-                unitTest( lst == IntList(1).append(3).append(5).append(10) );
-        }
-
-        test sort2
-        {
-                IntList lst;
-
-                lst.insertSorted<Bu::__basicGTCmp<int> >( 5 );
-                lst.insertSorted<Bu::__basicGTCmp<int> >( 1 );
-                lst.insertSorted<Bu::__basicGTCmp<int> >( 10 );
-                lst.insertSorted<Bu::__basicGTCmp<int> >( 3 );
-
-                unitTest( lst == IntList(10).append(5).append(3).append(1) );
-        }
-
-        test sort3
-        {
-                IntList lst;
-                Bu::__basicGTCmp<int> cmp;
-
-                lst.insertSorted( cmp, 5 );
-                lst.insertSorted( cmp, 1 );
-                lst.insertSorted( cmp, 10 );
-                lst.insertSorted( cmp, 3 );
-
-                unitTest( lst == IntList(10).append(5).append(3).append(1) );
-        }
-
-        test sort4
-        {
-                IntList lst;
-
-                lst.append( 5 );
-                lst.append( 1 );
-                lst.append( 10 );
-                lst.append( 3 );
-
-                lst.sort();
-
-                unitTest( lst == IntList(1).append(3).append(5).append(10) );
-        }
-
-        test sort5
-        {
-                IntList lst;
-
-                lst.append( 5 );
-                lst.append( 1 );
-                lst.append( 10 );
-                lst.append( 3 );
-
-                lst.sort<Bu::__basicGTCmp<int> >();
-
-                unitTest( lst == IntList(10).append(5).append(3).append(1) );
-        }
-
-        test sort6
-        {
-                IntList lst;
-
-                lst.append( 5 );
-                lst.append( 1 );
-                lst.append( 10 );
-                lst.append( 3 );
-
-                Bu::__basicGTCmp<int> x;
-                lst.sort( x );
-
-                unitTest( lst == IntList(10).append(5).append(3).append(1) );
-        }
+    test append
+    {
+        IntList lst;
+        for( int j = 0; j < 50; j++ )
+        {
+            lst.append( j );
+        }
+        int j = 0;
+        for( IntList::iterator i = lst.begin(); i; i++, j++ )
+        {
+            unitTest( *i == j );
+        }
+    }
+
+    test prepend
+    {
+        IntList lst;
+        for( int j = 0; j < 50; j++ )
+        {
+            lst.prepend( j );
+        }
+        int j = 49;
+        for( IntList::iterator i = lst.begin(); i; i++, j-- )
+        {
+            unitTest( *i == j );
+        }
+    }
+
+    test copy
+    {
+        IntList lst;
+        int j;
+        for( j = 0; j < 50; j++ )
+        {
+            lst.append( j );
+        }
+        IntList lst2 = lst;
+
+        j = 0;
+        for( IntList::iterator i = lst2.begin(); i; i++, j++ )
+        {
+            unitTest( *i == j );
+        }
+        lst2.clear();
+        lst2 = lst;
+
+        j = 0;
+        for( IntList::iterator i = lst2.begin(); i; i++, j++ )
+        {
+            unitTest( *i == j );
+        }
+    }
+
+    test sort1
+    {
+        IntList lst;
+
+        lst.insertSorted( 5 );
+        lst.insertSorted( 1 );
+        lst.insertSorted( 10 );
+        lst.insertSorted( 3 );
+
+        unitTest( lst == IntList(1).append(3).append(5).append(10) );
+    }
+
+    test sort2
+    {
+        IntList lst;
+
+        lst.insertSorted<Bu::__basicGTCmp<int> >( 5 );
+        lst.insertSorted<Bu::__basicGTCmp<int> >( 1 );
+        lst.insertSorted<Bu::__basicGTCmp<int> >( 10 );
+        lst.insertSorted<Bu::__basicGTCmp<int> >( 3 );
+
+        unitTest( lst == IntList(10).append(5).append(3).append(1) );
+    }
+
+    test sort3
+    {
+        IntList lst;
+        Bu::__basicGTCmp<int> cmp;
+
+        lst.insertSorted( cmp, 5 );
+        lst.insertSorted( cmp, 1 );
+        lst.insertSorted( cmp, 10 );
+        lst.insertSorted( cmp, 3 );
+
+        unitTest( lst == IntList(10).append(5).append(3).append(1) );
+    }
+
+    test sort4
+    {
+        IntList lst;
+
+        lst.append( 5 );
+        lst.append( 1 );
+        lst.append( 10 );
+        lst.append( 3 );
+
+        lst.sort();
+
+        unitTest( lst == IntList(1).append(3).append(5).append(10) );
+    }
+
+    test sort5
+    {
+        IntList lst;
+
+        lst.append( 5 );
+        lst.append( 1 );
+        lst.append( 10 );
+        lst.append( 3 );
+
+        lst.sort<Bu::__basicGTCmp<int> >();
+
+        unitTest( lst == IntList(10).append(5).append(3).append(1) );
+    }
+
+    test sort6
+    {
+        IntList lst;
+
+        lst.append( 5 );
+        lst.append( 1 );
+        lst.append( 10 );
+        lst.append( 3 );
+
+        Bu::__basicGTCmp<int> x;
+        lst.sort( x );
+
+        unitTest( lst == IntList(10).append(5).append(3).append(1) );
+    }
 }
diff --git a/src/unit/md5.unit b/src/unit/md5.unit
index 248aaaf..aaba113 100644
--- a/src/unit/md5.unit
+++ b/src/unit/md5.unit
@@ -12,71 +12,71 @@
 
 suite Md5
 {
-        test basics
-        {
+    test basics
+    {
 #define tryStr( a, b ) \
-        { Bu::Md5 m; m.addData(a); unitTest( m.getHexResult() == b ); } (void)0
-                tryStr("", "d41d8cd98f00b204e9800998ecf8427e");
-                tryStr("a", "0cc175b9c0f1b6a831c399e269772661");
-                tryStr("abc", "900150983cd24fb0d6963f7d28e17f72");
-                tryStr("message digest", "f96b697d7cb7938d525a2f31aaf161d0");
-                tryStr("abcdefghijklmnopqrstuvwxyz",
-                        "c3fcd3d76192e4007dfb496cca67e13b");
-                tryStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
-                        "d174ab98d277d9f5a5611c2c9f419d9f");
-                tryStr("12345678901234567890123456789012345"
-                        "678901234567890123456789012345678901234567890",
-                        "57edf4a22be3c955ac49da2e2107b67a");
-        }
+    { Bu::Md5 m; m.addData(a); unitTest( m.getHexResult() == b ); } (void)0
+        tryStr("", "d41d8cd98f00b204e9800998ecf8427e");
+        tryStr("a", "0cc175b9c0f1b6a831c399e269772661");
+        tryStr("abc", "900150983cd24fb0d6963f7d28e17f72");
+        tryStr("message digest", "f96b697d7cb7938d525a2f31aaf161d0");
+        tryStr("abcdefghijklmnopqrstuvwxyz",
+            "c3fcd3d76192e4007dfb496cca67e13b");
+        tryStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+            "d174ab98d277d9f5a5611c2c9f419d9f");
+        tryStr("12345678901234567890123456789012345"
+            "678901234567890123456789012345678901234567890",
+            "57edf4a22be3c955ac49da2e2107b67a");
+    }
 
-        test twoChunks
-        {
-                Bu::Md5 m;
-                m.addData("12345678901234567890123456789012345");
-                m.addData("678901234567890123456789012345678901234567890");
-                unitTest( m.getHexResult() == "57edf4a22be3c955ac49da2e2107b67a" );
-        }
+    test twoChunks
+    {
+        Bu::Md5 m;
+        m.addData("12345678901234567890123456789012345");
+        m.addData("678901234567890123456789012345678901234567890");
+        unitTest( m.getHexResult() == "57edf4a22be3c955ac49da2e2107b67a" );
+    }
 
-        test biggerBlocks
-        {
-                const char *sums[33] = {
-                        "75fcf199abe516903321095a588b938d",
-                        "e26a863c96d6bdba6601175aedaae108",
-                        "2b207fdcb222078d3ebfeb8d5e7c9315",
-                        "b08683aaa465add72cc2b43ae42f4f70",
-                        "638bb73963b2d925771c3579ccb5e879",
-                        "c727bd4b48a88e3df5924a2604de0790",
-                        "f33d21203c80490f7342e5853c5550eb",
-                        "db449faca66a177aae59b1e36a19d053",
-                        "c800d429afb5f5c820f75c2c94e2e2bb",
-                        "43b79c70b9a6a11e823ffbfa0f45a4db",
-                        "0177ffc483cf598ae3966b3a5ae00c8c",
-                        "1a68fdf4b17a3820d48d101e9355a818"
-                };
+    test biggerBlocks
+    {
+        const char *sums[33] = {
+            "75fcf199abe516903321095a588b938d",
+            "e26a863c96d6bdba6601175aedaae108",
+            "2b207fdcb222078d3ebfeb8d5e7c9315",
+            "b08683aaa465add72cc2b43ae42f4f70",
+            "638bb73963b2d925771c3579ccb5e879",
+            "c727bd4b48a88e3df5924a2604de0790",
+            "f33d21203c80490f7342e5853c5550eb",
+            "db449faca66a177aae59b1e36a19d053",
+            "c800d429afb5f5c820f75c2c94e2e2bb",
+            "43b79c70b9a6a11e823ffbfa0f45a4db",
+            "0177ffc483cf598ae3966b3a5ae00c8c",
+            "1a68fdf4b17a3820d48d101e9355a818"
+        };
 
-                char block[128];
-                for( int i = 0; i < 128; i++ )
-                        block[i] = i*2;
+        char block[128];
+        for( int i = 0; i < 128; i++ )
+            block[i] = i*2;
 
-                const char **curSum = sums;
-                for( int j = 1; j < 4096; j*=2 )
-                {
-                        /*
-                        Bu::File fOut("temp", Bu::File::WriteNew );
-                        for( int b = 0; b < j; b++ )
-                        {
-                                fOut.write( block, 128 );
-                        }
-                        fOut.close();
-                        system("md5sum -b temp");
-                        */
-                        Bu::Md5 m;
-                        for( int b = 0; b < j; b++ )
-                        {
-                                m.addData( block, 128 );
-                        }
-                        unitTest( m.getHexResult() == *curSum );
-                        curSum++;
-                } 
-        }
+        const char **curSum = sums;
+        for( int j = 1; j < 4096; j*=2 )
+        {
+            /*
+            Bu::File fOut("temp", Bu::File::WriteNew );
+            for( int b = 0; b < j; b++ )
+            {
+                fOut.write( block, 128 );
+            }
+            fOut.close();
+            system("md5sum -b temp");
+            */
+            Bu::Md5 m;
+            for( int b = 0; b < j; b++ )
+            {
+                m.addData( block, 128 );
+            }
+            unitTest( m.getHexResult() == *curSum );
+            curSum++;
+        } 
+    }
 }
diff --git a/src/unit/membuf.unit b/src/unit/membuf.unit
index 37ea77e..e5ee073 100644
--- a/src/unit/membuf.unit
+++ b/src/unit/membuf.unit
@@ -10,37 +10,37 @@
 
 suite MemBuf
 {
-        test testWriteRead01
-        {
-                Bu::MemBuf mb;
-                unitTest( mb.write("ab", 2 ) == 2 );
-                unitTest( mb.write("cde", 3 ) == 3 );
-                unitTest( mb.write("FG", 2 ) == 2 );
+    test testWriteRead01
+    {
+        Bu::MemBuf mb;
+        unitTest( mb.write("ab", 2 ) == 2 );
+        unitTest( mb.write("cde", 3 ) == 3 );
+        unitTest( mb.write("FG", 2 ) == 2 );
 
-                mb.setPos( 0 );
+        mb.setPos( 0 );
 
-                char buf[8];
-                buf[7] = '\0';
-                unitTest( mb.read( buf, 7 ) == 7 );
-                unitTest( !strncmp( buf, "abcdeFG", 7 ) );
-                unitTest( mb.read( buf, 7 ) == 0 );
-                mb.seek( -3 );
-                unitTest( mb.read( buf, 7 ) == 3 );
-                unitTest( !strncmp( buf, "eFG", 3 ) );
-        }
+        char buf[8];
+        buf[7] = '\0';
+        unitTest( mb.read( buf, 7 ) == 7 );
+        unitTest( !strncmp( buf, "abcdeFG", 7 ) );
+        unitTest( mb.read( buf, 7 ) == 0 );
+        mb.seek( -3 );
+        unitTest( mb.read( buf, 7 ) == 3 );
+        unitTest( !strncmp( buf, "eFG", 3 ) );
+    }
 
-        test testOverwrite1
-        {
-                Bu::MemBuf mb;
-                unitTest( mb.write("0123456789") == 10 );
-                mb.setPos( 4 );
-                unitTest( mb.write("-5-") == 3 );
-                mb.setPos( 9 );
-                mb.write("Hey!!!");
-                unitTest( mb.tell() == 15 );
-                char buf[50];
-                mb.setPos( 0 );
-                buf[mb.read( buf, 50 )] = '\0';
-                unitTest( !strcmp( buf, "0123-5-78Hey!!!" ) );
-        }
+    test testOverwrite1
+    {
+        Bu::MemBuf mb;
+        unitTest( mb.write("0123456789") == 10 );
+        mb.setPos( 4 );
+        unitTest( mb.write("-5-") == 3 );
+        mb.setPos( 9 );
+        mb.write("Hey!!!");
+        unitTest( mb.tell() == 15 );
+        char buf[50];
+        mb.setPos( 0 );
+        buf[mb.read( buf, 50 )] = '\0';
+        unitTest( !strcmp( buf, "0123-5-78Hey!!!" ) );
+    }
 }
diff --git a/src/unit/myriad.unit b/src/unit/myriad.unit
index 8c96f79..4960f38 100644
--- a/src/unit/myriad.unit
+++ b/src/unit/myriad.unit
@@ -26,360 +26,360 @@ class VerifyObject
 friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const VerifyObject &vo );
 friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, VerifyObject &vo );
 public:
-        VerifyObject( int iUnits ) :
-                iUnits( iUnits ),
-                iBytesWritten( 0 )
-        {
-        }
+    VerifyObject( int iUnits ) :
+        iUnits( iUnits ),
+        iBytesWritten( 0 )
+    {
+    }
 
-        virtual ~VerifyObject()
-        {
-        }
+    virtual ~VerifyObject()
+    {
+    }
 
-        int getBytesWritten()
-        {
-                return iBytesWritten;
-        }
+    int getBytesWritten()
+    {
+        return iBytesWritten;
+    }
 
 private:
-        int iUnits;
-        mutable int iBytesWritten;
+    int iUnits;
+    mutable int iBytesWritten;
 };
 
 Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const VerifyObject &vo )
 {
-        Md5 sum;
-        ar << vo.iUnits;
-        vo.iBytesWritten = 4;
-        sum.addData( &vo.iUnits, 4 );
-        for( int j = 0; j < vo.iUnits; j++ )
-        {
-                int iRand = random()%128;
-//              ar << iRand;
-                Bu::String sDat( iRand );
-                for( int j = 0; j < iRand; j++ )
-                        sDat[j] = (char)((uint8_t)(random()%256));
-                ar << sDat;
-                sum.addData( &iRand, 4 );
-                sum.addData( sDat.getStr(), iRand );
-                vo.iBytesWritten += 4 + iRand;
-        }
-        Bu::String sRes = sum.getResult();
-        ar << sRes;
-        vo.iBytesWritten += 4 + sRes.getSize();
-        return ar;
+    Md5 sum;
+    ar << vo.iUnits;
+    vo.iBytesWritten = 4;
+    sum.addData( &vo.iUnits, 4 );
+    for( int j = 0; j < vo.iUnits; j++ )
+    {
+        int iRand = random()%128;
+//      ar << iRand;
+        Bu::String sDat( iRand );
+        for( int j = 0; j < iRand; j++ )
+            sDat[j] = (char)((uint8_t)(random()%256));
+        ar << sDat;
+        sum.addData( &iRand, 4 );
+        sum.addData( sDat.getStr(), iRand );
+        vo.iBytesWritten += 4 + iRand;
+    }
+    Bu::String sRes = sum.getResult();
+    ar << sRes;
+    vo.iBytesWritten += 4 + sRes.getSize();
+    return ar;
 }
 
 Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, VerifyObject &vo )
 {
-        Md5 sum;
-        ar >> vo.iUnits;
-        sum.addData( &vo.iUnits, 4 );
-        for( int j = 0; j < vo.iUnits; j++ )
-        {
-                int iRand;
-//              ar >> iRand;
-                Bu::String sStr;
-                ar >> sStr;
-                iRand = sStr.getSize();
-                sum.addData( &iRand, 4 );
-                sum.addData( sStr.getStr(), iRand );
-        }
-        Bu::String sSum;
-        ar >> sSum;
-        unitTest( sSum == sum.getResult() );
-        int iTooMuch;
-        try
-        {
-                ar >> iTooMuch;
-                unitFailed("should have thrown an exception.");
-        }
-        catch( Bu::ExceptionBase &e )
-        {
-        }
-        return ar;
+    Md5 sum;
+    ar >> vo.iUnits;
+    sum.addData( &vo.iUnits, 4 );
+    for( int j = 0; j < vo.iUnits; j++ )
+    {
+        int iRand;
+//      ar >> iRand;
+        Bu::String sStr;
+        ar >> sStr;
+        iRand = sStr.getSize();
+        sum.addData( &iRand, 4 );
+        sum.addData( sStr.getStr(), iRand );
+    }
+    Bu::String sSum;
+    ar >> sSum;
+    unitTest( sSum == sum.getResult() );
+    int iTooMuch;
+    try
+    {
+        ar >> iTooMuch;
+        unitFailed("should have thrown an exception.");
+    }
+    catch( Bu::ExceptionBase &e )
+    {
+    }
+    return ar;
 }
 
 suite Myriad
 {
-        test setSize
-        {
-                String sFileName("myriad-XXXXXXX");
-
-                File fMyriad = tempFile( sFileName );
-                Myriad m( fMyriad, 32 );
-
-                MyriadStream ms = m.openStream( m.createStream() );
-                ms.setSize( 150 );
-                ms.setPos( 145 );
-                char stuff[10];
-                unitTest( ms.read( stuff, 10 ) == 5 );
-
-                ms.setSize( 12 );
-                unitTest( ms.read( stuff, 10 ) == 0 );
-                unitTest( ms.write( "hello", 5 ) == 5 );
-                unitTest( ms.tell() == 17 );
-
-                ms.setSize( 500 );
-                unitTest( ms.tell() == 17 );
-        }
-
-        void addBlock( Stream &s, bool bAppend=true )
-        {
-                if( bAppend )
-                        s.setPosEnd( 0 );
-                int iSize = (random()%1016)+8;
-                s.write( &iSize, 4 );
-                char *buf = new char[iSize-8];
-                for( int j = 0; j < iSize-8; j++ )
-                {
-                        buf[j] = (j+iSize)%256;
-                }
-                if( random()%2 == 0 )
-                {
-                        s.write( buf, iSize-8 );
-                }
-                else
-                {
-                        for( int j = 0; j < iSize-8; )
-                        {
-                                int iAmnt = (random()%8)+1;
-                                if( iAmnt+j > iSize-8 )
-                                        iAmnt = iSize-8-j;
-                                iAmnt = s.write( buf+j, iAmnt );
-                                j += iAmnt;
-                        }
-                }
-                delete[] buf;
-                iSize = ~iSize;
-                s.write( &iSize, 4 );
-        }
-
-        void verifyBlock( Stream &s )
-        {
-                int iSize, iInv;
-                if( s.read( &iSize, 4 ) == 0 )
-                        return;
-                if( iSize < 8 || iSize > 1024 )
-                        throw ExceptionBase("Read bad data, %d", iSize );
-                char *buf = new char[iSize-8];
-                if( s.read( buf, iSize-8 ) < (size_t)iSize-8 )
-                {
-                        delete[] buf;
-                        throw ExceptionBase("Block failed verify (insuffient block data).");
-                }
-                for( int j = 0; j < iSize-8; j++ )
-                {
-                        if( buf[j] != (char)((j+iSize)%256) )
-                        {
-                                char b = buf[j];
-                                delete[] buf;
-                                throw ExceptionBase("Block failed computed data verify "
-                                        "(%02X==%02X).", b, (char)((j+iSize)%256) );
-                        }
-                }
-                delete[] buf;
-                if( s.read( &iInv, 4 ) < 4 )
-                        throw ExceptionBase("Block failed verify (insufficient data).");
-                if( iInv != ~iSize )
-                        throw ExceptionBase("Block failed inversion verify.");
-        }
-        
-        void verifyStream( Stream &s )
-        {
-                s.setPos( 0 );
-                while( !s.isEos() )
-                        verifyBlock( s );
-        }
-
-        test stressGrow
-        {
-                String sFileName("myriad-XXXXXXX");
-
-                File fMyriad = tempFile( sFileName );
-                Myriad m( fMyriad );
-                m.initialize( 64 );
-
-                Array<int> aStreams;
-                for( int j = 0; j < 5; j++ )
-                {
-                        aStreams.append( m.createStream() );
-                }
-
-                srandom( 512 );
-
-                for( int j = 0; j < 2500; j++ )
-                {
-                        switch( random()%5 )
-                        {
-                                case 0:
-                                        aStreams.append( m.createStream() );
-                                        break;
-
-                                case 1:
-                                        if( aStreams.getSize() > 0 )
-                                        {
-                                                int iStream = random()%aStreams.getSize();
-                                                {
-                                                        MyriadStream ms = m.openStream( aStreams[iStream] );
-                                                        verifyStream( ms );
-                                                }
-                                                m.deleteStream( aStreams[iStream] );
-                                                Array<int>::iterator i = aStreams.begin();
-                                                for( int k = 0; k < iStream; k++ )
-                                                        i++;
-                                                aStreams.erase( i );
-                                        }
-                                        break;
-
-                                default:
-                                        if( aStreams.getSize() == 0 )
-                                        {
-                                                aStreams.append( m.createStream() );
-                                        }
-                                        {
-                                                int iStream = random()%aStreams.getSize();
-                                                MyriadStream ms = m.openStream( aStreams[iStream] );
-                                                addBlock( ms );
-                                                verifyStream( ms );
-                                        }
-                                        break;
-                        }
-                }
-
-                for( Array<int>::iterator i = aStreams.begin(); i; i++ )
-                {
-                        MyriadStream ms = m.openStream( *i );
-                        verifyStream( ms );
-                }
-        }
-        
-        test stressTruncate
-        {
-                String sFileName("myriad-XXXXXXX");
-
-                File fMyriad = tempFile( sFileName );
-                Myriad m( fMyriad );
-                m.initialize( 128 );
-
-                Array<int> aStream;
-
-                for( int j = 0; j < 5; j++ )
-                {
-                        aStream.append( m.createStream() );
-                }
-                
-                srandom( 1024 );
-
-                char b;
-                for( int iter = 0; iter < 2500; iter++ )
-                {
-                        for( Array<int>::iterator i = aStream.begin(); i; i++ )
-                        {
-                                MyriadStream ms = m.openStream( *i );
-                                addBlock( ms, false );
-                                ms.setSize( ms.tell() );
-                                unitTest( ms.read( &b, 1 ) == 0 );
-                                ms.setPos( 0 );
-                                verifyBlock( ms );
-                                unitTest( ms.read( &b, 1 ) == 0 );
-                        }
-                }
-        }
-        
-        test stressTruncate2
-        {
-                String sFileName("myriad-XXXXXXX");
-
-                Array<int> aStream;
-
-                setStepCount( 5*2500 + 5 );
-
-                {
-                        File fMyriad = tempFile( sFileName );
-                        Myriad m( fMyriad, 128 );
-
-                        for( int j = 0; j < 5; j++ )
-                        {
-                                aStream.append( m.createStream() );
-                                incProgress();
-                        }
-                }
-                
-                srandom( 1024 );
-
-                char b;
-                for( int iter = 0; iter < 2500; iter++ )
-                {
-                        File fMyriad( sFileName, File::ReadWrite );
-                        Myriad m( fMyriad );
-                        for( Array<int>::iterator i = aStream.begin(); i; i++ )
-                        {
-                                MyriadStream ms = m.openStream( *i );
-                                addBlock( ms, false );
-                                ms.setSize( ms.tell() );
-                                unitTest( ms.read( &b, 1 ) == 0 );
-                                ms.setPos( 0 );
-                                verifyBlock( ms );
-                                unitTest( ms.read( &b, 1 ) == 0 );
-                                incProgress();
-                        }
-                }
-        }
-
-        test stressArchive
-        {
-                String sFileName("myriad-XXXXXX");
-                Array<int> aStream;
-                
-                srandom( 2096 );
-
-                setStepCount( 15*250 + 15 );
-                
-                {
-                        File fMyriad = tempFile( sFileName );
-                        Myriad m( fMyriad, 1024 );
-
-                        for( int j = 0; j < 15; j++ )
-                        {
-                                int iStream = m.createStream();
-                                aStream.append( iStream );
-                                VerifyObject vo( random()%1024 );
-                                {
-                                        MyriadStream ms = m.openStream( iStream );
-                                        Archive ar( ms, Archive::save );
-                                        ar << vo;
-                                        unitTest( ms.tell() == vo.getBytesWritten() );
-                                        ms.setSize( ms.tell() );
-                                }
-                                unitTest( m.getStreamSize( iStream ) == vo.getBytesWritten() );
-                                incProgress();
-                        }
-                }
-
-                for( int iter = 0; iter < 250; iter++ )
-                {
-                        File fMyriad( sFileName, File::ReadWrite );
-                        Myriad m( fMyriad );
-                        for( Array<int>::iterator i = aStream.begin(); i; i++ )
-                        {
-                                VerifyObject vo( random()%1024 );
-                                {
-                                        MyriadStream ms = m.openStream( *i );
-                                        Archive ar( ms, Archive::load );
-                                        ar >> vo;
-                                }
-                                {
-                                        MyriadStream ms = m.openStream( *i );
-                                        Archive ar( ms, Archive::save );
-                                        ar << vo;
-                                        unitTest( ms.tell() == vo.getBytesWritten() );
-                                        ms.setSize( ms.tell() );
-                                }
-                                unitTest( m.getStreamSize( *i ) == vo.getBytesWritten() );
-                                incProgress();
-                        }
-                }
-        }
+    test setSize
+    {
+        String sFileName("myriad-XXXXXXX");
+
+        File fMyriad = tempFile( sFileName );
+        Myriad m( fMyriad, 32 );
+
+        MyriadStream ms = m.openStream( m.createStream() );
+        ms.setSize( 150 );
+        ms.setPos( 145 );
+        char stuff[10];
+        unitTest( ms.read( stuff, 10 ) == 5 );
+
+        ms.setSize( 12 );
+        unitTest( ms.read( stuff, 10 ) == 0 );
+        unitTest( ms.write( "hello", 5 ) == 5 );
+        unitTest( ms.tell() == 17 );
+
+        ms.setSize( 500 );
+        unitTest( ms.tell() == 17 );
+    }
+
+    void addBlock( Stream &s, bool bAppend=true )
+    {
+        if( bAppend )
+            s.setPosEnd( 0 );
+        int iSize = (random()%1016)+8;
+        s.write( &iSize, 4 );
+        char *buf = new char[iSize-8];
+        for( int j = 0; j < iSize-8; j++ )
+        {
+            buf[j] = (j+iSize)%256;
+        }
+        if( random()%2 == 0 )
+        {
+            s.write( buf, iSize-8 );
+        }
+        else
+        {
+            for( int j = 0; j < iSize-8; )
+            {
+                int iAmnt = (random()%8)+1;
+                if( iAmnt+j > iSize-8 )
+                    iAmnt = iSize-8-j;
+                iAmnt = s.write( buf+j, iAmnt );
+                j += iAmnt;
+            }
+        }
+        delete[] buf;
+        iSize = ~iSize;
+        s.write( &iSize, 4 );
+    }
+
+    void verifyBlock( Stream &s )
+    {
+        int iSize, iInv;
+        if( s.read( &iSize, 4 ) == 0 )
+            return;
+        if( iSize < 8 || iSize > 1024 )
+            throw ExceptionBase("Read bad data, %d", iSize );
+        char *buf = new char[iSize-8];
+        if( s.read( buf, iSize-8 ) < (size_t)iSize-8 )
+        {
+            delete[] buf;
+            throw ExceptionBase("Block failed verify (insuffient block data).");
+        }
+        for( int j = 0; j < iSize-8; j++ )
+        {
+            if( buf[j] != (char)((j+iSize)%256) )
+            {
+                char b = buf[j];
+                delete[] buf;
+                throw ExceptionBase("Block failed computed data verify "
+                    "(%02X==%02X).", b, (char)((j+iSize)%256) );
+            }
+        }
+        delete[] buf;
+        if( s.read( &iInv, 4 ) < 4 )
+            throw ExceptionBase("Block failed verify (insufficient data).");
+        if( iInv != ~iSize )
+            throw ExceptionBase("Block failed inversion verify.");
+    }
+    
+    void verifyStream( Stream &s )
+    {
+        s.setPos( 0 );
+        while( !s.isEos() )
+            verifyBlock( s );
+    }
+
+    test stressGrow
+    {
+        String sFileName("myriad-XXXXXXX");
+
+        File fMyriad = tempFile( sFileName );
+        Myriad m( fMyriad );
+        m.initialize( 64 );
+
+        Array<int> aStreams;
+        for( int j = 0; j < 5; j++ )
+        {
+            aStreams.append( m.createStream() );
+        }
+
+        srandom( 512 );
+
+        for( int j = 0; j < 2500; j++ )
+        {
+            switch( random()%5 )
+            {
+                case 0:
+                    aStreams.append( m.createStream() );
+                    break;
+
+                case 1:
+                    if( aStreams.getSize() > 0 )
+                    {
+                        int iStream = random()%aStreams.getSize();
+                        {
+                            MyriadStream ms = m.openStream( aStreams[iStream] );
+                            verifyStream( ms );
+                        }
+                        m.deleteStream( aStreams[iStream] );
+                        Array<int>::iterator i = aStreams.begin();
+                        for( int k = 0; k < iStream; k++ )
+                            i++;
+                        aStreams.erase( i );
+                    }
+                    break;
+
+                default:
+                    if( aStreams.getSize() == 0 )
+                    {
+                        aStreams.append( m.createStream() );
+                    }
+                    {
+                        int iStream = random()%aStreams.getSize();
+                        MyriadStream ms = m.openStream( aStreams[iStream] );
+                        addBlock( ms );
+                        verifyStream( ms );
+                    }
+                    break;
+            }
+        }
+
+        for( Array<int>::iterator i = aStreams.begin(); i; i++ )
+        {
+            MyriadStream ms = m.openStream( *i );
+            verifyStream( ms );
+        }
+    }
+    
+    test stressTruncate
+    {
+        String sFileName("myriad-XXXXXXX");
+
+        File fMyriad = tempFile( sFileName );
+        Myriad m( fMyriad );
+        m.initialize( 128 );
+
+        Array<int> aStream;
+
+        for( int j = 0; j < 5; j++ )
+        {
+            aStream.append( m.createStream() );
+        }
+        
+        srandom( 1024 );
+
+        char b;
+        for( int iter = 0; iter < 2500; iter++ )
+        {
+            for( Array<int>::iterator i = aStream.begin(); i; i++ )
+            {
+                MyriadStream ms = m.openStream( *i );
+                addBlock( ms, false );
+                ms.setSize( ms.tell() );
+                unitTest( ms.read( &b, 1 ) == 0 );
+                ms.setPos( 0 );
+                verifyBlock( ms );
+                unitTest( ms.read( &b, 1 ) == 0 );
+            }
+        }
+    }
+    
+    test stressTruncate2
+    {
+        String sFileName("myriad-XXXXXXX");
+
+        Array<int> aStream;
+
+        setStepCount( 5*2500 + 5 );
+
+        {
+            File fMyriad = tempFile( sFileName );
+            Myriad m( fMyriad, 128 );
+
+            for( int j = 0; j < 5; j++ )
+            {
+                aStream.append( m.createStream() );
+                incProgress();
+            }
+        }
+        
+        srandom( 1024 );
+
+        char b;
+        for( int iter = 0; iter < 2500; iter++ )
+        {
+            File fMyriad( sFileName, File::ReadWrite );
+            Myriad m( fMyriad );
+            for( Array<int>::iterator i = aStream.begin(); i; i++ )
+            {
+                MyriadStream ms = m.openStream( *i );
+                addBlock( ms, false );
+                ms.setSize( ms.tell() );
+                unitTest( ms.read( &b, 1 ) == 0 );
+                ms.setPos( 0 );
+                verifyBlock( ms );
+                unitTest( ms.read( &b, 1 ) == 0 );
+                incProgress();
+            }
+        }
+    }
+
+    test stressArchive
+    {
+        String sFileName("myriad-XXXXXX");
+        Array<int> aStream;
+        
+        srandom( 2096 );
+
+        setStepCount( 15*250 + 15 );
+        
+        {
+            File fMyriad = tempFile( sFileName );
+            Myriad m( fMyriad, 1024 );
+
+            for( int j = 0; j < 15; j++ )
+            {
+                int iStream = m.createStream();
+                aStream.append( iStream );
+                VerifyObject vo( random()%1024 );
+                {
+                    MyriadStream ms = m.openStream( iStream );
+                    Archive ar( ms, Archive::save );
+                    ar << vo;
+                    unitTest( ms.tell() == vo.getBytesWritten() );
+                    ms.setSize( ms.tell() );
+                }
+                unitTest( m.getStreamSize( iStream ) == vo.getBytesWritten() );
+                incProgress();
+            }
+        }
+
+        for( int iter = 0; iter < 250; iter++ )
+        {
+            File fMyriad( sFileName, File::ReadWrite );
+            Myriad m( fMyriad );
+            for( Array<int>::iterator i = aStream.begin(); i; i++ )
+            {
+                VerifyObject vo( random()%1024 );
+                {
+                    MyriadStream ms = m.openStream( *i );
+                    Archive ar( ms, Archive::load );
+                    ar >> vo;
+                }
+                {
+                    MyriadStream ms = m.openStream( *i );
+                    Archive ar( ms, Archive::save );
+                    ar << vo;
+                    unitTest( ms.tell() == vo.getBytesWritten() );
+                    ms.setSize( ms.tell() );
+                }
+                unitTest( m.getStreamSize( *i ) == vo.getBytesWritten() );
+                incProgress();
+            }
+        }
+    }
 }
 
diff --git a/src/unit/queuebuf.unit b/src/unit/queuebuf.unit
index 553d9fc..bc55a04 100644
--- a/src/unit/queuebuf.unit
+++ b/src/unit/queuebuf.unit
@@ -16,89 +16,89 @@
 
 suite QueueBuf
 {
-        test testBasic01
-        {
-                Bu::QueueBuf qb;
-                unitTest( qb.write("ab", 2 ) == 2 );
-                unitTest( qb.write("cde", 3 ) == 3 );
-                unitTest( qb.write("FG", 2 ) == 2 );
+    test testBasic01
+    {
+        Bu::QueueBuf qb;
+        unitTest( qb.write("ab", 2 ) == 2 );
+        unitTest( qb.write("cde", 3 ) == 3 );
+        unitTest( qb.write("FG", 2 ) == 2 );
 
-                char buf[8];
-                buf[7] = '\0';
-                unitTest( qb.read( buf, 7 ) == 7 );
-                unitTest( !strncmp( buf, "abcdeFG", 7 ) );
-                unitTest( qb.read( buf, 7 ) == 0 );
-        }
+        char buf[8];
+        buf[7] = '\0';
+        unitTest( qb.read( buf, 7 ) == 7 );
+        unitTest( !strncmp( buf, "abcdeFG", 7 ) );
+        unitTest( qb.read( buf, 7 ) == 0 );
+    }
 
-        void QBUF_RANDSTR( Bu::String &fill, unsigned int iSize )
-        {
-                char c;
-                for( unsigned int i=0; i<iSize; ++i )
-                {
-                        c = RNDCHR;
-                        fill.append(&c,1);
-                }
-        }
+    void QBUF_RANDSTR( Bu::String &fill, unsigned int iSize )
+    {
+        char c;
+        for( unsigned int i=0; i<iSize; ++i )
+        {
+            c = RNDCHR;
+            fill.append(&c,1);
+        }
+    }
 
-        test testAmounts
-        {
-                srandom(time(NULL));
-                Bu::QueueBuf qb;
-                Bu::String sTmp;
-                char buf[4096];
+    test testAmounts
+    {
+        srandom(time(NULL));
+        Bu::QueueBuf qb;
+        Bu::String sTmp;
+        char buf[4096];
 
-                for( int i=0; i<200; ++i )
-                {
-                        unsigned int iAmt = (int)RNDCHR+128;
-                        sTmp.clear();
-                        QBUF_RANDSTR( sTmp, iAmt );
-                        unitTest( qb.write( sTmp.getStr(), sTmp.getSize() ) == 
-                                (uint32_t)sTmp.getSize() );
-                        size_t iRead = qb.read( buf, 4096 );
-                        unitTest( iRead == iAmt );
-                }
-        }
+        for( int i=0; i<200; ++i )
+        {
+            unsigned int iAmt = (int)RNDCHR+128;
+            sTmp.clear();
+            QBUF_RANDSTR( sTmp, iAmt );
+            unitTest( qb.write( sTmp.getStr(), sTmp.getSize() ) == 
+                (uint32_t)sTmp.getSize() );
+            size_t iRead = qb.read( buf, 4096 );
+            unitTest( iRead == iAmt );
+        }
+    }
 
-        void QBUF_HEXOUT( const char *s, int iSize )
-        {
-                for( int i=0; i<iSize; ++i )
-                        printf("%02x",(int)(uint8_t)s[i]);
-        }
+    void QBUF_HEXOUT( const char *s, int iSize )
+    {
+        for( int i=0; i<iSize; ++i )
+            printf("%02x",(int)(uint8_t)s[i]);
+    }
 
-        void QBUF_HASH( Bu::String &fill, const char *s, int iSize )
-        {
-                Bu::Md5 hash;
-                hash.reset();
-                hash.addData( s, iSize );
-                const Bu::String &sTmp = hash.getResult();
-                fill.append( sTmp.getStr(), 16 );
-        }
+    void QBUF_HASH( Bu::String &fill, const char *s, int iSize )
+    {
+        Bu::Md5 hash;
+        hash.reset();
+        hash.addData( s, iSize );
+        const Bu::String &sTmp = hash.getResult();
+        fill.append( sTmp.getStr(), 16 );
+    }
 
-        test testRandomData
-        {
-                srandom(time(NULL));
-                Bu::QueueBuf qb;
-                Bu::String sTmp;
-                Bu::String sTmp2;
-                char buf[4096];
+    test testRandomData
+    {
+        srandom(time(NULL));
+        Bu::QueueBuf qb;
+        Bu::String sTmp;
+        Bu::String sTmp2;
+        char buf[4096];
 
-                for( int i=0; i<200; ++i )
-                {
-                        uint32_t iAmt = (uint32_t)RNDCHR+128;
-                        sTmp.clear();
-                        sTmp.append( (const char *)&iAmt, 4 );
-                        QBUF_RANDSTR( sTmp, iAmt );
-                        sTmp2.clear();
-                        QBUF_HASH( sTmp2, sTmp.getStr()+4, iAmt );
-                        sTmp.append( sTmp2 );
-                        unitTest( qb.write( sTmp.getStr(), sTmp.getSize() ) == 
-                                (uint32_t)sTmp.getSize() );
-                        size_t iRead = qb.read( buf, 4096 );
-                        uint32_t iGotSize = *((uint32_t *)buf);
-                        unitTest( iRead == iGotSize+4+16 );
-                        sTmp2.clear();
-                        QBUF_HASH( sTmp2, buf+4, iGotSize );
-                        unitTest( !strncmp(sTmp2.getStr(),buf+4+iGotSize,16) );
-                }
-        }
+        for( int i=0; i<200; ++i )
+        {
+            uint32_t iAmt = (uint32_t)RNDCHR+128;
+            sTmp.clear();
+            sTmp.append( (const char *)&iAmt, 4 );
+            QBUF_RANDSTR( sTmp, iAmt );
+            sTmp2.clear();
+            QBUF_HASH( sTmp2, sTmp.getStr()+4, iAmt );
+            sTmp.append( sTmp2 );
+            unitTest( qb.write( sTmp.getStr(), sTmp.getSize() ) == 
+                (uint32_t)sTmp.getSize() );
+            size_t iRead = qb.read( buf, 4096 );
+            uint32_t iGotSize = *((uint32_t *)buf);
+            unitTest( iRead == iGotSize+4+16 );
+            sTmp2.clear();
+            QBUF_HASH( sTmp2, buf+4, iGotSize );
+            unitTest( !strncmp(sTmp2.getStr(),buf+4+iGotSize,16) );
+        }
+    }
 }
diff --git a/src/unit/sha1.unit b/src/unit/sha1.unit
index d91b4c3..1151cfb 100644
--- a/src/unit/sha1.unit
+++ b/src/unit/sha1.unit
@@ -12,65 +12,65 @@
 
 suite Sha1
 {
-        test basics
-        {
+    test basics
+    {
 #define tryStr( a, b ) \
-        { Bu::Sha1 m; m.addData(a); unitTest( m.getHexResult() == b ); } (void)0
-                tryStr("", "da39a3ee5e6b4b0d3255bfef95601890afd80709");
-                tryStr("The quick brown fox jumps over the lazy dog",
-                        "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
-                tryStr("The quick brown fox jumps over the lazy cog",
-                        "de9f2c7fd25e1b3afad3e85a0bd17d9b100db4b3");
-        }
+    { Bu::Sha1 m; m.addData(a); unitTest( m.getHexResult() == b ); } (void)0
+        tryStr("", "da39a3ee5e6b4b0d3255bfef95601890afd80709");
+        tryStr("The quick brown fox jumps over the lazy dog",
+            "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
+        tryStr("The quick brown fox jumps over the lazy cog",
+            "de9f2c7fd25e1b3afad3e85a0bd17d9b100db4b3");
+    }
 
-        test twoChunks
-        {
-                Bu::Sha1 m;
-                m.addData("The quick brown fo");
-                m.addData("x jumps over the lazy dog");
-                unitTest( m.getHexResult() == "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12" );
-        }
+    test twoChunks
+    {
+        Bu::Sha1 m;
+        m.addData("The quick brown fo");
+        m.addData("x jumps over the lazy dog");
+        unitTest( m.getHexResult() == "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12" );
+    }
 
-        test biggerBlocks
-        {
-                const char *sums[41] = {
-                        "2356aab95478d8e3c2c918e36f383e46d06154c7",
-                        "e3f663240c185a95111c4e00e20865dfbda390aa",
-                        "3f21881040b42f44476b610b6d2191f72afc1cb5",
-                        "493fe9da6de598c52ea56962b15ccc4405a8dfda",
-                        "4684ff568f7c1198a258eb04d88209f4feab4e05",
-                        "614101c1c164b8b6099f63165ea01078cbb6c77f",
-                        "393f1c1a9f6384653029ab807756e85a13147029",
-                        "fd66443d68f8b0508b4f125f2cff1192bfc01913",
-                        "1ef66120e530731194554bb2cd51293779a0bcc7",
-                        "d77e0eda0037f51b0b6c197371c5fd801cc0eede",
-                        "ce8b579bd3aa2ccac2e0205f52a8ed03777117ac",
-                        "d9e9d7fc411de2f89329ab758dc8f4302f80ff23"
-                };
+    test biggerBlocks
+    {
+        const char *sums[41] = {
+            "2356aab95478d8e3c2c918e36f383e46d06154c7",
+            "e3f663240c185a95111c4e00e20865dfbda390aa",
+            "3f21881040b42f44476b610b6d2191f72afc1cb5",
+            "493fe9da6de598c52ea56962b15ccc4405a8dfda",
+            "4684ff568f7c1198a258eb04d88209f4feab4e05",
+            "614101c1c164b8b6099f63165ea01078cbb6c77f",
+            "393f1c1a9f6384653029ab807756e85a13147029",
+            "fd66443d68f8b0508b4f125f2cff1192bfc01913",
+            "1ef66120e530731194554bb2cd51293779a0bcc7",
+            "d77e0eda0037f51b0b6c197371c5fd801cc0eede",
+            "ce8b579bd3aa2ccac2e0205f52a8ed03777117ac",
+            "d9e9d7fc411de2f89329ab758dc8f4302f80ff23"
+        };
 
-                char block[128];
-                for( int i = 0; i < 128; i++ )
-                        block[i] = i*2;
+        char block[128];
+        for( int i = 0; i < 128; i++ )
+            block[i] = i*2;
 
-                const char **curSum = sums;
-                for( int j = 1; j < 4096; j*=2 )
-                {
-                        /*
-                        Bu::File fOut("temp", Bu::File::WriteNew );
-                        for( int b = 0; b < j; b++ )
-                        {
-                                fOut.write( block, 128 );
-                        }
-                        fOut.close();
-                        system("sha1sum -b temp");
-                        */
-                        Bu::Sha1 m;
-                        for( int b = 0; b < j; b++ )
-                        {
-                                m.addData( block, 128 );
-                        }
-                        unitTest( m.getHexResult() == *curSum );
-                        curSum++;
-                } 
-        }
+        const char **curSum = sums;
+        for( int j = 1; j < 4096; j*=2 )
+        {
+            /*
+            Bu::File fOut("temp", Bu::File::WriteNew );
+            for( int b = 0; b < j; b++ )
+            {
+                fOut.write( block, 128 );
+            }
+            fOut.close();
+            system("sha1sum -b temp");
+            */
+            Bu::Sha1 m;
+            for( int b = 0; b < j; b++ )
+            {
+                m.addData( block, 128 );
+            }
+            unitTest( m.getHexResult() == *curSum );
+            curSum++;
+        } 
+    }
 }
diff --git a/src/unit/string.unit b/src/unit/string.unit
index 4ea878e..ddd89a6 100644
--- a/src/unit/string.unit
+++ b/src/unit/string.unit
@@ -12,580 +12,580 @@
 
 suite String
 {
-        test compare1
-        {
-                Bu::String b("Bob");
-                unitTest( !(b == "Bobo") );
-                unitTest( b == "Bob" );
-        }
-
-        test compare2
-        {
-                Bu::String b("Bobo");
-                unitTest( !(b == "Bob") );
-                unitTest( b == "Bobo" );
-        }
-
-        test appendSingle
-        {
-                Bu::String b;
-                for( char l = 'a'; l < 'g'; l++ )
-                        b += l;
-                unitTest( b == "abcdef" );
-                unitTest( strcmp( b.getStr(), "abcdef" ) == 0 );
-        }
-
-        test shared1
-        {
-                Bu::String a("Hey there");
-                Bu::String b( a );
-                unitTest( a.getConstStr() == b.getConstStr() );
-                b += " guy";
-                unitTest( a.getConstStr() != b.getConstStr() );
-                a = b;
-                unitTest( a.getConstStr() == b.getConstStr() );
-        }
-
-        test insert
-        {
-                Bu::String a("abcd");
-                a.insert( 2, "-!-", 3 );
-                unitTest( a == "ab-!-cd" );
-                
-                a.insert( 0, "!!", 2 );
-                unitTest( a == "!!ab-!-cd" );
-                
-                a.insert( -10, "789", 3 );
-                unitTest( a == "789!!ab-!-cd" );
-                
-                a.insert( 12, "89", 2 );
-                unitTest( a == "789!!ab-!-cd89" );
-                
-                a.insert( 1203, "12", 2 );
-                unitTest( a == "789!!ab-!-cd8912" );
-        }
-
-        test remove
-        {
-                Bu::String a("abHEYcd");
-                a.remove( 2, 3 );
-                unitTest( a == "abcd" );
-                a.remove( 2, 5 );
-                unitTest( a == "ab" );
-                a += "cdefghijklmnop";
-                a.remove( 5, 1 );
-                unitTest( a == "abcdeghijklmnop" );
-        }
-
-        test add1
-        {
-                Bu::String a("hi there");
-                Bu::String b(", yeah!");
-                Bu::String c = a + b;
-
-                unitTest( c == "hi there, yeah!" );
-        }
-
-        test add2
-        {
-                Bu::String a("hi there");
-                Bu::String c = a + ", yeah!";
-
-                unitTest( c == "hi there, yeah!" );
-        }
-
-        test add3
-        {
-                Bu::String a("hi there");
-                Bu::String b(", yeah!");
-                Bu::String c = a + ", Mr. Man" + b;
-
-                unitTest( c == "hi there, Mr. Man, yeah!" );
-        }
-
-        test add4
-        {
-                Bu::String b(", yeah!");
-                Bu::String c = "hi there" + b;
-
-                unitTest( c == "hi there, yeah!" );
-        }
-
-        test add5
-        {
-                Bu::String b;
-                Bu::String c = "sup?";
-                b += "hey, " + c;
-                
-                unitTest( b == "hey, sup?" );
-        }
-
-        test add6
-        {
-                Bu::String a("Hello");
-                char b[256] = {"Dude"};
-                Bu::String c = a + "/" + b;
-
-                unitTest( c == "Hello/Dude" );
-        }
-
-        test add7
-        {
-                const Bu::String a("hello ");
-                Bu::String b(" how ");
-                unitTest( a == "hello " );
-                unitTest( a + "dude" == "hello dude" );
-                unitTest( a + "dude" + b + "are you?" == "hello dude how are you?" );
-        }
-
-        test subStr1
-        {
-                Bu::String a("abcdefghijklmnop");
-                Bu::String::iterator i = a.find('f');
-                unitTest( a.getSubStr( i, Bu::String::iterator() ) == "fghijklmnop" );
-                Bu::String::iterator j = i.find('l');
-                unitTest( a.getSubStr( i, j ) == "fghijk" );
-        }
-
-        test compareSub1
-        {
-                Bu::String a("just a string.");
-                unitTest( a.compareSub("a ", 5, 2) == true );
-                unitTest( a.compareSub("string.aoeu", 7, 11 ) == false );
-                unitTest( a.compareSub("string.aoeu", 7, 3 ) == true );
-        }
-
-        test compareSub2
-        {
-                Bu::String a("just a string.");
-                unitTest( a.compareSub(Bu::String("a "), 5, 2) == true );
-                unitTest( a.compareSub(Bu::String("string.aoeu"), 7, 11 ) == false );
-                unitTest( a.compareSub(Bu::String("string.aoeu"), 7, 3 ) == true );
-        }
-
-        test iterator1
-        {
-                Bu::String a("This is a test.");
-                Bu::String b;
-                for( Bu::String::iterator i = a.begin(); i; i++ )
-                {
-                        b += *i;
-                }
-                unitTest( a == b );
-        }
-
-        test iteratorCompare1
-        {
-                Bu::String a("This is a test.");
-                Bu::String b("--This is a test.");
-                Bu::String::iterator ai = a.begin();
-                Bu::String::iterator bi = b.begin();
-                unitTest( ai.compare( bi ) == false );
-                unitTest( bi.compare( ai ) == false );
-                bi++; bi++;
-                unitTest( ai.compare( bi ) == true );
-                unitTest( bi.compare( ai ) == true );
-                b += "hi";
-                unitTest( ai.compare( bi ) == false );
-                unitTest( bi.compare( ai ) == false );
-        }
-
-        test iteratorCompare2
-        {
-                Bu::String a("1234honour");
-                Bu::String b("--1234ueje");
-                Bu::String::iterator ai = a.begin();
-                Bu::String::iterator bi = b.begin();
-                unitTest( ai.compare( bi, 4 ) == false );
-                unitTest( bi.compare( ai, 4 ) == false );
-                bi++; bi++;
-                unitTest( ai.compare( bi, 4 ) == true );
-                unitTest( bi.compare( ai, 4 ) == true );
-                unitTest( ai.compare( bi, 5 ) == false );
-                unitTest( bi.compare( ai, 5 ) == false );
-                
-                a = "fell";
-                b = "-felloo";
-                ai = a.begin();
-                bi = b.begin()+1;
-                unitTest( ai.compare( bi, 4 ) == true );
-                ai++;
-                bi++;
-                unitTest( ai.compare( bi, 4 ) == false );
-        }
-
-        test iteratorCompare3
-        {
-                Bu::String a("1234aoeu");
-                Bu::String::iterator ai = a.begin();
-                unitTest( ai.compare("1234") == false );
-                unitTest( ai.compare("1234aoeu") == true );
-                unitTest( ai.compare("1234aoeuee") == false );
-                ai += 4;
-                unitTest( ai.compare("aoeu") == true );
-                unitTest( ai.compare("aoeubo") == false );
-                unitTest( ai.compare("aoe") == false );
-                unitTest( ai.compare("wrong") == false );
-                unitTest( ai.compare("boeu") == false );
-        }
-
-        test iteratorCompare4
-        {
-                Bu::String a("1234aoeu");
-                Bu::String::iterator ai = a.begin();
-                unitTest( ai.compare("1234", 4) == true );
-                unitTest( ai.compare("1234aoeu", 8) == true );
-                unitTest( ai.compare("1234aoeuee", 10) == false );
-        }
-
-        test iteratorCompare5
-        {
-                Bu::String a("1234aoeu");
-                Bu::String b("34ao");
-                Bu::String::iterator ai = a.begin();
-                unitTest( ai.compare( b ) == false );
-                ai += 2;
-                unitTest( ai.compare( b ) == false );
-                b = "oeu";
-                ai += 3;
-                unitTest( ai.compare( b ) == true );
-                b += "boo";
-                unitTest( ai.compare( b ) == false );
-        }
-
-        test iteratorCompare6
-        {
-                Bu::String a("1234aoeu");
-                Bu::String::iterator ai = a.begin();
-                unitTest( ai.compare( Bu::String("1234"), 4) == true );
-                unitTest( ai.compare( Bu::String("1234aoeu"), 8) == true );
-                unitTest( ai.compare( Bu::String("1234aoeuee"), 10) == false );
-        }
-
-        test const_iteratorCompare1
-        {
-                Bu::String a("This is a test.");
-                Bu::String b("--This is a test.");
-                Bu::String::const_iterator ai = a.begin();
-                Bu::String::const_iterator bi = b.begin();
-                unitTest( ai.compare( bi ) == false );
-                unitTest( bi.compare( ai ) == false );
-                bi++; bi++;
-                unitTest( ai.compare( bi ) == true );
-                unitTest( bi.compare( ai ) == true );
-                b += "hi";
-                unitTest( ai.compare( bi ) == false );
-                unitTest( bi.compare( ai ) == false );
-        }
-
-        test const_iteratorCompare2
-        {
-                Bu::String a("1234honour");
-                Bu::String b("--1234ueje");
-                Bu::String::const_iterator ai = a.begin();
-                Bu::String::const_iterator bi = b.begin();
-                unitTest( ai.compare( bi, 4 ) == false );
-                unitTest( bi.compare( ai, 4 ) == false );
-                bi++; bi++;
-                unitTest( ai.compare( bi, 4 ) == true );
-                unitTest( bi.compare( ai, 4 ) == true );
-                unitTest( ai.compare( bi, 5 ) == false );
-                unitTest( bi.compare( ai, 5 ) == false );
-                
-                a = "fell";
-                b = "-felloo";
-                ai = a.begin();
-                bi = b.begin()+1;
-                unitTest( ai.compare( bi, 4 ) == true );
-                ai++;
-                bi++;
-                unitTest( ai.compare( bi, 4 ) == false );
-        }
-
-        test const_iteratorCompare3
-        {
-                Bu::String a("1234aoeu");
-                Bu::String::const_iterator ai = a.begin();
-                unitTest( ai.compare("1234") == false );
-                unitTest( ai.compare("1234aoeu") == true );
-                unitTest( ai.compare("1234aoeuee") == false );
-                ai += 4;
-                unitTest( ai.compare("aoeu") == true );
-                unitTest( ai.compare("aoeubo") == false );
-                unitTest( ai.compare("aoe") == false );
-                unitTest( ai.compare("wrong") == false );
-                unitTest( ai.compare("boeu") == false );
-        }
-
-        test const_iteratorCompare4
-        {
-                Bu::String a("1234aoeu");
-                Bu::String::const_iterator ai = a.begin();
-                unitTest( ai.compare("1234", 4) == true );
-                unitTest( ai.compare("1234aoeu", 8) == true );
-                unitTest( ai.compare("1234aoeuee", 10) == false );
-        }
-
-        test const_iteratorCompare5
-        {
-                Bu::String a("1234aoeu");
-                Bu::String b("34ao");
-                Bu::String::const_iterator ai = a.begin();
-                unitTest( ai.compare( b ) == false );
-                ai += 2;
-                unitTest( ai.compare( b ) == false );
-                b = "oeu";
-                ai += 3;
-                unitTest( ai.compare( b ) == true );
-                b += "boo";
-                unitTest( ai.compare( b ) == false );
-        }
-
-        test const_iteratorCompare6
-        {
-                Bu::String a("1234aoeu");
-                Bu::String::const_iterator ai = a.begin();
-                unitTest( ai.compare( Bu::String("1234"), 4) == true );
-                unitTest( ai.compare( Bu::String("1234aoeu"), 8) == true );
-                unitTest( ai.compare( Bu::String("1234aoeuee"), 10) == false );
-        }
-
-        test iteratorAppend1
-        {
-                Bu::String a("just ->this part");
-                Bu::String b;
-                Bu::String::iterator s = a.begin();
-                for(; s; s++ )
-                {
-                        if( *s == '>' )
-                        {
-                                s++;
-                                b.set( s );
-                                break;
-                        }
-                }
-                unitTest( b == "this part" );
-
-                b.append( s );
-
-                Bu::String c;
-                c.set( b.begin() );
-
-                // This is here because the comparison operator used to cause flattening.
-                unitTest( b == "this partthis part" );
-                unitTest( c == b );
-        }
-
-        test iteratorAppend2
-        {
-                Bu::String a("just [this] part");
-                Bu::String b;
-                Bu::String::iterator s = a.begin();
-                for(; s; s++ )
-                {
-                        if( *s == '[' )
-                        {
-                                s++;
-                                break;
-                        }
-                }
-                Bu::String::iterator e = s;
-                for(; e; e++ )
-                {
-                        if( *e == ']' )
-                        {
-                                b.set( s, e );
-                                break;
-                        }
-                }
-                unitTest( b == "this" );
-
-                b.append( s, e );
-
-                for( Bu::String::iterator i = b.begin(); i;)
-                {
-                        Bu::String::iterator k = i;
-                        k++;
-                        if( !k )
-                        {
-                                b.append( b.begin(), i );
-                                break;
-                        }
-                        i = k;
-                }
-                Bu::String l;
-                l.set( b.begin() );
-                unitTest( l == "thisthisthisthi" );
-                for( Bu::String::iterator i = b.begin(); i;)
-                {
-                        Bu::String::iterator k = i;
-                        k++;
-                        if( !k )
-                        {
-                                b.append( b.begin(), i );
-                                break;
-                        }
-                        i = k;
-                }
-                l.set( b.begin() );
-                unitTest( l == "thisthisthisthithisthisthisth" );
-        }
-
-        test isSet1
-        {
-                Bu::String bob;
-
-                unitTest( bob.isSet() == false );
-                bob = "something";
-                unitTest( bob.isSet() == true );
-                bob = "";
-                unitTest( bob.isSet() == false );
-        }
-
-        test swap1
-        {
-                Bu::String a, b;
-                a = "Goodbye";
-                b = "Hello";
-                Bu::swap( a, b );
-                unitTest( a == "Hello" );
-                unitTest( b == "Goodbye" );
-        }
-
-        test swap2
-        {
-                Bu::String a, b;
-                a = "Goodbye";
-                b = "Hello";
-                std::swap( a, b );
-                unitTest( a == "Hello" );
-                unitTest( b == "Goodbye" );
-        }
-
-        test replace1
-        {
-                Bu::String a;
-                a = "This is a test.";
-                unitTest( a.replace("i", "ooo") == "Thooos ooos a test." );
-        }
-
-        test replace2
-        {
-                Bu::String a;
-                a = "aaaboostuffb";
-                unitTest( a.replace("boo", "/") == "aaa/stuffb" );
-        }
-
-        test coreDerefBug1
-        {
-                Bu::String a, b;
-                a = "bob";
-                a.setSize( 0 );
-                b = a;
-                b.getStr();
-        }
-
-        test padding1
-        {
-                Bu::String a;
-                a.append('a');
-                a.append('b');
-                a.append('c');
-                a.append("hello");
-                a.clear();
-        }
-
-        test padding2
-        {
-                Bu::String src("It's all sorts of things");
-                Bu::String::const_iterator i = src.find('a');
-                Bu::String::const_iterator j = src.find('f');
-                Bu::String a, b;
-                a.append( i );
-                i += 2;
-                a.append( i, j );
-                a.append('a');
-                a.append('b');
-                a.append('c');
-                a.append("hello");
-                a.append( src );
-                b = a;
-                a.clear();
-        }
-
-        test append
-        {
-                // This is the byte sequence that caused += to die
-                //      03 F0 9C A4 F5 8A C8 CA 0E
-                uint8_t b;
-                Bu::String m1;
-                b = 0x03; m1 += (char)b;
-                b = 0xF0; m1 += (char)b;
-                b = 0x9C; m1 += (char)b;
-                b = 0xA4; m1 += (char)b;
-                b = 0xF5; m1 += (char)b;
-                b = 0x8A; m1 += (char)b;
-                b = 0xC8; m1 += (char)b;
-                b = 0xCA; m1 += (char)b;
-                b = 0x0E; m1 += (char)b;
-
-                Bu::String m2;
-                b = 0x03; m2.append( (const char *)&b, 1 );
-                b = 0xF0; m2.append( (const char *)&b, 1 );
-                b = 0x9C; m2.append( (const char *)&b, 1 );
-                b = 0xA4; m2.append( (const char *)&b, 1 );
-                b = 0xF5; m2.append( (const char *)&b, 1 );
-                b = 0x8A; m2.append( (const char *)&b, 1 );
-                b = 0xC8; m2.append( (const char *)&b, 1 );
-                b = 0xCA; m2.append( (const char *)&b, 1 );
-                b = 0x0E; m2.append( (const char *)&b, 1 );
-
-                unitTest( m1 == m2 );
-                unitTest( m1 == "\x03\xF0\x9C\xA4\xF5\x8A\xC8\xCA\x0E" );
-        }
-
-        test toUpper1
-        {
-                Bu::String s1("HeLlO ThErE, HoW ArE YoU DoInG?");
-                unitTest( s1.toUpper() == "HELLO THERE, HOW ARE YOU DOING?" );
-                unitTest( s1 == "HeLlO ThErE, HoW ArE YoU DoInG?" );
-        }
-
-        test toLower1
-        {
-                Bu::String s1("HeLlO ThErE, HoW ArE YoU DoInG?");
-                unitTest( s1.toLower() == "hello there, how are you doing?" );
-                unitTest( s1 == "HeLlO ThErE, HoW ArE YoU DoInG?" );
-        }
-
-        test trimWhitespace1
-        {
-                unitTest( Bu::String("Hello there").trimWhitespace()
-                        == "Hello there" );
-                unitTest( Bu::String(" \t\r\r\nHello there").trimWhitespace()
-                        == "Hello there" );
-                unitTest( Bu::String("Hello there \r\n\n\t\t ").trimWhitespace()
-                        == "Hello there" );
-                unitTest( Bu::String(" \tHello there\r\n \t").trimWhitespace()
-                        == "Hello there" );
-                unitTest( Bu::String("   \t\t\r\n").trimWhitespace() == "" );
-                unitTest( Bu::String().trimWhitespace() == "" );
-                unitTest( Bu::String(" \tHello   \t\t\r\nthere\r\n \t").trimWhitespace()
-                        == "Hello   \t\t\r\nthere" );
-        }
-
-        test format1
-        {
-                unitTest( (Bu::String)Bu::String("%1").arg( 12, Bu::Fmt().width(3) ) == " 12" );
-                unitTest( (Bu::String)Bu::String("%1 %2").arg("IQ").arg(4, Bu::Fmt().plus()) == "IQ +4" );
-                unitTest( (Bu::String)Bu::String("%1%2").arg("IQ").arg(4, Bu::Fmt().plus()) == "IQ+4" );
-                unitTest( (Bu::String)Bu::String("Sup #%1-Guy!").arg( 1 ) == "Sup #1-Guy!" );
-        }
-
-        test format2
-        {
-                unitTest( Bu::String("0x%{1}00").arg( 75, Bu::Fmt::hex() ).end() == "0x4B00" );
-        }
+    test compare1
+    {
+        Bu::String b("Bob");
+        unitTest( !(b == "Bobo") );
+        unitTest( b == "Bob" );
+    }
+
+    test compare2
+    {
+        Bu::String b("Bobo");
+        unitTest( !(b == "Bob") );
+        unitTest( b == "Bobo" );
+    }
+
+    test appendSingle
+    {
+        Bu::String b;
+        for( char l = 'a'; l < 'g'; l++ )
+            b += l;
+        unitTest( b == "abcdef" );
+        unitTest( strcmp( b.getStr(), "abcdef" ) == 0 );
+    }
+
+    test shared1
+    {
+        Bu::String a("Hey there");
+        Bu::String b( a );
+        unitTest( a.getConstStr() == b.getConstStr() );
+        b += " guy";
+        unitTest( a.getConstStr() != b.getConstStr() );
+        a = b;
+        unitTest( a.getConstStr() == b.getConstStr() );
+    }
+
+    test insert
+    {
+        Bu::String a("abcd");
+        a.insert( 2, "-!-", 3 );
+        unitTest( a == "ab-!-cd" );
+        
+        a.insert( 0, "!!", 2 );
+        unitTest( a == "!!ab-!-cd" );
+        
+        a.insert( -10, "789", 3 );
+        unitTest( a == "789!!ab-!-cd" );
+        
+        a.insert( 12, "89", 2 );
+        unitTest( a == "789!!ab-!-cd89" );
+        
+        a.insert( 1203, "12", 2 );
+        unitTest( a == "789!!ab-!-cd8912" );
+    }
+
+    test remove
+    {
+        Bu::String a("abHEYcd");
+        a.remove( 2, 3 );
+        unitTest( a == "abcd" );
+        a.remove( 2, 5 );
+        unitTest( a == "ab" );
+        a += "cdefghijklmnop";
+        a.remove( 5, 1 );
+        unitTest( a == "abcdeghijklmnop" );
+    }
+
+    test add1
+    {
+        Bu::String a("hi there");
+        Bu::String b(", yeah!");
+        Bu::String c = a + b;
+
+        unitTest( c == "hi there, yeah!" );
+    }
+
+    test add2
+    {
+        Bu::String a("hi there");
+        Bu::String c = a + ", yeah!";
+
+        unitTest( c == "hi there, yeah!" );
+    }
+
+    test add3
+    {
+        Bu::String a("hi there");
+        Bu::String b(", yeah!");
+        Bu::String c = a + ", Mr. Man" + b;
+
+        unitTest( c == "hi there, Mr. Man, yeah!" );
+    }
+
+    test add4
+    {
+        Bu::String b(", yeah!");
+        Bu::String c = "hi there" + b;
+
+        unitTest( c == "hi there, yeah!" );
+    }
+
+    test add5
+    {
+        Bu::String b;
+        Bu::String c = "sup?";
+        b += "hey, " + c;
+        
+        unitTest( b == "hey, sup?" );
+    }
+
+    test add6
+    {
+        Bu::String a("Hello");
+        char b[256] = {"Dude"};
+        Bu::String c = a + "/" + b;
+
+        unitTest( c == "Hello/Dude" );
+    }
+
+    test add7
+    {
+        const Bu::String a("hello ");
+        Bu::String b(" how ");
+        unitTest( a == "hello " );
+        unitTest( a + "dude" == "hello dude" );
+        unitTest( a + "dude" + b + "are you?" == "hello dude how are you?" );
+    }
+
+    test subStr1
+    {
+        Bu::String a("abcdefghijklmnop");
+        Bu::String::iterator i = a.find('f');
+        unitTest( a.getSubStr( i, Bu::String::iterator() ) == "fghijklmnop" );
+        Bu::String::iterator j = i.find('l');
+        unitTest( a.getSubStr( i, j ) == "fghijk" );
+    }
+
+    test compareSub1
+    {
+        Bu::String a("just a string.");
+        unitTest( a.compareSub("a ", 5, 2) == true );
+        unitTest( a.compareSub("string.aoeu", 7, 11 ) == false );
+        unitTest( a.compareSub("string.aoeu", 7, 3 ) == true );
+    }
+
+    test compareSub2
+    {
+        Bu::String a("just a string.");
+        unitTest( a.compareSub(Bu::String("a "), 5, 2) == true );
+        unitTest( a.compareSub(Bu::String("string.aoeu"), 7, 11 ) == false );
+        unitTest( a.compareSub(Bu::String("string.aoeu"), 7, 3 ) == true );
+    }
+
+    test iterator1
+    {
+        Bu::String a("This is a test.");
+        Bu::String b;
+        for( Bu::String::iterator i = a.begin(); i; i++ )
+        {
+            b += *i;
+        }
+        unitTest( a == b );
+    }
+
+    test iteratorCompare1
+    {
+        Bu::String a("This is a test.");
+        Bu::String b("--This is a test.");
+        Bu::String::iterator ai = a.begin();
+        Bu::String::iterator bi = b.begin();
+        unitTest( ai.compare( bi ) == false );
+        unitTest( bi.compare( ai ) == false );
+        bi++; bi++;
+        unitTest( ai.compare( bi ) == true );
+        unitTest( bi.compare( ai ) == true );
+        b += "hi";
+        unitTest( ai.compare( bi ) == false );
+        unitTest( bi.compare( ai ) == false );
+    }
+
+    test iteratorCompare2
+    {
+        Bu::String a("1234honour");
+        Bu::String b("--1234ueje");
+        Bu::String::iterator ai = a.begin();
+        Bu::String::iterator bi = b.begin();
+        unitTest( ai.compare( bi, 4 ) == false );
+        unitTest( bi.compare( ai, 4 ) == false );
+        bi++; bi++;
+        unitTest( ai.compare( bi, 4 ) == true );
+        unitTest( bi.compare( ai, 4 ) == true );
+        unitTest( ai.compare( bi, 5 ) == false );
+        unitTest( bi.compare( ai, 5 ) == false );
+        
+        a = "fell";
+        b = "-felloo";
+        ai = a.begin();
+        bi = b.begin()+1;
+        unitTest( ai.compare( bi, 4 ) == true );
+        ai++;
+        bi++;
+        unitTest( ai.compare( bi, 4 ) == false );
+    }
+
+    test iteratorCompare3
+    {
+        Bu::String a("1234aoeu");
+        Bu::String::iterator ai = a.begin();
+        unitTest( ai.compare("1234") == false );
+        unitTest( ai.compare("1234aoeu") == true );
+        unitTest( ai.compare("1234aoeuee") == false );
+        ai += 4;
+        unitTest( ai.compare("aoeu") == true );
+        unitTest( ai.compare("aoeubo") == false );
+        unitTest( ai.compare("aoe") == false );
+        unitTest( ai.compare("wrong") == false );
+        unitTest( ai.compare("boeu") == false );
+    }
+
+    test iteratorCompare4
+    {
+        Bu::String a("1234aoeu");
+        Bu::String::iterator ai = a.begin();
+        unitTest( ai.compare("1234", 4) == true );
+        unitTest( ai.compare("1234aoeu", 8) == true );
+        unitTest( ai.compare("1234aoeuee", 10) == false );
+    }
+
+    test iteratorCompare5
+    {
+        Bu::String a("1234aoeu");
+        Bu::String b("34ao");
+        Bu::String::iterator ai = a.begin();
+        unitTest( ai.compare( b ) == false );
+        ai += 2;
+        unitTest( ai.compare( b ) == false );
+        b = "oeu";
+        ai += 3;
+        unitTest( ai.compare( b ) == true );
+        b += "boo";
+        unitTest( ai.compare( b ) == false );
+    }
+
+    test iteratorCompare6
+    {
+        Bu::String a("1234aoeu");
+        Bu::String::iterator ai = a.begin();
+        unitTest( ai.compare( Bu::String("1234"), 4) == true );
+        unitTest( ai.compare( Bu::String("1234aoeu"), 8) == true );
+        unitTest( ai.compare( Bu::String("1234aoeuee"), 10) == false );
+    }
+
+    test const_iteratorCompare1
+    {
+        Bu::String a("This is a test.");
+        Bu::String b("--This is a test.");
+        Bu::String::const_iterator ai = a.begin();
+        Bu::String::const_iterator bi = b.begin();
+        unitTest( ai.compare( bi ) == false );
+        unitTest( bi.compare( ai ) == false );
+        bi++; bi++;
+        unitTest( ai.compare( bi ) == true );
+        unitTest( bi.compare( ai ) == true );
+        b += "hi";
+        unitTest( ai.compare( bi ) == false );
+        unitTest( bi.compare( ai ) == false );
+    }
+
+    test const_iteratorCompare2
+    {
+        Bu::String a("1234honour");
+        Bu::String b("--1234ueje");
+        Bu::String::const_iterator ai = a.begin();
+        Bu::String::const_iterator bi = b.begin();
+        unitTest( ai.compare( bi, 4 ) == false );
+        unitTest( bi.compare( ai, 4 ) == false );
+        bi++; bi++;
+        unitTest( ai.compare( bi, 4 ) == true );
+        unitTest( bi.compare( ai, 4 ) == true );
+        unitTest( ai.compare( bi, 5 ) == false );
+        unitTest( bi.compare( ai, 5 ) == false );
+        
+        a = "fell";
+        b = "-felloo";
+        ai = a.begin();
+        bi = b.begin()+1;
+        unitTest( ai.compare( bi, 4 ) == true );
+        ai++;
+        bi++;
+        unitTest( ai.compare( bi, 4 ) == false );
+    }
+
+    test const_iteratorCompare3
+    {
+        Bu::String a("1234aoeu");
+        Bu::String::const_iterator ai = a.begin();
+        unitTest( ai.compare("1234") == false );
+        unitTest( ai.compare("1234aoeu") == true );
+        unitTest( ai.compare("1234aoeuee") == false );
+        ai += 4;
+        unitTest( ai.compare("aoeu") == true );
+        unitTest( ai.compare("aoeubo") == false );
+        unitTest( ai.compare("aoe") == false );
+        unitTest( ai.compare("wrong") == false );
+        unitTest( ai.compare("boeu") == false );
+    }
+
+    test const_iteratorCompare4
+    {
+        Bu::String a("1234aoeu");
+        Bu::String::const_iterator ai = a.begin();
+        unitTest( ai.compare("1234", 4) == true );
+        unitTest( ai.compare("1234aoeu", 8) == true );
+        unitTest( ai.compare("1234aoeuee", 10) == false );
+    }
+
+    test const_iteratorCompare5
+    {
+        Bu::String a("1234aoeu");
+        Bu::String b("34ao");
+        Bu::String::const_iterator ai = a.begin();
+        unitTest( ai.compare( b ) == false );
+        ai += 2;
+        unitTest( ai.compare( b ) == false );
+        b = "oeu";
+        ai += 3;
+        unitTest( ai.compare( b ) == true );
+        b += "boo";
+        unitTest( ai.compare( b ) == false );
+    }
+
+    test const_iteratorCompare6
+    {
+        Bu::String a("1234aoeu");
+        Bu::String::const_iterator ai = a.begin();
+        unitTest( ai.compare( Bu::String("1234"), 4) == true );
+        unitTest( ai.compare( Bu::String("1234aoeu"), 8) == true );
+        unitTest( ai.compare( Bu::String("1234aoeuee"), 10) == false );
+    }
+
+    test iteratorAppend1
+    {
+        Bu::String a("just ->this part");
+        Bu::String b;
+        Bu::String::iterator s = a.begin();
+        for(; s; s++ )
+        {
+            if( *s == '>' )
+            {
+                s++;
+                b.set( s );
+                break;
+            }
+        }
+        unitTest( b == "this part" );
+
+        b.append( s );
+
+        Bu::String c;
+        c.set( b.begin() );
+
+        // This is here because the comparison operator used to cause flattening.
+        unitTest( b == "this partthis part" );
+        unitTest( c == b );
+    }
+
+    test iteratorAppend2
+    {
+        Bu::String a("just [this] part");
+        Bu::String b;
+        Bu::String::iterator s = a.begin();
+        for(; s; s++ )
+        {
+            if( *s == '[' )
+            {
+                s++;
+                break;
+            }
+        }
+        Bu::String::iterator e = s;
+        for(; e; e++ )
+        {
+            if( *e == ']' )
+            {
+                b.set( s, e );
+                break;
+            }
+        }
+        unitTest( b == "this" );
+
+        b.append( s, e );
+
+        for( Bu::String::iterator i = b.begin(); i;)
+        {
+            Bu::String::iterator k = i;
+            k++;
+            if( !k )
+            {
+                b.append( b.begin(), i );
+                break;
+            }
+            i = k;
+        }
+        Bu::String l;
+        l.set( b.begin() );
+        unitTest( l == "thisthisthisthi" );
+        for( Bu::String::iterator i = b.begin(); i;)
+        {
+            Bu::String::iterator k = i;
+            k++;
+            if( !k )
+            {
+                b.append( b.begin(), i );
+                break;
+            }
+            i = k;
+        }
+        l.set( b.begin() );
+        unitTest( l == "thisthisthisthithisthisthisth" );
+    }
+
+    test isSet1
+    {
+        Bu::String bob;
+
+        unitTest( bob.isSet() == false );
+        bob = "something";
+        unitTest( bob.isSet() == true );
+        bob = "";
+        unitTest( bob.isSet() == false );
+    }
+
+    test swap1
+    {
+        Bu::String a, b;
+        a = "Goodbye";
+        b = "Hello";
+        Bu::swap( a, b );
+        unitTest( a == "Hello" );
+        unitTest( b == "Goodbye" );
+    }
+
+    test swap2
+    {
+        Bu::String a, b;
+        a = "Goodbye";
+        b = "Hello";
+        std::swap( a, b );
+        unitTest( a == "Hello" );
+        unitTest( b == "Goodbye" );
+    }
+
+    test replace1
+    {
+        Bu::String a;
+        a = "This is a test.";
+        unitTest( a.replace("i", "ooo") == "Thooos ooos a test." );
+    }
+
+    test replace2
+    {
+        Bu::String a;
+        a = "aaaboostuffb";
+        unitTest( a.replace("boo", "/") == "aaa/stuffb" );
+    }
+
+    test coreDerefBug1
+    {
+        Bu::String a, b;
+        a = "bob";
+        a.setSize( 0 );
+        b = a;
+        b.getStr();
+    }
+
+    test padding1
+    {
+        Bu::String a;
+        a.append('a');
+        a.append('b');
+        a.append('c');
+        a.append("hello");
+        a.clear();
+    }
+
+    test padding2
+    {
+        Bu::String src("It's all sorts of things");
+        Bu::String::const_iterator i = src.find('a');
+        Bu::String::const_iterator j = src.find('f');
+        Bu::String a, b;
+        a.append( i );
+        i += 2;
+        a.append( i, j );
+        a.append('a');
+        a.append('b');
+        a.append('c');
+        a.append("hello");
+        a.append( src );
+        b = a;
+        a.clear();
+    }
+
+    test append
+    {
+        // This is the byte sequence that caused += to die
+        //  03 F0 9C A4 F5 8A C8 CA 0E
+        uint8_t b;
+        Bu::String m1;
+        b = 0x03; m1 += (char)b;
+        b = 0xF0; m1 += (char)b;
+        b = 0x9C; m1 += (char)b;
+        b = 0xA4; m1 += (char)b;
+        b = 0xF5; m1 += (char)b;
+        b = 0x8A; m1 += (char)b;
+        b = 0xC8; m1 += (char)b;
+        b = 0xCA; m1 += (char)b;
+        b = 0x0E; m1 += (char)b;
+
+        Bu::String m2;
+        b = 0x03; m2.append( (const char *)&b, 1 );
+        b = 0xF0; m2.append( (const char *)&b, 1 );
+        b = 0x9C; m2.append( (const char *)&b, 1 );
+        b = 0xA4; m2.append( (const char *)&b, 1 );
+        b = 0xF5; m2.append( (const char *)&b, 1 );
+        b = 0x8A; m2.append( (const char *)&b, 1 );
+        b = 0xC8; m2.append( (const char *)&b, 1 );
+        b = 0xCA; m2.append( (const char *)&b, 1 );
+        b = 0x0E; m2.append( (const char *)&b, 1 );
+
+        unitTest( m1 == m2 );
+        unitTest( m1 == "\x03\xF0\x9C\xA4\xF5\x8A\xC8\xCA\x0E" );
+    }
+
+    test toUpper1
+    {
+        Bu::String s1("HeLlO ThErE, HoW ArE YoU DoInG?");
+        unitTest( s1.toUpper() == "HELLO THERE, HOW ARE YOU DOING?" );
+        unitTest( s1 == "HeLlO ThErE, HoW ArE YoU DoInG?" );
+    }
+
+    test toLower1
+    {
+        Bu::String s1("HeLlO ThErE, HoW ArE YoU DoInG?");
+        unitTest( s1.toLower() == "hello there, how are you doing?" );
+        unitTest( s1 == "HeLlO ThErE, HoW ArE YoU DoInG?" );
+    }
+
+    test trimWhitespace1
+    {
+        unitTest( Bu::String("Hello there").trimWhitespace()
+            == "Hello there" );
+        unitTest( Bu::String(" \t\r\r\nHello there").trimWhitespace()
+            == "Hello there" );
+        unitTest( Bu::String("Hello there \r\n\n\t\t ").trimWhitespace()
+            == "Hello there" );
+        unitTest( Bu::String(" \tHello there\r\n \t").trimWhitespace()
+            == "Hello there" );
+        unitTest( Bu::String("   \t\t\r\n").trimWhitespace() == "" );
+        unitTest( Bu::String().trimWhitespace() == "" );
+        unitTest( Bu::String(" \tHello   \t\t\r\nthere\r\n \t").trimWhitespace()
+            == "Hello   \t\t\r\nthere" );
+    }
+
+    test format1
+    {
+        unitTest( (Bu::String)Bu::String("%1").arg( 12, Bu::Fmt().width(3) ) == " 12" );
+        unitTest( (Bu::String)Bu::String("%1 %2").arg("IQ").arg(4, Bu::Fmt().plus()) == "IQ +4" );
+        unitTest( (Bu::String)Bu::String("%1%2").arg("IQ").arg(4, Bu::Fmt().plus()) == "IQ+4" );
+        unitTest( (Bu::String)Bu::String("Sup #%1-Guy!").arg( 1 ) == "Sup #1-Guy!" );
+    }
+
+    test format2
+    {
+        unitTest( Bu::String("0x%{1}00").arg( 75, Bu::Fmt::hex() ).end() == "0x4B00" );
+    }
 }
 // 03F09CA4F58AC8CA0E80F0D9D409D0A60700A192270004BC3A99E91D0001034F544603362E35013103313130019CA4F58AC8CA0E0002830800002C4200008AC200EBF7D9D4090127BB010000E3
 // 
diff --git a/src/unit/substream.unit b/src/unit/substream.unit
index c66238d..b0d1407 100644
--- a/src/unit/substream.unit
+++ b/src/unit/substream.unit
@@ -11,42 +11,42 @@
 
 suite SubStream
 {
-        test testRead01
-        {
-                Bu::MemBuf mb("abcdefghijklmnopqrstuvwxyz");
-                mb.seek( 4 );
-                Bu::SubStream ss( mb, 10 );
-                unitTest( ss.readLine() == "efghijklmn" );
-        }
+    test testRead01
+    {
+        Bu::MemBuf mb("abcdefghijklmnopqrstuvwxyz");
+        mb.seek( 4 );
+        Bu::SubStream ss( mb, 10 );
+        unitTest( ss.readLine() == "efghijklmn" );
+    }
 
-        test testRead02
-        {
-                Bu::MemBuf mb("abcdefghijklmnopqrstuvwxyz");
-                mb.seek( 4 );
-                Bu::SubStream ss( mb, 10 );
-                char buf[8];
-                size_t iRead = ss.read( buf, 8 );
-                unitTest( iRead == 8 );
-                unitTest( strncmp( buf, "efghijkl", 8 ) == 0 );
-                unitTest( !ss.isEos() );
-                iRead = ss.read( buf, 8 );
-                unitTest( iRead == 2 );
-                unitTest( strncmp( buf, "mn", 2 ) == 0 );
-                unitTest( ss.isEos() );
-        }
+    test testRead02
+    {
+        Bu::MemBuf mb("abcdefghijklmnopqrstuvwxyz");
+        mb.seek( 4 );
+        Bu::SubStream ss( mb, 10 );
+        char buf[8];
+        size_t iRead = ss.read( buf, 8 );
+        unitTest( iRead == 8 );
+        unitTest( strncmp( buf, "efghijkl", 8 ) == 0 );
+        unitTest( !ss.isEos() );
+        iRead = ss.read( buf, 8 );
+        unitTest( iRead == 2 );
+        unitTest( strncmp( buf, "mn", 2 ) == 0 );
+        unitTest( ss.isEos() );
+    }
 
-        test testRead03
-        {
-                Bu::MemBuf mb("abcdefghijklmnopqrstuvwxyz");
-                mb.seek( 20 );
-                Bu::SubStream ss( mb, 10 );
-                char buf[8];
-                size_t iRead = ss.read( buf, 8 );
-                unitTest( iRead == 6 );
-                unitTest( strncmp( buf, "uvwxyz", 6 ) == 0 );
-                unitTest( ss.isEos() );
-                iRead = ss.read( buf, 8 );
-                unitTest( iRead == 0 );
-                unitTest( ss.isEos() );
-        }
+    test testRead03
+    {
+        Bu::MemBuf mb("abcdefghijklmnopqrstuvwxyz");
+        mb.seek( 20 );
+        Bu::SubStream ss( mb, 10 );
+        char buf[8];
+        size_t iRead = ss.read( buf, 8 );
+        unitTest( iRead == 6 );
+        unitTest( strncmp( buf, "uvwxyz", 6 ) == 0 );
+        unitTest( ss.isEos() );
+        iRead = ss.read( buf, 8 );
+        unitTest( iRead == 0 );
+        unitTest( ss.isEos() );
+    }
 }
diff --git a/src/unit/taf.unit b/src/unit/taf.unit
index 12e93c2..47605ee 100644
--- a/src/unit/taf.unit
+++ b/src/unit/taf.unit
@@ -15,64 +15,64 @@
 
 suite Taf
 {
-        test read1
-        {
+    test read1
+    {
 #define FN_TMP ("/tmp/tmpXXXXXXXX")
-                Bu::String sFnTmp(FN_TMP);
-                Bu::File fOut = Bu::File::tempFile( sFnTmp );
-                const char *data =
-                        "{test: name=\"Bob\"}"
-                        ;
-                fOut.write(data,strlen(data));
-                fOut.close();
+        Bu::String sFnTmp(FN_TMP);
+        Bu::File fOut = Bu::File::tempFile( sFnTmp );
+        const char *data =
+            "{test: name=\"Bob\"}"
+            ;
+        fOut.write(data,strlen(data));
+        fOut.close();
 
-                Bu::File fIn(sFnTmp.getStr(), Bu::File::Read );
-                Bu::TafReader tr(fIn);
-                
-                Bu::TafGroup *tn = tr.readGroup();
-                unitTest( !strcmp("Bob", tn->getProperty("name").getStr()) );
-                delete tn;
+        Bu::File fIn(sFnTmp.getStr(), Bu::File::Read );
+        Bu::TafReader tr(fIn);
+        
+        Bu::TafGroup *tn = tr.readGroup();
+        unitTest( !strcmp("Bob", tn->getProperty("name").getStr()) );
+        delete tn;
 
-                unlink(sFnTmp.getStr());
+        unlink(sFnTmp.getStr());
 #undef FN_TMP
-        }
+    }
 
-        test encode1
-        {
-                Bu::MemBuf mb;
-                Bu::TafWriter tw( mb );
-                
-                Bu::TafGroup g("Test data");
-                Bu::String sData( 256 );
-                for( int j = 0; j < 256; j++ )
-                        sData[j] = (unsigned char)j;
-                g.addChild( new Bu::TafProperty("Encoded", sData) );
-                tw.writeGroup( &g );
+    test encode1
+    {
+        Bu::MemBuf mb;
+        Bu::TafWriter tw( mb );
+        
+        Bu::TafGroup g("Test data");
+        Bu::String sData( 256 );
+        for( int j = 0; j < 256; j++ )
+            sData[j] = (unsigned char)j;
+        g.addChild( new Bu::TafProperty("Encoded", sData) );
+        tw.writeGroup( &g );
 
-                static const char *cmpdata = "{\"Test data\":\n    \"Encoded\"=\""
+        static const char *cmpdata = "{\"Test data\":\n    \"Encoded\"=\""
                         "\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07"
                         "\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\\x0F"
                         "\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17"
                         "\\x18\\x19\\x1A\\x1B\\x1C\\x1D\\x1E\\x1F"
                         " !\\\"#$%&'()*+,-./0123456789:;<=>?@ABCD"
-                        "EFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghi"
-                        "jklmnopqrstuvwxyz{|}~\\x7F"
-                        "\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87"
-                        "\\x88\\x89\\x8A\\x8B\\x8C\\x8D\\x8E\\x8F"
-                        "\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97"
-                        "\\x98\\x99\\x9A\\x9B\\x9C\\x9D\\x9E\\x9F"
-                        "\\xA0\\xA1\\xA2\\xA3\\xA4\\xA5\\xA6\\xA7"
-                        "\\xA8\\xA9\\xAA\\xAB\\xAC\\xAD\\xAE\\xAF"
-                        "\\xB0\\xB1\\xB2\\xB3\\xB4\\xB5\\xB6\\xB7"
-                        "\\xB8\\xB9\\xBA\\xBB\\xBC\\xBD\\xBE\\xBF"
-                        "\\xC0\\xC1\\xC2\\xC3\\xC4\\xC5\\xC6\\xC7"
-                        "\\xC8\\xC9\\xCA\\xCB\\xCC\\xCD\\xCE\\xCF"
-                        "\\xD0\\xD1\\xD2\\xD3\\xD4\\xD5\\xD6\\xD7"
-                        "\\xD8\\xD9\\xDA\\xDB\\xDC\\xDD\\xDE\\xDF"
-                        "\\xE0\\xE1\\xE2\\xE3\\xE4\\xE5\\xE6\\xE7"
-                        "\\xE8\\xE9\\xEA\\xEB\\xEC\\xED\\xEE\\xEF"
-                        "\\xF0\\xF1\\xF2\\xF3\\xF4\\xF5\\xF6\\xF7"
-                        "\\xF8\\xF9\\xFA\\xFB\\xFC\\xFD\\xFE\\xFF\"\n}\n";
+            "EFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghi"
+            "jklmnopqrstuvwxyz{|}~\\x7F"
+            "\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87"
+            "\\x88\\x89\\x8A\\x8B\\x8C\\x8D\\x8E\\x8F"
+            "\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97"
+            "\\x98\\x99\\x9A\\x9B\\x9C\\x9D\\x9E\\x9F"
+            "\\xA0\\xA1\\xA2\\xA3\\xA4\\xA5\\xA6\\xA7"
+            "\\xA8\\xA9\\xAA\\xAB\\xAC\\xAD\\xAE\\xAF"
+            "\\xB0\\xB1\\xB2\\xB3\\xB4\\xB5\\xB6\\xB7"
+            "\\xB8\\xB9\\xBA\\xBB\\xBC\\xBD\\xBE\\xBF"
+            "\\xC0\\xC1\\xC2\\xC3\\xC4\\xC5\\xC6\\xC7"
+            "\\xC8\\xC9\\xCA\\xCB\\xCC\\xCD\\xCE\\xCF"
+            "\\xD0\\xD1\\xD2\\xD3\\xD4\\xD5\\xD6\\xD7"
+            "\\xD8\\xD9\\xDA\\xDB\\xDC\\xDD\\xDE\\xDF"
+            "\\xE0\\xE1\\xE2\\xE3\\xE4\\xE5\\xE6\\xE7"
+            "\\xE8\\xE9\\xEA\\xEB\\xEC\\xED\\xEE\\xEF"
+            "\\xF0\\xF1\\xF2\\xF3\\xF4\\xF5\\xF6\\xF7"
+            "\\xF8\\xF9\\xFA\\xFB\\xFC\\xFD\\xFE\\xFF\"\n}\n";
                 unitTest( mb.getString() == cmpdata );
                 mb.setPos( 0 );
                 Bu::TafReader tr( mb );
diff --git a/src/unit/variant.unit b/src/unit/variant.unit
index 684bea1..68c7be5 100644
--- a/src/unit/variant.unit
+++ b/src/unit/variant.unit
@@ -16,46 +16,46 @@ using namespace Bu;
 
 Bu::String mkastring()
 {
-        Bu::String a = "s";
-        a += "tu";
-        a += "f";
-        a += "f";
-        return a;
+    Bu::String a = "s";
+    a += "tu";
+    a += "f";
+    a += "f";
+    return a;
 }
 
 suite Variant
 {
-        test construction
-        {
-                Bu::Variant v( 55 );
-                v.get<int>();
+    test construction
+    {
+        Bu::Variant v( 55 );
+        v.get<int>();
 
-                Bu::Variant v2( v );
-                v2.get<int>();
-        }
+        Bu::Variant v2( v );
+        v2.get<int>();
+    }
 
-        test formatting
-        {
-                Bu::Variant v("hello");
-                Bu::MemBuf mb;
-                Bu::Formatter f( mb );
-                f << v;
-                unitTest( mb.getString() == v.get<Bu::String>() );
-        }
+    test formatting
+    {
+        Bu::Variant v("hello");
+        Bu::MemBuf mb;
+        Bu::Formatter f( mb );
+        f << v;
+        unitTest( mb.getString() == v.get<Bu::String>() );
+    }
 
-        test stringForamtting
-        {
-                Bu::String s1;
-                s1 = "hello";
-                int32_t i1, i2;
-                i1 = 32;
-                i2 = 0;
-                Bu::String out = Bu::String("%1-%2-%3-%4.odp").
-                        arg( s1.getStr() ).
-                        arg( mkastring().getStr() ).
-                        arg( i1, Fmt(2).fill('0') ).
-                        arg( i2, Fmt(2).fill('0') );
-                // sio << sio.nl << out << sio.nl;
-                unitTest( out == "hello-stuff-32-00.odp" );
-        }
+    test stringForamtting
+    {
+        Bu::String s1;
+        s1 = "hello";
+        int32_t i1, i2;
+        i1 = 32;
+        i2 = 0;
+        Bu::String out = Bu::String("%1-%2-%3-%4.odp").
+            arg( s1.getStr() ).
+            arg( mkastring().getStr() ).
+            arg( i1, Fmt(2).fill('0') ).
+            arg( i2, Fmt(2).fill('0') );
+        // sio << sio.nl << out << sio.nl;
+        unitTest( out == "hello-stuff-32-00.odp" );
+    }
 }
diff --git a/src/unit/xml.unit b/src/unit/xml.unit
index 0db21c1..57e1c1c 100644
--- a/src/unit/xml.unit
+++ b/src/unit/xml.unit
@@ -12,10 +12,10 @@
 
 suite Xml
 {
-        test declaration
-        {
-                Bu::String sXml("<?xml ?> <hi />");
-                Bu::MemBuf buf( sXml );
-                Bu::XmlReader xr( buf );
-        }
+    test declaration
+    {
+        Bu::String sXml("<?xml ?> <hi />");
+        Bu::MemBuf buf( sXml );
+        Bu::XmlReader xr( buf );
+    }
 }
diff --git a/src/unstable/bitstring.cpp b/src/unstable/bitstring.cpp
index 9559aad..3f24ec7 100644
--- a/src/unstable/bitstring.cpp
+++ b/src/unstable/bitstring.cpp
@@ -16,460 +16,460 @@
 
 Bu::BitString::BitString()
 {
-        caData = NULL;
-        cTopByteMask = 0;
-        iBits = iBytes = 0;
+    caData = NULL;
+    cTopByteMask = 0;
+    iBits = iBytes = 0;
 }
 
 Bu::BitString::BitString( const Bu::BitString &xSrc )
 {
-        iBits = xSrc.iBits;
-        iBytes = xSrc.iBytes;
-        cTopByteMask = xSrc.cTopByteMask;
-        caData = new unsigned char[iBytes];
-        memcpy( caData, xSrc.caData, iBytes );
+    iBits = xSrc.iBits;
+    iBytes = xSrc.iBytes;
+    cTopByteMask = xSrc.cTopByteMask;
+    caData = new unsigned char[iBytes];
+    memcpy( caData, xSrc.caData, iBytes );
 
-        fixup();
+    fixup();
 }
 
 Bu::BitString::BitString( long iNewBits, bool bFillRandomly )
 {
-        long j;
-        iBits = iNewBits;
-        iBytes = bitsToBytes( iNewBits );//(iNewBits/8)+((iNewBits%8)?(1):(0));
-        caData = new unsigned char[iBytes];
-
-        setMask();
-
-        if( bFillRandomly )
-        {
-                // rand() only returns a value up to RAND_MAX (0x7FFF on my system) so
-                // I'll just use the low order byte)
-                for( j = 0; j < iBytes; j++ )
-                {
-                        caData[j] = (unsigned char)(Bu::Random::rand() & 0xFF);
-                }
-        }
-        else
-        {
-                clear();
-        }
-
-        fixup();
+    long j;
+    iBits = iNewBits;
+    iBytes = bitsToBytes( iNewBits );//(iNewBits/8)+((iNewBits%8)?(1):(0));
+    caData = new unsigned char[iBytes];
+
+    setMask();
+
+    if( bFillRandomly )
+    {
+        // rand() only returns a value up to RAND_MAX (0x7FFF on my system) so
+        // I'll just use the low order byte)
+        for( j = 0; j < iBytes; j++ )
+        {
+            caData[j] = (unsigned char)(Bu::Random::rand() & 0xFF);
+        }
+    }
+    else
+    {
+        clear();
+    }
+
+    fixup();
 }
 
 Bu::BitString::~BitString()
 {
-        if( caData != NULL ) delete[] caData;
+    if( caData != NULL ) delete[] caData;
 }
 
 Bu::BitString &Bu::BitString::operator=( const Bu::BitString &xSrc )
 {
-        if( caData != NULL )
-        {
-                delete[] caData;
-        }
-        iBits = xSrc.iBits;
-        iBytes = xSrc.iBytes;
-        cTopByteMask = xSrc.cTopByteMask;
-        caData = new unsigned char[iBytes];
-        memcpy( caData, xSrc.caData, iBytes );
-
-        fixup();
-
-        return *this;
+    if( caData != NULL )
+    {
+        delete[] caData;
+    }
+    iBits = xSrc.iBits;
+    iBytes = xSrc.iBytes;
+    cTopByteMask = xSrc.cTopByteMask;
+    caData = new unsigned char[iBytes];
+    memcpy( caData, xSrc.caData, iBytes );
+
+    fixup();
+
+    return *this;
 }
 
 Bu::BitString Bu::BitString::operator~()
 {
-        Bu::BitString xRet( *this );
+    Bu::BitString xRet( *this );
 
-        for( int j = 0; j < xRet.iBytes; j++ )
-        {
-                xRet.caData[j] = ~xRet.caData[j];
-        }
+    for( int j = 0; j < xRet.iBytes; j++ )
+    {
+        xRet.caData[j] = ~xRet.caData[j];
+    }
 
-        xRet.fixup();
+    xRet.fixup();
 
-        return xRet;
+    return xRet;
 }
 
 Bu::BitString Bu::BitString::operator<<( const long iAmt )
 {
-        if( iAmt == 0 )
-        {
-                return (*this);
-        }
-        //int iByteShift = iAmt/8;
-
-        Bu::BitString xSub( getSize() );
-
-        long shft = (iAmt%8);
-        long base = (iAmt/8);
-        unsigned char lowmask=0;
-        for( long j = 0; j < 8-shft; j++ )
-        {
-                lowmask |= (1<<j);
-        }
-        for( long j = 0; j < xSub.iBytes; j++ )
-        {
-                xSub.caData[base+j] = ((caData[j]>>shft)&(lowmask)) | ((caData[j+1]<<(8-shft))&(~lowmask));
-        }
-        xSub.fixup();
-
-        return xSub;
+    if( iAmt == 0 )
+    {
+        return (*this);
+    }
+    //int iByteShift = iAmt/8;
+
+    Bu::BitString xSub( getSize() );
+
+    long shft = (iAmt%8);
+    long base = (iAmt/8);
+    unsigned char lowmask=0;
+    for( long j = 0; j < 8-shft; j++ )
+    {
+        lowmask |= (1<<j);
+    }
+    for( long j = 0; j < xSub.iBytes; j++ )
+    {
+        xSub.caData[base+j] = ((caData[j]>>shft)&(lowmask)) | ((caData[j+1]<<(8-shft))&(~lowmask));
+    }
+    xSub.fixup();
+
+    return xSub;
 }
 
 Bu::BitString Bu::BitString::operator>>( const long iAmt )
 {
-        if( iAmt == 0 )
-        {
-                return (*this);
-        }
-        return (*this);
+    if( iAmt == 0 )
+    {
+        return (*this);
+    }
+    return (*this);
 }
 
 void Bu::BitString::shiftLeft( long iAmt )
 {
-        if( iAmt == 0 )
-        {
-                return;
-        }
-        else if( iAmt < 0 )
-        {
-                shiftRight( -iAmt );
-                return;
-        }
-
-        long iByteShift = iAmt/8;
-        long iBitShift = iAmt%8;
-
-        long j;
-        for( j = iBytes-1; j >= 0; j-- )
-        {
-                caData[j] = (((j-iByteShift)<0)?(0):((caData[j-iByteShift]<<iBitShift))) | (((j-iByteShift-1)<0)?(0):((caData[j-iByteShift-1]>>(8-iBitShift))));
-        }
-
-        fixup();
+    if( iAmt == 0 )
+    {
+        return;
+    }
+    else if( iAmt < 0 )
+    {
+        shiftRight( -iAmt );
+        return;
+    }
+
+    long iByteShift = iAmt/8;
+    long iBitShift = iAmt%8;
+
+    long j;
+    for( j = iBytes-1; j >= 0; j-- )
+    {
+        caData[j] = (((j-iByteShift)<0)?(0):((caData[j-iByteShift]<<iBitShift))) | (((j-iByteShift-1)<0)?(0):((caData[j-iByteShift-1]>>(8-iBitShift))));
+    }
+
+    fixup();
 }
 
 void Bu::BitString::shiftRight( long iAmt )
 {
-        if( iAmt == 0 )
-        {
-                return;
-        }
-        else if( iAmt < 0 )
-        {
-                shiftLeft( -iAmt );
-                return;
-        }
-
-        long iByteShift = iAmt/8;
-        long iBitShift = iAmt%8;
-
-        long j;
-        for( j = 0; j < iBytes; j++ )
-        {
-                caData[j] = (((j+iByteShift)>iBytes)?(0):((caData[j+iByteShift]>>iBitShift))) | (((j+iByteShift+1)>iBytes)?(0):((caData[j+iByteShift+1]<<(8-iBitShift))));
-        }
-
-        fixup();
+    if( iAmt == 0 )
+    {
+        return;
+    }
+    else if( iAmt < 0 )
+    {
+        shiftLeft( -iAmt );
+        return;
+    }
+
+    long iByteShift = iAmt/8;
+    long iBitShift = iAmt%8;
+
+    long j;
+    for( j = 0; j < iBytes; j++ )
+    {
+        caData[j] = (((j+iByteShift)>iBytes)?(0):((caData[j+iByteShift]>>iBitShift))) | (((j+iByteShift+1)>iBytes)?(0):((caData[j+iByteShift+1]<<(8-iBitShift))));
+    }
+
+    fixup();
 }
 /*
 long Bu::BitString::bitsToBytes( long iBits )
 {
-        return (iBits/8)+((iBits%8)?(1):(0));
+    return (iBits/8)+((iBits%8)?(1):(0));
 }
 */
 void Bu::BitString::fixup()
 {
-        if( caData != NULL )
-        {
-                caData[iBytes-1] &= cTopByteMask;
-        }
+    if( caData != NULL )
+    {
+        caData[iBytes-1] &= cTopByteMask;
+    }
 }
 
 void Bu::BitString::setBit( long iBit, bool bBitState )
 {
-        if( iBit < 0 || iBit >= iBits )
-                throw Bu::ExceptionBase("bit out of range: %d in (0-%d)", iBit, iBits );
-        if( bBitState )
-        {
-                caData[iBit/8] |= (1<<(iBit%8));
-        }
-        else
-        {
-                caData[iBit/8] &= ~(1<<(iBit%8));
-        }
+    if( iBit < 0 || iBit >= iBits )
+        throw Bu::ExceptionBase("bit out of range: %d in (0-%d)", iBit, iBits );
+    if( bBitState )
+    {
+        caData[iBit/8] |= (1<<(iBit%8));
+    }
+    else
+    {
+        caData[iBit/8] &= ~(1<<(iBit%8));
+    }
 }
 
 void Bu::BitString::flipBit( long iBit )
 {
-        caData[iBit/8] ^= (1<<(iBit%8));
+    caData[iBit/8] ^= (1<<(iBit%8));
 }
 
 bool Bu::BitString::getBit( long iBit )
 {
-        if( iBit >= iBits || iBit < 0 ) return false;
-        if( (caData[iBit/8] & (1<<(iBit%8))) == 0 )
-        {
-                return false;
-        }
-        return true;
+    if( iBit >= iBits || iBit < 0 ) return false;
+    if( (caData[iBit/8] & (1<<(iBit%8))) == 0 )
+    {
+        return false;
+    }
+    return true;
 }
 
 long Bu::BitString::getBitLength()
 {
-        return iBits;
+    return iBits;
 }
 
 long Bu::BitString::getSize()
 {
-        return iBits;
+    return iBits;
 }
 
 class Bu::BitString Bu::BitString::getSubString( long iLower, long iUpper )
 {
-        if( iUpper == 0 || iUpper < iLower ) iUpper = iBits;
-
-        Bu::BitString xSub( iUpper-iLower+1 );
-
-        long shft = (iLower%8);
-        long base = (iLower/8);
-        unsigned char lowmask=0;
-        for( long j = 0; j < 8-shft; j++ )
-        {
-                lowmask |= (1<<j);
-        }
-        for( long j = 0; j < xSub.iBytes; j++ )
-        {
-                xSub.caData[j] = ((caData[base+j]>>shft)&(lowmask)) | ((caData[base+j+1]<<(8-shft))&(~lowmask));
-        }
-        xSub.fixup();
-
-        return xSub;
+    if( iUpper == 0 || iUpper < iLower ) iUpper = iBits;
+
+    Bu::BitString xSub( iUpper-iLower+1 );
+
+    long shft = (iLower%8);
+    long base = (iLower/8);
+    unsigned char lowmask=0;
+    for( long j = 0; j < 8-shft; j++ )
+    {
+        lowmask |= (1<<j);
+    }
+    for( long j = 0; j < xSub.iBytes; j++ )
+    {
+        xSub.caData[j] = ((caData[base+j]>>shft)&(lowmask)) | ((caData[base+j+1]<<(8-shft))&(~lowmask));
+    }
+    xSub.fixup();
+
+    return xSub;
 }
 
 long Bu::BitString::toLong( long iStart, long iSize )
 {
-        if( iSize < 1 ) iSize = 1;
-        if( iSize > 32 ) iSize = 32;
-        if( iStart < 0 ) return 0;
-        if( iStart+iSize > getSize() ) return 0;
+    if( iSize < 1 ) iSize = 1;
+    if( iSize > 32 ) iSize = 32;
+    if( iStart < 0 ) return 0;
+    if( iStart+iSize > getSize() ) return 0;
 
-        Bu::BitString tmpo;
-        tmpo = getSubString( iStart, iStart+iSize-1 );
-        long x = *((long *)tmpo.caData);
+    Bu::BitString tmpo;
+    tmpo = getSubString( iStart, iStart+iSize-1 );
+    long x = *((long *)tmpo.caData);
 
-        return x;
+    return x;
 }
 /*
 std::string Bu::BitString::toString( bool bAddSpacers )
 {
-        long iSz = iBits;
-        if( bAddSpacers )
-        {
-                iSz += (iBits/8);
-                if( iBits%8 == 0 ) iSz--;
-        }
-        std::string xStr;
-
-        int bw=0;
-        int of=0;
-        for( int j = iBits-1; j >= 0; j-- )
-        {
-                if( getBit( j ) )
-                {
-                        xStr += '1';
-                }
-                else
-                {
-                        xStr += '0';
-                }
-
-                if( bAddSpacers )
-                {
-                        bw++;
-                        if( bw >= 8 && j < iBits-1 )
-                        {
-                                bw = 0;
-                                of++;
-                                xStr += ' ';
-                        }
-                }
-        }
-
-        return xStr;
+    long iSz = iBits;
+    if( bAddSpacers )
+    {
+        iSz += (iBits/8);
+        if( iBits%8 == 0 ) iSz--;
+    }
+    std::string xStr;
+
+    int bw=0;
+    int of=0;
+    for( int j = iBits-1; j >= 0; j-- )
+    {
+        if( getBit( j ) )
+        {
+            xStr += '1';
+        }
+        else
+        {
+            xStr += '0';
+        }
+
+        if( bAddSpacers )
+        {
+            bw++;
+            if( bw >= 8 && j < iBits-1 )
+            {
+                bw = 0;
+                of++;
+                xStr += ' ';
+            }
+        }
+    }
+
+    return xStr;
 }
 */
 void Bu::BitString::clear()
 {
-        if( caData != NULL )
-        {
-                memset( caData, 0, iBytes );
-        }
+    if( caData != NULL )
+    {
+        memset( caData, 0, iBytes );
+    }
 }
 
 bool Bu::BitString::setBitLength( long iLength, bool bClear )
 {
-        return setSize( iLength, bClear );
+    return setSize( iLength, bClear );
 }
 
 bool Bu::BitString::setSize( long iLength, bool bClear )
 {
-        // First, if there's nothing, then allocate an empty one.
-        if( caData == NULL )
-        {
-                iBits = iLength;
-                iBytes = bitsToBytes( iLength );
-                caData = new unsigned char[iBytes];
-                memset( caData, 0, iBytes );
-                return true;
-        }
-
-        // If the new length is the same as the old, don't do anything, but do
-        // check to see if we should still clear the data.
-        if( iBits != iLength )
-        {
-                // Ok, we are changing the number if bits, but are we changing the
-                // number of bytes?
-                long iNewBytes = bitsToBytes( iLength );
-                if( iBytes == iNewBytes )
-                {
-                        // No? That makes life easier
-                        iBits = iLength;
-                        setMask();
-                        if( bClear )
-                        {
-                                clear();
-                        }
-                }
-                else
-                {
-                        // Ok, reallocate and copy...
-                        iBits = iLength;
-//                      long iNewBytes = bitsToBytes( iLength );
-                        if( bClear )
-                        {
-                                delete[] caData;
-                                caData = new unsigned char[iNewBytes];
-                                memset( caData, 0, iNewBytes );
-                        }
-                        else
-                        {
-                                unsigned char *tmp = caData;
-                                caData = new unsigned char[iNewBytes];
-                                if( iNewBytes < iBytes )
-                                {
-                                        memcpy( caData, tmp, iNewBytes );
-                                }
-                                else
-                                {
-                                        memcpy( caData, tmp, iBytes );
-                                }
-                                delete[] tmp;
-                        }
-                        iBytes = iNewBytes;
-                        
-                        setMask();
-                }
-
-        }
-        else if( bClear )
-        {
-                clear();
-        }
-
-        return true;
+    // First, if there's nothing, then allocate an empty one.
+    if( caData == NULL )
+    {
+        iBits = iLength;
+        iBytes = bitsToBytes( iLength );
+        caData = new unsigned char[iBytes];
+        memset( caData, 0, iBytes );
+        return true;
+    }
+
+    // If the new length is the same as the old, don't do anything, but do
+    // check to see if we should still clear the data.
+    if( iBits != iLength )
+    {
+        // Ok, we are changing the number if bits, but are we changing the
+        // number of bytes?
+        long iNewBytes = bitsToBytes( iLength );
+        if( iBytes == iNewBytes )
+        {
+            // No? That makes life easier
+            iBits = iLength;
+            setMask();
+            if( bClear )
+            {
+                clear();
+            }
+        }
+        else
+        {
+            // Ok, reallocate and copy...
+            iBits = iLength;
+//          long iNewBytes = bitsToBytes( iLength );
+            if( bClear )
+            {
+                delete[] caData;
+                caData = new unsigned char[iNewBytes];
+                memset( caData, 0, iNewBytes );
+            }
+            else
+            {
+                unsigned char *tmp = caData;
+                caData = new unsigned char[iNewBytes];
+                if( iNewBytes < iBytes )
+                {
+                    memcpy( caData, tmp, iNewBytes );
+                }
+                else
+                {
+                    memcpy( caData, tmp, iBytes );
+                }
+                delete[] tmp;
+            }
+            iBytes = iNewBytes;
+            
+            setMask();
+        }
+
+    }
+    else if( bClear )
+    {
+        clear();
+    }
+
+    return true;
 }
 
 void Bu::BitString::setMask()
 {
-        // This can either mean that there are a multiple of eight bits or
-        // zero, if there are zero you're an idiot (zero can't happen, because
-        // we would allocate an extra byte and never use it)
-        if( (iBits%8 == 0) )
-        {
-                cTopByteMask = 0xFF;
-        }
-        else
-        {
-                cTopByteMask = 0;
-                for( long j = 0; j < (iBits%8); j++ )
-                {
-                        cTopByteMask |= (1<<j);
-                }
-        }
+    // This can either mean that there are a multiple of eight bits or
+    // zero, if there are zero you're an idiot (zero can't happen, because
+    // we would allocate an extra byte and never use it)
+    if( (iBits%8 == 0) )
+    {
+        cTopByteMask = 0xFF;
+    }
+    else
+    {
+        cTopByteMask = 0;
+        for( long j = 0; j < (iBits%8); j++ )
+        {
+            cTopByteMask |= (1<<j);
+        }
+    }
 }
 
 void Bu::BitString::randomize()
 {
-        if( caData != NULL )
-        {
-                for( int j = 0; j < iBytes; j++ )
-                {
-                        caData[j] = (unsigned char)(Bu::Random::rand() & 0xFF);
-                }
-                fixup();
-        }
+    if( caData != NULL )
+    {
+        for( int j = 0; j < iBytes; j++ )
+        {
+            caData[j] = (unsigned char)(Bu::Random::rand() & 0xFF);
+        }
+        fixup();
+    }
 }
 
 void Bu::BitString::invert()
 {
-        if( caData != NULL )
-        {
-                for( long j = 0; j < iBytes; j++ )
-                {
-                        caData[j] = ~caData[j];
-                }
-                fixup();
-        }
+    if( caData != NULL )
+    {
+        for( long j = 0; j < iBytes; j++ )
+        {
+            caData[j] = ~caData[j];
+        }
+        fixup();
+    }
 }
 
 long Bu::BitString::getHighestOrderBitPos()
 {
-        for( long j = iBits-1; j >= 0; j-- )
-        {
-                if( getBit( j ) )
-                {
-                        return j;
-                }
-        }
-
-        return -1;
+    for( long j = iBits-1; j >= 0; j-- )
+    {
+        if( getBit( j ) )
+        {
+            return j;
+        }
+    }
+
+    return -1;
 }
 
 Bu::String Bu::BitString::toString()
 {
-        Bu::String sRet;
-        for( int j = iBits-1; j >= 0; j-- )
-                sRet.append( getBit( j )?'1':'0' );
-        return sRet;
+    Bu::String sRet;
+    for( int j = iBits-1; j >= 0; j-- )
+        sRet.append( getBit( j )?'1':'0' );
+    return sRet;
 }
 
 /*
 bool Bu::BitString::writeToFile( FILE *fh )
 {
-        fwrite( &iBits, sizeof(long), 1, fh );
-        fwrite( caData, sizeof(char), iBytes, fh );
-        
-        return true;
+    fwrite( &iBits, sizeof(long), 1, fh );
+    fwrite( caData, sizeof(char), iBytes, fh );
+    
+    return true;
 }
 
 bool Bu::BitString::readFromFile( FILE *fh )
 {
-        fread( &iBits, sizeof(long), 1, fh );
-        
-        iBytes = bitsToBytes( iBits );
-        if( caData ) delete[] caData;
-        caData = new unsigned char[iBytes];
+    fread( &iBits, sizeof(long), 1, fh );
+    
+    iBytes = bitsToBytes( iBits );
+    if( caData ) delete[] caData;
+    caData = new unsigned char[iBytes];
 
-        fread( caData, sizeof(char), iBytes, fh );
+    fread( caData, sizeof(char), iBytes, fh );
 
-        setMask();
-        
-        fixup();
+    setMask();
+    
+    fixup();
 
-        return true;
+    return true;
 }*/
diff --git a/src/unstable/bitstring.h b/src/unstable/bitstring.h
index fd34402..ea884f6 100644
--- a/src/unstable/bitstring.h
+++ b/src/unstable/bitstring.h
@@ -13,212 +13,212 @@
 
 namespace Bu
 {
-        /**
-         * Manages an arbitrarily sized string of bits, and allows basic interaction
-         * with them.  This includes basic non-mathematical bitwise operations such
-         * as setting and testing bits, shifting the string, inversion and a few
-         * extras like randomization.  On linux systems this takes advantage of long
-         * longs giving you a maximum size of about 2tb per string.
-         *
-         * For more general and mathematical type interaction see BitStringInt.
-         * 
-         */
-        class BitString
-        {
-        public:
-                /**
-                 * Constructs a blank and basic BitString.  This is actually useful
-                 * since you can resize BitStrings at will, and even retain the data
-                 * that was in them.
-                 */
-                BitString();
-
-                /**
-                 * Constructs a BitString object as a copy of another BitString.  This
-                 * is a standard copy constructor and produces an exact duplicate of
-                 * the original BitString object.
-                 *@param xSrc Source BitString to copy data from.
-                 */
-                BitString( const BitString &xSrc );
-
-                /**
-                 * Constructs a BitString with length iBits and optionally fills it with
-                 * random data.  The default setting, to not fill randomly, will produce
-                 * a blank (all zeros) string of the specified size.
-                 *@param iBits The length of the new BitString in bits.
-                 *@param bFillRandomly Wether or not to randomize this BitString.
-                 */
-                BitString( long iBits, bool bFillRandomly=false );
-
-                /**
-                 * Virtual deconstructor for the BitString.  Takes care of cleanup for
-                 * you.  What more do you really want to know?
-                 */
-                virtual ~BitString();
-
-                // basic interaction
-                /**
-                 * Sets a bit in the BitString.  In it's normal mode it will always turn
-                 * the given bit on, to clear a bit set bBitState to false instead of
-                 * true.  This operation runs in O(1).
-                 *@param iBit The zero-based index of the bit to modify.
-                 *@param bBitState Set to true to set the bit to 1, set to false to set
-                 * the bit to 0.
-                 */
-                void setBit( long iBit, bool bBitState=true );
-
-                /**
-                 * Reverses the state of the given bit.  This will set the given bit
-                 * to a 1 if it was 0, and to 0 if it was 1.  This operation runs in
-                 * O(1), and it should be noted that using this is marginally faster
-                 * than doing the test and flip yourself with getBit and setBit since
-                 * it uses a bitwise not operation and doesn't actually test the bit
-                 * itself.
-                 *@param iBit The index of the bit to flip.
-                 */
-                void flipBit( long iBit );
-
-                /**
-                 * Gets the state of the given bit.  This follows the standard
-                 * convention used so far, a returned value of true means the bit in
-                 * question is 1, and a value of flase means the bit is 0.  All bits
-                 * out of range of the BitString are treated as off, but are
-                 * "accessable" in that this does not produce any kind of error
-                 * message.  This is intentional.  This operation runs in O(1).
-                 *@param iBit The index of the bit to test.
-                 *@returns True for a 1, false for a 0.
-                 */
-                bool getBit( long iBit );
-
-                /**
-                 * Inverts the entire BitString, in effect this calls flipBit on every
-                 * bit in the string but is faster since it can operate on whole bytes
-                 * at a time instead of individual bits.  This operation runs in O(N).
-                 */
-                void invert();
-
-                /**
-                 * Returns the number of bits allocated in this BitString.  This
-                 * operation runs in O(1) time since this value is cached and not
-                 * computed.
-                 *@returns The number of bits allocated in this BitString.
-                 */
-                DEPRECATED
-                long getBitLength();
-
-                long getSize();
-
-                /**
-                 * Sets the entire BitString to zeros, but it does it very quickly.
-                 * This operation runs in O(N).
-                 */
-                void clear();
-
-                /**
-                 * Gets another BitString that is autonomous of the current one
-                 * (contains a copy of the memory, not a pointer) and contains a subset
-                 * of the data in the current BitString.  This is an inclusive
-                 * operation, so grabbing bits 0-5 will give you 6 bits.  This is based
-                 * on a very tricky bit-shifting algorithm and runs very quickly, in
-                 * O(N) time.  Passing in a value of zero for iUpper, or any value for
-                 * iUpper that is less than iLower will set iUpper equal to the number
-                 * of bits in the BitString.
-                 *@param iLower The first bit in the current string, will be the first
-                 * bit (0 index) in the new sub string.
-                 *@param iUpper The last bit in the current string, will be the last
-                 * bit in the new sub string.  iUpper is included in the sub string.
-                 *@returns A new BitString object ready to be used.  Please note that
-                 * managing this new object is up to whomever calls this function.
-                 */
-                class BitString getSubString( long iLower, long iUpper );
-
-                /**
-                 * Sets the number of bits in the BitString, allocating more memory if
-                 * necesarry, or freeing extra if able.  The default operation of this
-                 * function clears all data in the BitString while resizing it.  If you
-                 * would like to keep as much of the data that you had in your BitString
-                 * as possible, then set bClear to false, and any data that will fit
-                 * into the new BitString length will be retained.  If increasing the
-                 * number of bits, the new bits will come into existance cleared (set
-                 * to 0).
-                 *@param iLength The number of bits to set the BitString to.
-                 *@param bClear When true, all data is eradicated and zeroed, when set
-                 * to false an effort is made to retain the existing data.
-                 *@returns true on success, false on failure.
-                 */
-                DEPRECATED
-                bool setBitLength( long iLength, bool bClear=true );
-                bool setSize( long iLength, bool bClear=true );
-
-                /**
-                 * Randomize the entire BitString, one bit at a time.  This is actually
-                 * the function called by the constructor when the user selects initial
-                 * randomization.  This function uses the system random() function, so
-                 * srandom may be used to effect this process at will.
-                 */
-                void randomize();
-
-                /**
-                 * Operates exactly like <<.  All data in the BitString is shifted to
-                 * the left by some number of bits, any data pushed off the edge of the
-                 * BitString is lost, and all new data coming in will be zeroed.
-                 * Using a negative value in the shiftLeft function will turn it into
-                 * the shiftRight function.
-                 *@param iAmt The number of bit positions to shift all data.
-                 */
-                void shiftLeft( long iAmt ); // just like <<
-
-                /**
-                 * Operates exactly like >>.  All data in the BitString is shifted to
-                 * the right by some number of bits, any data pushed off the edge of the
-                 * BitString is lost, and all new data coming in will be zeroed.
-                 * Using a negative value in the shiftRight function will turn it into
-                 * the shiftLeft function.
-                 *@param iAmt The number of bit positions to shift all data.
-                 */
-                void shiftRight( long iAmt ); // just like >>
-
-                /**
-                 * Searches through the BitString and returns the index of the highest
-                 * order bit position (the highest index) with an on bit (a bit set to
-                 * 1).  This is a handy helper function and rather faster than calling
-                 * getBit() over and over again.
-                 *@returns The index of the highest indexed on bit.
-                 */
-                long getHighestOrderBitPos();
-
-                // Conversion
-                /**
-                 * Convert a block of data (no more than 32 bits) to a primitive long
-                 * type.
-                 * This is done in a little bit interesting way, so it may not always be
-                 * the fastest way to access the data that you want, although it will
-                 * always ensure that the long that is written makes numerical sense, as
-                 * we write numbers, regaurdless of platform.
-                 *@param iStart The first bit in the BitString to include in the long
-                 *@param iSize THe number of bits to include, if this value is set over
-                 * 32 it will be automatically truncated to, or however many bits there
-                 * are in a long in your system.
-                 *@returns A long converted from your raw BitString data.
-                 */
-                long toLong( long iStart = 0, long iSize = 32 );
-
-                Bu::String toString();
-
-                //operators
-                BitString &operator=( const BitString &xSrc );
-                BitString operator~();
-                BitString operator<<( const long iAmt );
-                BitString operator>>( const long iAmt );
-
-        private:
-                void fixup();
-                void setMask();
-                unsigned char *caData;
-                long iBits;
-                long iBytes;
-                unsigned char cTopByteMask;
-        };
+    /**
+     * Manages an arbitrarily sized string of bits, and allows basic interaction
+     * with them.  This includes basic non-mathematical bitwise operations such
+     * as setting and testing bits, shifting the string, inversion and a few
+     * extras like randomization.  On linux systems this takes advantage of long
+     * longs giving you a maximum size of about 2tb per string.
+     *
+     * For more general and mathematical type interaction see BitStringInt.
+     * 
+     */
+    class BitString
+    {
+    public:
+        /**
+         * Constructs a blank and basic BitString.  This is actually useful
+         * since you can resize BitStrings at will, and even retain the data
+         * that was in them.
+         */
+        BitString();
+
+        /**
+         * Constructs a BitString object as a copy of another BitString.  This
+         * is a standard copy constructor and produces an exact duplicate of
+         * the original BitString object.
+         *@param xSrc Source BitString to copy data from.
+         */
+        BitString( const BitString &xSrc );
+
+        /**
+         * Constructs a BitString with length iBits and optionally fills it with
+         * random data.  The default setting, to not fill randomly, will produce
+         * a blank (all zeros) string of the specified size.
+         *@param iBits The length of the new BitString in bits.
+         *@param bFillRandomly Wether or not to randomize this BitString.
+         */
+        BitString( long iBits, bool bFillRandomly=false );
+
+        /**
+         * Virtual deconstructor for the BitString.  Takes care of cleanup for
+         * you.  What more do you really want to know?
+         */
+        virtual ~BitString();
+
+        // basic interaction
+        /**
+         * Sets a bit in the BitString.  In it's normal mode it will always turn
+         * the given bit on, to clear a bit set bBitState to false instead of
+         * true.  This operation runs in O(1).
+         *@param iBit The zero-based index of the bit to modify.
+         *@param bBitState Set to true to set the bit to 1, set to false to set
+         * the bit to 0.
+         */
+        void setBit( long iBit, bool bBitState=true );
+
+        /**
+         * Reverses the state of the given bit.  This will set the given bit
+         * to a 1 if it was 0, and to 0 if it was 1.  This operation runs in
+         * O(1), and it should be noted that using this is marginally faster
+         * than doing the test and flip yourself with getBit and setBit since
+         * it uses a bitwise not operation and doesn't actually test the bit
+         * itself.
+         *@param iBit The index of the bit to flip.
+         */
+        void flipBit( long iBit );
+
+        /**
+         * Gets the state of the given bit.  This follows the standard
+         * convention used so far, a returned value of true means the bit in
+         * question is 1, and a value of flase means the bit is 0.  All bits
+         * out of range of the BitString are treated as off, but are
+         * "accessable" in that this does not produce any kind of error
+         * message.  This is intentional.  This operation runs in O(1).
+         *@param iBit The index of the bit to test.
+         *@returns True for a 1, false for a 0.
+         */
+        bool getBit( long iBit );
+
+        /**
+         * Inverts the entire BitString, in effect this calls flipBit on every
+         * bit in the string but is faster since it can operate on whole bytes
+         * at a time instead of individual bits.  This operation runs in O(N).
+         */
+        void invert();
+
+        /**
+         * Returns the number of bits allocated in this BitString.  This
+         * operation runs in O(1) time since this value is cached and not
+         * computed.
+         *@returns The number of bits allocated in this BitString.
+         */
+        DEPRECATED
+        long getBitLength();
+
+        long getSize();
+
+        /**
+         * Sets the entire BitString to zeros, but it does it very quickly.
+         * This operation runs in O(N).
+         */
+        void clear();
+
+        /**
+         * Gets another BitString that is autonomous of the current one
+         * (contains a copy of the memory, not a pointer) and contains a subset
+         * of the data in the current BitString.  This is an inclusive
+         * operation, so grabbing bits 0-5 will give you 6 bits.  This is based
+         * on a very tricky bit-shifting algorithm and runs very quickly, in
+         * O(N) time.  Passing in a value of zero for iUpper, or any value for
+         * iUpper that is less than iLower will set iUpper equal to the number
+         * of bits in the BitString.
+         *@param iLower The first bit in the current string, will be the first
+         * bit (0 index) in the new sub string.
+         *@param iUpper The last bit in the current string, will be the last
+         * bit in the new sub string.  iUpper is included in the sub string.
+         *@returns A new BitString object ready to be used.  Please note that
+         * managing this new object is up to whomever calls this function.
+         */
+        class BitString getSubString( long iLower, long iUpper );
+
+        /**
+         * Sets the number of bits in the BitString, allocating more memory if
+         * necesarry, or freeing extra if able.  The default operation of this
+         * function clears all data in the BitString while resizing it.  If you
+         * would like to keep as much of the data that you had in your BitString
+         * as possible, then set bClear to false, and any data that will fit
+         * into the new BitString length will be retained.  If increasing the
+         * number of bits, the new bits will come into existance cleared (set
+         * to 0).
+         *@param iLength The number of bits to set the BitString to.
+         *@param bClear When true, all data is eradicated and zeroed, when set
+         * to false an effort is made to retain the existing data.
+         *@returns true on success, false on failure.
+         */
+        DEPRECATED
+        bool setBitLength( long iLength, bool bClear=true );
+        bool setSize( long iLength, bool bClear=true );
+
+        /**
+         * Randomize the entire BitString, one bit at a time.  This is actually
+         * the function called by the constructor when the user selects initial
+         * randomization.  This function uses the system random() function, so
+         * srandom may be used to effect this process at will.
+         */
+        void randomize();
+
+        /**
+         * Operates exactly like <<.  All data in the BitString is shifted to
+         * the left by some number of bits, any data pushed off the edge of the
+         * BitString is lost, and all new data coming in will be zeroed.
+         * Using a negative value in the shiftLeft function will turn it into
+         * the shiftRight function.
+         *@param iAmt The number of bit positions to shift all data.
+         */
+        void shiftLeft( long iAmt ); // just like <<
+
+        /**
+         * Operates exactly like >>.  All data in the BitString is shifted to
+         * the right by some number of bits, any data pushed off the edge of the
+         * BitString is lost, and all new data coming in will be zeroed.
+         * Using a negative value in the shiftRight function will turn it into
+         * the shiftLeft function.
+         *@param iAmt The number of bit positions to shift all data.
+         */
+        void shiftRight( long iAmt ); // just like >>
+
+        /**
+         * Searches through the BitString and returns the index of the highest
+         * order bit position (the highest index) with an on bit (a bit set to
+         * 1).  This is a handy helper function and rather faster than calling
+         * getBit() over and over again.
+         *@returns The index of the highest indexed on bit.
+         */
+        long getHighestOrderBitPos();
+
+        // Conversion
+        /**
+         * Convert a block of data (no more than 32 bits) to a primitive long
+         * type.
+         * This is done in a little bit interesting way, so it may not always be
+         * the fastest way to access the data that you want, although it will
+         * always ensure that the long that is written makes numerical sense, as
+         * we write numbers, regaurdless of platform.
+         *@param iStart The first bit in the BitString to include in the long
+         *@param iSize THe number of bits to include, if this value is set over
+         * 32 it will be automatically truncated to, or however many bits there
+         * are in a long in your system.
+         *@returns A long converted from your raw BitString data.
+         */
+        long toLong( long iStart = 0, long iSize = 32 );
+
+        Bu::String toString();
+
+        //operators
+        BitString &operator=( const BitString &xSrc );
+        BitString operator~();
+        BitString operator<<( const long iAmt );
+        BitString operator>>( const long iAmt );
+
+    private:
+        void fixup();
+        void setMask();
+        unsigned char *caData;
+        long iBits;
+        long iBytes;
+        unsigned char cTopByteMask;
+    };
 };
 
 #endif
diff --git a/src/unstable/fifo.cpp b/src/unstable/fifo.cpp
index 6f327df..4b4a2bf 100644
--- a/src/unstable/fifo.cpp
+++ b/src/unstable/fifo.cpp
@@ -17,75 +17,75 @@
 namespace Bu { subExceptionDef( FifoException ) }
 
 Bu::Fifo::Fifo( const Bu::String &sName, int iFlags, mode_t mAcc ) :
-        iFlags( iFlags ),
-        iIn( -1 ),
-        iOut( -1 )
+    iFlags( iFlags ),
+    iIn( -1 ),
+    iOut( -1 )
 {
 #ifndef WIN32
-        if( iFlags&Create )
-        {
-                if( mkfifo( sName.getStr(), mAcc ) )
-                {
-                        throw FifoException("Error creating fifo: %s\n", strerror( errno ) );
-                }
-        }
-        if( iFlags&Read )
-        {
-                iIn = ::open(
-                        sName.getStr(),
-                        O_RDONLY|((iFlags&NonBlock)?O_NONBLOCK:0)
-                        );
-        }
-        if( iFlags&Write )
-        {
-                iOut = ::open(
-                        sName.getStr(),
-                        O_WRONLY
-                        );
-        }
+    if( iFlags&Create )
+    {
+        if( mkfifo( sName.getStr(), mAcc ) )
+        {
+            throw FifoException("Error creating fifo: %s\n", strerror( errno ) );
+        }
+    }
+    if( iFlags&Read )
+    {
+        iIn = ::open(
+            sName.getStr(),
+            O_RDONLY|((iFlags&NonBlock)?O_NONBLOCK:0)
+            );
+    }
+    if( iFlags&Write )
+    {
+        iOut = ::open(
+            sName.getStr(),
+            O_WRONLY
+            );
+    }
 #else
-        #warning Bu::Fifo::Fifo IS A STUB for WIN32!!!! 
+    #warning Bu::Fifo::Fifo IS A STUB for WIN32!!!! 
 #endif
 }
 
 Bu::Fifo::~Fifo()
 {
-        close();
+    close();
 }
 
 void Bu::Fifo::close()
 {
-        if( iIn > -1 )
-        {
-                ::close( iIn );
-                iIn = -1;
-        }
-        if( iOut > -1 )
-        {
-                ::close( iOut );
-                iOut = -1;
-        }
+    if( iIn > -1 )
+    {
+        ::close( iIn );
+        iIn = -1;
+    }
+    if( iOut > -1 )
+    {
+        ::close( iOut );
+        iOut = -1;
+    }
 }
 
 Bu::size Bu::Fifo::read( void *pBuf, Bu::size nBytes )
 {
-        if( iIn < 0 )
-                throw FifoException("Fifo not open for reading.");
+    if( iIn < 0 )
+        throw FifoException("Fifo not open for reading.");
 
-        return TEMP_FAILURE_RETRY( ::read( iIn, pBuf, nBytes ) );
+    return TEMP_FAILURE_RETRY( ::read( iIn, pBuf, nBytes ) );
 }
 
 Bu::size Bu::Fifo::write( const void *pBuf, Bu::size nBytes )
 {
-        if( iOut < 0 )
-                throw FifoException("Fifo not open for writing.");
+    if( iOut < 0 )
+        throw FifoException("Fifo not open for writing.");
 
-        return TEMP_FAILURE_RETRY( ::write( iOut, pBuf, nBytes ) );
+    return TEMP_FAILURE_RETRY( ::write( iOut, pBuf, nBytes ) );
 }
 
 Bu::size Bu::Fifo::tell()
 {
-        return -1;
+    return -1;
 }
 
 void Bu::Fifo::seek( Bu::size )
@@ -102,53 +102,53 @@ void Bu::Fifo::setPosEnd( Bu::size )
 
 bool Bu::Fifo::isEos()
 {
-        return false;
+    return false;
 }
 
 bool Bu::Fifo::canRead()
 {
-        return (iIn>-1);
+    return (iIn>-1);
 }
 
 bool Bu::Fifo::canWrite()
 {
-        return (iOut>-1);
+    return (iOut>-1);
 }
 
 bool Bu::Fifo::isReadable()
 {
-        return (iIn>-1);
+    return (iIn>-1);
 }
 
 bool Bu::Fifo::isWritable()
 {
-        return (iOut>-1);
+    return (iOut>-1);
 }
 
 bool Bu::Fifo::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::Fifo::isBlocking()
 {
 #ifndef WIN32
-        return ((fcntl( iIn, F_GETFL, 0 )&O_NONBLOCK) == O_NONBLOCK);
+    return ((fcntl( iIn, F_GETFL, 0 )&O_NONBLOCK) == O_NONBLOCK);
 #else
-        #warning Bu::Fifo::isBlocking IS A STUB for WIN32!!!!
-#endif  
+    #warning Bu::Fifo::isBlocking IS A STUB for WIN32!!!!
+#endif  
 }
 
 void Bu::Fifo::setBlocking( bool bBlocking )
 {
 #ifndef WIN32
-        if( bBlocking )
-                fcntl( iIn, F_SETFL, fcntl( iIn, F_GETFL, 0 )&(~O_NONBLOCK) );
-        else
-                fcntl( iIn, F_SETFL, fcntl( iIn, F_GETFL, 0 )|O_NONBLOCK );
+    if( bBlocking )
+        fcntl( iIn, F_SETFL, fcntl( iIn, F_GETFL, 0 )&(~O_NONBLOCK) );
+    else
+        fcntl( iIn, F_SETFL, fcntl( iIn, F_GETFL, 0 )|O_NONBLOCK );
 #else
-        #warning Bu::Fifo::setBlocking IS A STUB for WIN32!!!!
-#endif  
+    #warning Bu::Fifo::setBlocking IS A STUB for WIN32!!!!
+#endif  
 }
 
 void Bu::Fifo::flush()
@@ -157,6 +157,6 @@ void Bu::Fifo::flush()
 
 bool Bu::Fifo::isOpen()
 {
-        return (iIn > -1) || (iOut > -1);
+    return (iIn > -1) || (iOut > -1);
 }
 
diff --git a/src/unstable/fifo.h b/src/unstable/fifo.h
index ea32f04..3d9192a 100644
--- a/src/unstable/fifo.h
+++ b/src/unstable/fifo.h
@@ -18,55 +18,55 @@
 
 namespace Bu
 {
-        subExceptionDecl( FifoException );
+    subExceptionDecl( FifoException );
 
-        /**
-         * A fifo stream.
-         *@ingroup Streams
-         */
-        class Fifo : public Bu::Stream
-        {
-        public:
-                Fifo( const Bu::String &sName, int iFlags, mode_t mAcc=-1 );
-                virtual ~Fifo();
+    /**
+     * A fifo stream.
+     *@ingroup Streams
+     */
+    class Fifo : public Bu::Stream
+    {
+    public:
+        Fifo( const Bu::String &sName, int iFlags, mode_t mAcc=-1 );
+        virtual ~Fifo();
 
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
 
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
 
-                virtual void flush();
+        virtual void flush();
 
-                virtual bool canRead();
-                virtual bool canWrite();
+        virtual bool canRead();
+        virtual bool canWrite();
 
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
 
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
 
-                enum {
-                        Read            = 0x01,
-                        Write           = 0x02,
-                        Create          = 0x04,
-                        Delete          = 0x08,
-                        NonBlock        = 0x10
-                };
+        enum {
+            Read        = 0x01,
+            Write       = 0x02,
+            Create      = 0x04,
+            Delete      = 0x08,
+            NonBlock    = 0x10
+        };
 
-        private:
-                int iFlags;
-                int iIn;
-                int iOut;
-        };
+    private:
+        int iFlags;
+        int iIn;
+        int iOut;
+    };
 }
 
 #endif
diff --git a/src/unstable/itoserver.cpp b/src/unstable/itoserver.cpp
index 7dbce6c..103bf90 100644
--- a/src/unstable/itoserver.cpp
+++ b/src/unstable/itoserver.cpp
@@ -13,121 +13,121 @@
 #include "bu/tcpsocket.h"
 
 Bu::ItoServer::ItoServer() :
-        nTimeoutSec( 1 ),
-        nTimeoutUSec( 0 )
+    nTimeoutSec( 1 ),
+    nTimeoutUSec( 0 )
 {
-        FD_ZERO( &fdActive );
+    FD_ZERO( &fdActive );
 }
 
 Bu::ItoServer::~ItoServer()
 {
-        while( !qClientCleanup.isEmpty() )
-        {
-                ItoClient *pCli = qClientCleanup.dequeue();
-                pCli->join();
-                delete pCli;
-        }
-        // TODO:  Make sure here that each client has shutdown it's socket, and
-        // maybe even written any extra data, we could put a timelimit on this...
-        // anyway, it's not as clean as it could be right now.
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                ItoClient *pCli = (*i);
-                pCli->join();
-                delete pCli;
-        }
+    while( !qClientCleanup.isEmpty() )
+    {
+        ItoClient *pCli = qClientCleanup.dequeue();
+        pCli->join();
+        delete pCli;
+    }
+    // TODO:  Make sure here that each client has shutdown it's socket, and
+    // maybe even written any extra data, we could put a timelimit on this...
+    // anyway, it's not as clean as it could be right now.
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        ItoClient *pCli = (*i);
+        pCli->join();
+        delete pCli;
+    }
 }
 
 void Bu::ItoServer::addPort( int nPort, int nPoolSize )
 {
-        TcpServerSocket *s = new TcpServerSocket( nPort, nPoolSize );
-        socket_t nSocket = s->getSocket();
-        FD_SET( nSocket, &fdActive );
-        hServers.insert( nSocket, s );
+    TcpServerSocket *s = new TcpServerSocket( nPort, nPoolSize );
+    socket_t nSocket = s->getSocket();
+    FD_SET( nSocket, &fdActive );
+    hServers.insert( nSocket, s );
 }
 
 void Bu::ItoServer::addPort( const String &sAddr, int nPort, int nPoolSize )
 {
-        TcpServerSocket *s = new TcpServerSocket( sAddr, nPort, nPoolSize );
-        socket_t nSocket = s->getSocket();
-        FD_SET( nSocket, &fdActive );
-        hServers.insert( nSocket, s );
+    TcpServerSocket *s = new TcpServerSocket( sAddr, nPort, nPoolSize );
+    socket_t nSocket = s->getSocket();
+    FD_SET( nSocket, &fdActive );
+    hServers.insert( nSocket, s );
 }
 
 void Bu::ItoServer::setTimeout( int nTimeoutSec, int nTimeoutUSec )
 {
-        this->nTimeoutSec = nTimeoutSec;
-        this->nTimeoutUSec = nTimeoutUSec;
+    this->nTimeoutSec = nTimeoutSec;
+    this->nTimeoutUSec = nTimeoutUSec;
 }
 
 void Bu::ItoServer::addClient( socket_t nSocket, int nPort )
 {
-        ItoClient *pC = new ItoClient( *this, nSocket, nPort, nTimeoutSec,
-                        nTimeoutUSec );
+    ItoClient *pC = new ItoClient( *this, nSocket, nPort, nTimeoutSec,
+            nTimeoutUSec );
 
-        imClients.lock();
-        hClients.insert( nSocket, pC );
-        imClients.unlock();
-        
-        pC->start();
+    imClients.lock();
+    hClients.insert( nSocket, pC );
+    imClients.unlock();
+    
+    pC->start();
 }
 
 void Bu::ItoServer::run()
 {
-        for(;;)
-        {
-                struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
-                
-                fd_set fdRead = fdActive;
-                //fd_set fdWrite = fdActive;
-                fd_set fdException = fdActive;
-
-                if( TEMP_FAILURE_RETRY( select( FD_SETSIZE, &fdRead, NULL, &fdException, &xTimeout ) ) < 0 )
-                {
-                        throw ExceptionBase("Error attempting to scan open connections.");
-                }
-
-                for( ServerHash::iterator i = hServers.begin(); i != hServers.end(); i++ )
-                {
-                        if( FD_ISSET( i.getKey(), &fdRead ) )
-                        {
-                                TcpServerSocket *pSrv = i.getValue();
-                                addClient( pSrv->accept(), pSrv->getPort() );
-                        }
-                }
-
-                while( !qClientCleanup.isEmpty() )
-                {
-                        ItoClient *pCli = qClientCleanup.dequeue();
-                        pCli->join();
-                        delete pCli;
-                }
-        }
+    for(;;)
+    {
+        struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
+        
+        fd_set fdRead = fdActive;
+        //fd_set fdWrite = fdActive;
+        fd_set fdException = fdActive;
+
+        if( TEMP_FAILURE_RETRY( select( FD_SETSIZE, &fdRead, NULL, &fdException, &xTimeout ) ) < 0 )
+        {
+            throw ExceptionBase("Error attempting to scan open connections.");
+        }
+
+        for( ServerHash::iterator i = hServers.begin(); i != hServers.end(); i++ )
+        {
+            if( FD_ISSET( i.getKey(), &fdRead ) )
+            {
+                TcpServerSocket *pSrv = i.getValue();
+                addClient( pSrv->accept(), pSrv->getPort() );
+            }
+        }
+
+        while( !qClientCleanup.isEmpty() )
+        {
+            ItoClient *pCli = qClientCleanup.dequeue();
+            pCli->join();
+            delete pCli;
+        }
+    }
 }
 
 void Bu::ItoServer::clientCleanup( socket_t iSocket )
 {
-        imClients.lock();
-        ItoClient *pCli = hClients.get( iSocket );
-        imClients.unlock();
-        qClientCleanup.enqueue( pCli );
+    imClients.lock();
+    ItoClient *pCli = hClients.get( iSocket );
+    imClients.unlock();
+    qClientCleanup.enqueue( pCli );
 }
 
 Bu::ItoServer::ItoClient::ItoClient( ItoServer &rSrv, Bu::ItoServer::socket_t iSocket, int iPort,
-                int nTimeoutSec, int nTimeoutUSec ) :
-        rSrv( rSrv ),
-        iSocket( iSocket ),
-        iPort( iPort ),
-        nTimeoutSec( nTimeoutSec ),
-        nTimeoutUSec( nTimeoutUSec )
+        int nTimeoutSec, int nTimeoutUSec ) :
+    rSrv( rSrv ),
+    iSocket( iSocket ),
+    iPort( iPort ),
+    nTimeoutSec( nTimeoutSec ),
+    nTimeoutUSec( nTimeoutUSec )
 {
-        FD_ZERO( &fdActive );
-        FD_SET( iSocket, &fdActive );
+    FD_ZERO( &fdActive );
+    FD_SET( iSocket, &fdActive );
 
-        pClient = new Client(
-                new Bu::TcpSocket( iSocket ),
-                new SrvClientLinkFactory( rSrv )
-                );
+    pClient = new Client(
+        new Bu::TcpSocket( iSocket ),
+        new SrvClientLinkFactory( rSrv )
+        );
 }
 
 Bu::ItoServer::ItoClient::~ItoClient()
@@ -136,67 +136,67 @@ Bu::ItoServer::ItoClient::~ItoClient()
 
 void Bu::ItoServer::ItoClient::run()
 {
-        imProto.lock();
-        rSrv.onNewConnection( pClient, iPort );
-        pClient->processOutput();
-        imProto.unlock();
-
-        for(;;)
-        {
-                struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
-                
-                fd_set fdRead = fdActive;
-                fd_set fdWrite;
-                fd_set fdException = fdActive;
-
-                FD_ZERO( &fdWrite );
-                if( pClient->hasOutput() )
-                        FD_SET( iSocket, &fdWrite );
-
-                if( TEMP_FAILURE_RETRY( select( FD_SETSIZE,
-                                &fdRead, &fdWrite, &fdException, &xTimeout ) ) < 0 )
-                {
-                        throw ExceptionBase("Error attempting to scan open connections.");
-                }
-
-                while( !qMsg.isEmpty() )
-                {
-                        imProto.lock();
-                        Bu::String *pMsg = qMsg.dequeue();
-                        pClient->onMessage( *pMsg );
-                        delete pMsg;
-                        pClient->processOutput();
-                        imProto.unlock();
-                }
-
-                if( FD_ISSET( iSocket, &fdRead ) )
-                {
-                        imProto.lock();
-                        pClient->processInput();
-                        imProto.unlock();
-                        if( !pClient->isOpen() )
-                        {
-                                imProto.lock();
-                                rSrv.onClosedConnection( pClient );
-                                imProto.unlock();
-
-                                rSrv.clientCleanup( iSocket );
-                                
-                                return;
-                        }
-                }
-
-                if( FD_ISSET( iSocket, &fdWrite ) )
-                {
-                        imProto.lock();
-                        pClient->processOutput();
-                        imProto.unlock();
-                }
-        }
+    imProto.lock();
+    rSrv.onNewConnection( pClient, iPort );
+    pClient->processOutput();
+    imProto.unlock();
+
+    for(;;)
+    {
+        struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
+        
+        fd_set fdRead = fdActive;
+        fd_set fdWrite;
+        fd_set fdException = fdActive;
+
+        FD_ZERO( &fdWrite );
+        if( pClient->hasOutput() )
+            FD_SET( iSocket, &fdWrite );
+
+        if( TEMP_FAILURE_RETRY( select( FD_SETSIZE,
+                &fdRead, &fdWrite, &fdException, &xTimeout ) ) < 0 )
+        {
+            throw ExceptionBase("Error attempting to scan open connections.");
+        }
+
+        while( !qMsg.isEmpty() )
+        {
+            imProto.lock();
+            Bu::String *pMsg = qMsg.dequeue();
+            pClient->onMessage( *pMsg );
+            delete pMsg;
+            pClient->processOutput();
+            imProto.unlock();
+        }
+
+        if( FD_ISSET( iSocket, &fdRead ) )
+        {
+            imProto.lock();
+            pClient->processInput();
+            imProto.unlock();
+            if( !pClient->isOpen() )
+            {
+                imProto.lock();
+                rSrv.onClosedConnection( pClient );
+                imProto.unlock();
+
+                rSrv.clientCleanup( iSocket );
+                
+                return;
+            }
+        }
+
+        if( FD_ISSET( iSocket, &fdWrite ) )
+        {
+            imProto.lock();
+            pClient->processOutput();
+            imProto.unlock();
+        }
+    }
 }
 
 Bu::ItoServer::SrvClientLink::SrvClientLink( ItoClient *pClient ) :
-        pClient( pClient )
+    pClient( pClient )
 {
 }
 
@@ -206,22 +206,22 @@ Bu::ItoServer::SrvClientLink::~SrvClientLink()
 
 void Bu::ItoServer::SrvClientLink::sendMessage( const Bu::String &sMsg )
 {
-        if( !pClient->imProto.trylock() )
-        {
-                pClient->pClient->onMessage( sMsg );
-                pClient->pClient->processOutput();
-                pClient->imProto.unlock();
-        }
-        else
-        {
-                Bu::String *pMsg = new Bu::String( sMsg );
-                pClient->qMsg.enqueue( pMsg );
-        }
+    if( !pClient->imProto.trylock() )
+    {
+        pClient->pClient->onMessage( sMsg );
+        pClient->pClient->processOutput();
+        pClient->imProto.unlock();
+    }
+    else
+    {
+        Bu::String *pMsg = new Bu::String( sMsg );
+        pClient->qMsg.enqueue( pMsg );
+    }
 }
 
 Bu::ItoServer::SrvClientLinkFactory::SrvClientLinkFactory(
-                Bu::ItoServer &rSrv ) :
-        rSrv( rSrv )
+        Bu::ItoServer &rSrv ) :
+    rSrv( rSrv )
 {
 }
 
@@ -230,12 +230,12 @@ Bu::ItoServer::SrvClientLinkFactory::~SrvClientLinkFactory()
 }
 
 Bu::ClientLink *Bu::ItoServer::SrvClientLinkFactory::createLink(
-                Bu::Client *pClient )
+        Bu::Client *pClient )
 {
-        rSrv.imClients.lock();
-        ItoClient *pCli = rSrv.hClients.get( *pClient->getSocket() );
-        rSrv.imClients.unlock();
+    rSrv.imClients.lock();
+    ItoClient *pCli = rSrv.hClients.get( *pClient->getSocket() );
+    rSrv.imClients.unlock();
 
-        return new SrvClientLink( pCli );
+    return new SrvClientLink( pCli );
 }
 
diff --git a/src/unstable/itoserver.h b/src/unstable/itoserver.h
index 6a0df56..34f0fb1 100644
--- a/src/unstable/itoserver.h
+++ b/src/unstable/itoserver.h
@@ -11,7 +11,7 @@
 #include <stdint.h>
 
 #ifndef WIN32
-        #include <sys/select.h>
+    #include <sys/select.h>
 #endif
 
 #include "bu/string.h"
@@ -26,122 +26,122 @@
 
 namespace Bu
 {
-        class TcpServerSocket;
-        class TcpSocket;
-        class Client;
-
-        /**
-         * Core of a network server.  This class is distinct from a ServerSocket in
-         * that a ServerSocket is one listening socket, nothing more.  Socket will
-         * manage a pool of both ServerSockets and connected Sockets along with
-         * their protocols and buffers.
-         *
-         * To start serving on a new port, use the addPort functions.  Each call to
-         * addPort creates a new ServerSocket, starts it listening, and adds it to
-         * the server pool.
-         *
-         * All of the real work is done by scan, which will wait for up
-         * to the timeout set by setTimeout before returning if there is no data
-         * pending.  scan should probably be called in some sort of tight
-         * loop, possibly in it's own thread, or in the main control loop.
-         *
-         * In order to use a Server you must subclass it and implement the pure
-         * virtual functions.  These allow you to receive notification of events
-         * happening within the server itself, and actually makes it useful.
-         *@ingroup Threading Serving
-         */
-        class ItoServer : public Thread
-        {
-                friend class ItoClient;
-                friend class SrvClientLinkFactory;
-        public:
-                ItoServer();
-                virtual ~ItoServer();
+    class TcpServerSocket;
+    class TcpSocket;
+    class Client;
+
+    /**
+     * Core of a network server.  This class is distinct from a ServerSocket in
+     * that a ServerSocket is one listening socket, nothing more.  Socket will
+     * manage a pool of both ServerSockets and connected Sockets along with
+     * their protocols and buffers.
+     *
+     * To start serving on a new port, use the addPort functions.  Each call to
+     * addPort creates a new ServerSocket, starts it listening, and adds it to
+     * the server pool.
+     *
+     * All of the real work is done by scan, which will wait for up
+     * to the timeout set by setTimeout before returning if there is no data
+     * pending.  scan should probably be called in some sort of tight
+     * loop, possibly in it's own thread, or in the main control loop.
+     *
+     * In order to use a Server you must subclass it and implement the pure
+     * virtual functions.  These allow you to receive notification of events
+     * happening within the server itself, and actually makes it useful.
+     *@ingroup Threading Serving
+     */
+    class ItoServer : public Thread
+    {
+        friend class ItoClient;
+        friend class SrvClientLinkFactory;
+    public:
+        ItoServer();
+        virtual ~ItoServer();
 
 #ifdef WIN32
-                typedef unsigned int socket_t;
+        typedef unsigned int socket_t;
 #else
-                typedef int socket_t;
+        typedef int socket_t;
 #endif
 
-                void addPort( int nPort, int nPoolSize=40 );
-                void addPort( const String &sAddr, int nPort, int nPoolSize=40 );
-
-                //void scan();
-                void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
-
-                void addClient( socket_t nSocket, int nPort );
-
-                virtual void onNewConnection( Client *pClient, int nPort )=0;
-                virtual void onClosedConnection( Client *pClient )=0;
-
-        protected:
-                virtual void run();
-
-        private:
-                class SrvClientLink;
-                class ItoClient : public Thread
-                {
-                friend class Bu::ItoServer::SrvClientLink;
-                public:
-                        ItoClient( ItoServer &rSrv, socket_t nSocket, int nPort,
-                                        int nTimeoutSec, int nTimeoutUSec );
-                        virtual ~ItoClient();
-
-                        typedef SynchroQueue<Bu::String *> StringQueue;
-                        StringQueue qMsg;
-
-                protected:
-                        virtual void run();
-
-                private:
-                        ItoServer &rSrv;
-                        Client *pClient;
-                        fd_set fdActive;
-                        socket_t iSocket;
-                        int iPort;
-                        int nTimeoutSec;
-                        int nTimeoutUSec;
-                        Mutex imProto;
-                };
-
-                class SrvClientLink : public Bu::ClientLink
-                {
-                public:
-                        SrvClientLink( ItoClient *pClient );
-                        virtual ~SrvClientLink();
-
-                        virtual void sendMessage( const Bu::String &sMsg );
-
-                private:
-                        ItoClient *pClient;
-                };
-
-                class SrvClientLinkFactory : public Bu::ClientLinkFactory
-                {
-                public:
-                        SrvClientLinkFactory( ItoServer &rSrv );
-                        virtual ~SrvClientLinkFactory();
-
-                        virtual Bu::ClientLink *createLink( Bu::Client *pClient );
-
-                private:
-                        ItoServer &rSrv;
-                };
-
-                int nTimeoutSec;
-                int nTimeoutUSec;
-                fd_set fdActive;
-                typedef Hash<socket_t,TcpServerSocket *> ServerHash;
-                ServerHash hServers;
-                typedef Hash<socket_t,ItoClient *> ClientHash;
-                typedef SynchroQueue<ItoClient *> ClientQueue;
-                ClientHash hClients;
-                ClientQueue qClientCleanup;
-                Mutex imClients;
-
-                void clientCleanup( socket_t iSocket );
-        };
+        void addPort( int nPort, int nPoolSize=40 );
+        void addPort( const String &sAddr, int nPort, int nPoolSize=40 );
+
+        //void scan();
+        void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
+
+        void addClient( socket_t nSocket, int nPort );
+
+        virtual void onNewConnection( Client *pClient, int nPort )=0;
+        virtual void onClosedConnection( Client *pClient )=0;
+
+    protected:
+        virtual void run();
+
+    private:
+        class SrvClientLink;
+        class ItoClient : public Thread
+        {
+        friend class Bu::ItoServer::SrvClientLink;
+        public:
+            ItoClient( ItoServer &rSrv, socket_t nSocket, int nPort,
+                    int nTimeoutSec, int nTimeoutUSec );
+            virtual ~ItoClient();
+
+            typedef SynchroQueue<Bu::String *> StringQueue;
+            StringQueue qMsg;
+
+        protected:
+            virtual void run();
+
+        private:
+            ItoServer &rSrv;
+            Client *pClient;
+            fd_set fdActive;
+            socket_t iSocket;
+            int iPort;
+            int nTimeoutSec;
+            int nTimeoutUSec;
+            Mutex imProto;
+        };
+
+        class SrvClientLink : public Bu::ClientLink
+        {
+        public:
+            SrvClientLink( ItoClient *pClient );
+            virtual ~SrvClientLink();
+
+            virtual void sendMessage( const Bu::String &sMsg );
+
+        private:
+            ItoClient *pClient;
+        };
+
+        class SrvClientLinkFactory : public Bu::ClientLinkFactory
+        {
+        public:
+            SrvClientLinkFactory( ItoServer &rSrv );
+            virtual ~SrvClientLinkFactory();
+
+            virtual Bu::ClientLink *createLink( Bu::Client *pClient );
+
+        private:
+            ItoServer &rSrv;
+        };
+
+        int nTimeoutSec;
+        int nTimeoutUSec;
+        fd_set fdActive;
+        typedef Hash<socket_t,TcpServerSocket *> ServerHash;
+        ServerHash hServers;
+        typedef Hash<socket_t,ItoClient *> ClientHash;
+        typedef SynchroQueue<ItoClient *> ClientQueue;
+        ClientHash hClients;
+        ClientQueue qClientCleanup;
+        Mutex imClients;
+
+        void clientCleanup( socket_t iSocket );
+    };
 }
 
 #endif
diff --git a/src/unstable/minimacro.cpp b/src/unstable/minimacro.cpp
index ff12267..72178ad 100644
--- a/src/unstable/minimacro.cpp
+++ b/src/unstable/minimacro.cpp
@@ -9,16 +9,16 @@
 
 Bu::MiniMacro::MiniMacro()
 {
-        hFuncs.insert("toupper", new FuncToUpper() );
-        hFuncs.insert("tolower", new FuncToLower() );
+    hFuncs.insert("toupper", new FuncToUpper() );
+    hFuncs.insert("tolower", new FuncToLower() );
 }
 
 Bu::MiniMacro::MiniMacro( const StrHash &sVarSrc )
 {
-        for( StrHash::const_iterator i = sVarSrc.begin(); i != sVarSrc.end(); i++ )
-        {
-                addVar( i.getKey(), i.getValue() );
-        }
+    for( StrHash::const_iterator i = sVarSrc.begin(); i != sVarSrc.end(); i++ )
+    {
+        addVar( i.getKey(), i.getValue() );
+    }
 }
 
 Bu::MiniMacro::~MiniMacro()
@@ -27,161 +27,161 @@ Bu::MiniMacro::~MiniMacro()
 
 Bu::String Bu::MiniMacro::parse( const Bu::String &sIn )
 {
-        bContinue = true;
-        Bu::String sOut;
-        for( sCur = sIn.getStr(); *sCur && bContinue; sCur++ )
-        {
-                if( *sCur == '{' )
-                {
-                        switch( sCur[1] )
-                        {
-                                case '=':
-                                        sCur += 2;
-                                        sOut += parseRepl();
-                                        break;
-
-                                case '?':
-                                        sCur += 2;
-                                        sOut += parseCond();
-                                        break;
-
-                                case ':':
-                                        sCur += 2;
-                                        sOut += parseCmd();
-                                        break;
-
-                                default:
-                                        sOut += *sCur;
-                                        continue;
-                        }
-                }
-                else
-                {
-                        sOut += *sCur;
-                }
-        }
-
-        iLastPos = (ptrdiff_t)sCur - (ptrdiff_t)sIn.getStr();
-
-        return sOut;
+    bContinue = true;
+    Bu::String sOut;
+    for( sCur = sIn.getStr(); *sCur && bContinue; sCur++ )
+    {
+        if( *sCur == '{' )
+        {
+            switch( sCur[1] )
+            {
+                case '=':
+                    sCur += 2;
+                    sOut += parseRepl();
+                    break;
+
+                case '?':
+                    sCur += 2;
+                    sOut += parseCond();
+                    break;
+
+                case ':':
+                    sCur += 2;
+                    sOut += parseCmd();
+                    break;
+
+                default:
+                    sOut += *sCur;
+                    continue;
+            }
+        }
+        else
+        {
+            sOut += *sCur;
+        }
+    }
+
+    iLastPos = (ptrdiff_t)sCur - (ptrdiff_t)sIn.getStr();
+
+    return sOut;
 }
 
 Bu::String Bu::MiniMacro::parseRepl()
 {
-        Bu::String sOut;
-        bool bIsFirst = true;
-        for( const char *sNext = sCur;;)
-        {
-                for(; *sNext != ':' && *sNext != '}' && *sNext != '\0'; sNext++ ) { }
-                if( *sNext == '\0' )
-                        break;
-                Bu::String sName( sCur, (ptrdiff_t)sNext-(ptrdiff_t)sCur );
-                if( bIsFirst )
-                {
-                        sOut = hVars[sName];
-                        bIsFirst = false;
-                        //printf("Variable: \"%s\"\n", sName.getStr() );
-                }
-                else
-                {
-                        sOut = callFunc( sOut, sName );
-                        //printf("Filter: \"%s\"\n", sName.getStr() );
-                }
-                if( *sNext == '}' )
-                {
-                        sCur = sNext;
-                        break;
-                }
-                else if( *sNext == ':' )
-                {
-                }
-                sNext++;
-                sCur = sNext;
-        }
-        return sOut;
+    Bu::String sOut;
+    bool bIsFirst = true;
+    for( const char *sNext = sCur;;)
+    {
+        for(; *sNext != ':' && *sNext != '}' && *sNext != '\0'; sNext++ ) { }
+        if( *sNext == '\0' )
+            break;
+        Bu::String sName( sCur, (ptrdiff_t)sNext-(ptrdiff_t)sCur );
+        if( bIsFirst )
+        {
+            sOut = hVars[sName];
+            bIsFirst = false;
+            //printf("Variable: \"%s\"\n", sName.getStr() );
+        }
+        else
+        {
+            sOut = callFunc( sOut, sName );
+            //printf("Filter: \"%s\"\n", sName.getStr() );
+        }
+        if( *sNext == '}' )
+        {
+            sCur = sNext;
+            break;
+        }
+        else if( *sNext == ':' )
+        {
+        }
+        sNext++;
+        sCur = sNext;
+    }
+    return sOut;
 }
 
 Bu::String Bu::MiniMacro::parseCond()
 {
-        Bu::String sOut;
-        //printf("%20s\n", sCur );
-        return sOut;
+    Bu::String sOut;
+    //printf("%20s\n", sCur );
+    return sOut;
 }
 
 Bu::String Bu::MiniMacro::parseCmd()
 {
-        Bu::String sOut;
-        const char *sNext = sCur;
-        for(; *sNext != ':' && *sNext != '}' && *sNext != '\0'; sNext++ ) { }
-        if( *sNext != '\0' )
-        {
-                Bu::String sName( sCur, (ptrdiff_t)sNext-(ptrdiff_t)sCur );
-                if( sName == "end" )
-                {
-                        sCur = sNext;
-                        bContinue = false;
-                        return sOut;
-                }
-                else
-                {
-                        throw Bu::ExceptionBase("Unknown command '%s'.",
-                                sName.getStr()
-                                );
-                }
-        }
-        else
-        {
-                //printf("Uh...?\n");
-        }
-
-        //printf("%20s\n", sCur );
-        return sOut;
+    Bu::String sOut;
+    const char *sNext = sCur;
+    for(; *sNext != ':' && *sNext != '}' && *sNext != '\0'; sNext++ ) { }
+    if( *sNext != '\0' )
+    {
+        Bu::String sName( sCur, (ptrdiff_t)sNext-(ptrdiff_t)sCur );
+        if( sName == "end" )
+        {
+            sCur = sNext;
+            bContinue = false;
+            return sOut;
+        }
+        else
+        {
+            throw Bu::ExceptionBase("Unknown command '%s'.",
+                sName.getStr()
+                );
+        }
+    }
+    else
+    {
+        //printf("Uh...?\n");
+    }
+
+    //printf("%20s\n", sCur );
+    return sOut;
 }
 
 Bu::String Bu::MiniMacro::callFunc(
-        const Bu::String &sIn, const Bu::String &sFunc )
+    const Bu::String &sIn, const Bu::String &sFunc )
 {
-        int i = sFunc.findIdx('(');
-        if( i < 0 )
-                throw Bu::ExceptionBase("That doesn't look like a function call");
-        Bu::String sName( sFunc.getStr(), i );
-        StrList lsParams;
-        for( const char *s = sFunc.getStr()+i+1; *s && *s != ')'; s++ )
-        {
-                for(; *s == ' ' || *s == '\t' || *s == '\r' || *s == '\n'; s++ ) { }
-                const char *sNext;
-                for( sNext = s; *sNext && *sNext != ')' && *sNext != ','; sNext++ ) { }
-                Bu::String p( s, (ptrdiff_t)sNext-(ptrdiff_t)s );
-                lsParams.append( p );
-                sNext++;
-                s = sNext;
-        }
-        return hFuncs.get( sName )->call( sIn, lsParams );
+    int i = sFunc.findIdx('(');
+    if( i < 0 )
+        throw Bu::ExceptionBase("That doesn't look like a function call");
+    Bu::String sName( sFunc.getStr(), i );
+    StrList lsParams;
+    for( const char *s = sFunc.getStr()+i+1; *s && *s != ')'; s++ )
+    {
+        for(; *s == ' ' || *s == '\t' || *s == '\r' || *s == '\n'; s++ ) { }
+        const char *sNext;
+        for( sNext = s; *sNext && *sNext != ')' && *sNext != ','; sNext++ ) { }
+        Bu::String p( s, (ptrdiff_t)sNext-(ptrdiff_t)s );
+        lsParams.append( p );
+        sNext++;
+        s = sNext;
+    }
+    return hFuncs.get( sName )->call( sIn, lsParams );
 }
 
 void Bu::MiniMacro::addVar(
-        const Bu::String &sName, const Bu::String &sValue )
+    const Bu::String &sName, const Bu::String &sValue )
 {
-        hVars.insert( sName, sValue );
+    hVars.insert( sName, sValue );
 }
 
 bool Bu::MiniMacro::hasVar( const Bu::String &sName )
 {
-        return hVars.has( sName );
+    return hVars.has( sName );
 }
 
 const Bu::String &Bu::MiniMacro::getVar( const Bu::String &sName )
 {
-        return hVars.get( sName );
+    return hVars.get( sName );
 }
 
 const Bu::StrHash &Bu::MiniMacro::getVars()
 {
-        return hVars;
+    return hVars;
 }
 
 int Bu::MiniMacro::getPosition()
 {
-        return iLastPos;
+    return iLastPos;
 }
 
diff --git a/src/unstable/minimacro.h b/src/unstable/minimacro.h
index dc38891..1c33ea4 100644
--- a/src/unstable/minimacro.h
+++ b/src/unstable/minimacro.h
@@ -13,118 +13,118 @@
 
 namespace Bu
 {
-        typedef Bu::Hash<Bu::String, Bu::String> StrHash;
-        /**
-         * A processor for Libbu++ brand Mini Macros.  These are really simple, but
-         * still fairly flexible.  It's mainly text replacement, but with a few
-         * extras like filter functions and conditional text segments.  So far we
-         * don't support loops or anything, I'm not sure we ever will.
-         *
-         * Anatomy of a mini macro:
-         * - Every macro begins with a two character code, the first character is
-         *   always '{', the second character determines the operation to perform.
-         * - If the '{' is followed by a character that is not valid it is not
-         *   considered for expansion and the characters are copied to the output.
-         * - Every macro ends with a closing '}'
-         * - Macro types:
-         *   - '=': variable replacement.  The '=' is immediatley followed by the
-         *     name of the variable to replace, then any number of optional filter
-         *     segments.
-         *   - '?': conditional text.  The '?' is immediately followed by the
-         *     variable to test.  This works two ways, the variable can be alone, in
-         *     which case it's existance is tested, or it can be followed by a "="
-         *     and a string to compare to.  This is then followed by a text segment
-         *     that will be used if the test is true, and an optional text segment
-         *     to be used if the test is false.
-         *   - ':': command.  The ':' is immediately followed by a command string,
-         *     of which there's only one right now, but that's ok.  These are not
-         *     put into the output stream, but instead mark something for the
-         *     parser.  Currently supported:
-         *     - {:end}: end of parsing, stop here, also make note of how many input
-         *       characters were used.
-         * - Segments:
-         *   - Each segment is seperated by a colon.
-         *   - Filter segments give the name of the filter, followed by
-         *     parenthesies.  Parameters may be provided within the parenthesies.
-         *   - Text segments should always be quoted, but may contain any characters
-         *     within the quotes, backslash is used as per C/ANSI/ISO standard.
-         *     You can also quote any text using [' '] instead of quotes, which
-         *     allows for nested strings.  The [' token is only recognised within
-         *     a macro.
-         *
-         *@verbatim
-         {=name:tolower()}
-         {=name:ccsplit("_"):toupper()}
-         {?name:"name exists and is {=name}"}
-         {?name:"{=name}":"no name!"}
-         {?name="bob":"You're named bob!":"Who are you?  I only know bob..."}
-         @endverbatim
-         */
-        class MiniMacro
-        {
-        public:
-                MiniMacro();
-                MiniMacro( const StrHash &sVarSrc );
-                virtual ~MiniMacro();
+    typedef Bu::Hash<Bu::String, Bu::String> StrHash;
+    /**
+     * A processor for Libbu++ brand Mini Macros.  These are really simple, but
+     * still fairly flexible.  It's mainly text replacement, but with a few
+     * extras like filter functions and conditional text segments.  So far we
+     * don't support loops or anything, I'm not sure we ever will.
+     *
+     * Anatomy of a mini macro:
+     * - Every macro begins with a two character code, the first character is
+     *   always '{', the second character determines the operation to perform.
+     * - If the '{' is followed by a character that is not valid it is not
+     *   considered for expansion and the characters are copied to the output.
+     * - Every macro ends with a closing '}'
+     * - Macro types:
+     *   - '=': variable replacement.  The '=' is immediatley followed by the
+     *     name of the variable to replace, then any number of optional filter
+     *     segments.
+     *   - '?': conditional text.  The '?' is immediately followed by the
+     *     variable to test.  This works two ways, the variable can be alone, in
+     *     which case it's existance is tested, or it can be followed by a "="
+     *     and a string to compare to.  This is then followed by a text segment
+     *     that will be used if the test is true, and an optional text segment
+     *     to be used if the test is false.
+     *   - ':': command.  The ':' is immediately followed by a command string,
+     *     of which there's only one right now, but that's ok.  These are not
+     *     put into the output stream, but instead mark something for the
+     *     parser.  Currently supported:
+     *     - {:end}: end of parsing, stop here, also make note of how many input
+     *       characters were used.
+     * - Segments:
+     *   - Each segment is seperated by a colon.
+     *   - Filter segments give the name of the filter, followed by
+     *     parenthesies.  Parameters may be provided within the parenthesies.
+     *   - Text segments should always be quoted, but may contain any characters
+     *     within the quotes, backslash is used as per C/ANSI/ISO standard.
+     *     You can also quote any text using [' '] instead of quotes, which
+     *     allows for nested strings.  The [' token is only recognised within
+     *     a macro.
+     *
+     *@verbatim
+     {=name:tolower()}
+     {=name:ccsplit("_"):toupper()}
+     {?name:"name exists and is {=name}"}
+     {?name:"{=name}":"no name!"}
+     {?name="bob":"You're named bob!":"Who are you?  I only know bob..."}
+     @endverbatim
+     */
+    class MiniMacro
+    {
+    public:
+        MiniMacro();
+        MiniMacro( const StrHash &sVarSrc );
+        virtual ~MiniMacro();
 
-                Bu::String parse( const Bu::String &sIn );
-                void addVar( const Bu::String &sName, const Bu::String &sValue );
-                bool hasVar( const Bu::String &sName );
-                const Bu::String &getVar( const Bu::String &sName );
-                const StrHash &getVars();
-                int getPosition();
+        Bu::String parse( const Bu::String &sIn );
+        void addVar( const Bu::String &sName, const Bu::String &sValue );
+        bool hasVar( const Bu::String &sName );
+        const Bu::String &getVar( const Bu::String &sName );
+        const StrHash &getVars();
+        int getPosition();
 
-        private:
-                const char *sCur;
-                Bu::String parseRepl();
-                Bu::String parseCond();
-                Bu::String parseCmd();
-                Bu::String callFunc(
-                        const Bu::String &sIn, const Bu::String &sFunc );
+    private:
+        const char *sCur;
+        Bu::String parseRepl();
+        Bu::String parseCond();
+        Bu::String parseCmd();
+        Bu::String callFunc(
+            const Bu::String &sIn, const Bu::String &sFunc );
 
-                StrHash hVars;
-                bool bContinue;
-                int iLastPos;
+        StrHash hVars;
+        bool bContinue;
+        int iLastPos;
 
-        public:
-                typedef Bu::List<Bu::String> StrList;
-                class Func
-                {
-                public:
-                        Func(){}
-                        virtual ~Func(){}
-                        virtual Bu::String call(
-                                const Bu::String &sIn, StrList &lsParam )=0;
-                };
+    public:
+        typedef Bu::List<Bu::String> StrList;
+        class Func
+        {
+        public:
+            Func(){}
+            virtual ~Func(){}
+            virtual Bu::String call(
+                const Bu::String &sIn, StrList &lsParam )=0;
+        };
 
-                class FuncToUpper : public Func
-                {
-                public:
-                        FuncToUpper(){}
-                        virtual ~FuncToUpper(){}
-                        virtual Bu::String call(
-                                const Bu::String &sIn, StrList & )
-                        {
-                                return sIn.toUpper();
-                        }
-                };
+        class FuncToUpper : public Func
+        {
+        public:
+            FuncToUpper(){}
+            virtual ~FuncToUpper(){}
+            virtual Bu::String call(
+                const Bu::String &sIn, StrList & )
+            {
+                return sIn.toUpper();
+            }
+        };
 
-                class FuncToLower : public Func
-                {
-                public:
-                        FuncToLower(){}
-                        virtual ~FuncToLower(){}
-                        virtual Bu::String call(
-                                const Bu::String &sIn, StrList & )
-                        {
-                                return sIn.toLower();
-                        }
-                };
-                
-        private:
-                typedef Bu::Hash<Bu::String,class Func *> FuncHash;
-                FuncHash hFuncs;
-        };
+        class FuncToLower : public Func
+        {
+        public:
+            FuncToLower(){}
+            virtual ~FuncToLower(){}
+            virtual Bu::String call(
+                const Bu::String &sIn, StrList & )
+            {
+                return sIn.toLower();
+            }
+        };
+        
+    private:
+        typedef Bu::Hash<Bu::String,class Func *> FuncHash;
+        FuncHash hFuncs;
+    };
 };
 
 #endif
diff --git a/src/unstable/myriadfs.cpp b/src/unstable/myriadfs.cpp
index 6ed176d..3680c3f 100644
--- a/src/unstable/myriadfs.cpp
+++ b/src/unstable/myriadfs.cpp
@@ -19,686 +19,686 @@ using Bu::Fmt;
 
 namespace Bu { subExceptionDef( MyriadFsException ) }
 
-#define Myriad_Fs_MAGIC_CODE            ((char *)"\xa7\x18\x8b\x39")
+#define Myriad_Fs_MAGIC_CODE        ((char *)"\xa7\x18\x8b\x39")
 
 Bu::MyriadFs::MyriadFs( Bu::Stream &rStore, int iBlockSize ) :
-        rStore( rStore ),
-        mStore( rStore, iBlockSize ),
-        iUser( 0 ),
-        iGroup( 0 )
+    rStore( rStore ),
+    mStore( rStore, iBlockSize ),
+    iUser( 0 ),
+    iGroup( 0 )
 {
 #ifndef WIN32
-        iUser = getuid();
-        iGroup = getgid();
+    iUser = getuid();
+    iGroup = getgid();
 #endif
 
-        if( mStore.hasStream( 1 ) )
-        {
-                // Check to see if this is a MyriadFs stream.
-                Bu::MyriadStream ms = mStore.openStream( 1 );
-                char sMagic[4];
-                if( ms.read( sMagic, 4 ) < 4 )
-                        throw MyriadFsException("The provided stream does not appear to be "
-                                "a MyriadFs stream.");
-                if( ::strncmp( sMagic, Myriad_Fs_MAGIC_CODE, 4 ) )
-                        throw MyriadFsException("The provided stream does not appear to be "
-                                "a MyriadFs stream.");
-        
-                int8_t iVer;
-                ms.read( &iVer, 1 );
-
-                int32_t iNumNodes;
-                ms.read( &iNumNodes, 4 );
-                for( int32_t j = 0; j < iNumNodes; j++ )
-                {
-                        int32_t iNode;
-                        int32_t iPos;
-                        ms.read( &iNode, 4 );
-                        ms.read( &iPos, 4 );
-                        hNodeIndex.insert( iNode, iPos );
-                }
-        }
-        else
-        {
-                // Create initial header stream
-                {
-                        mStore.createStream( 1 );
-                        Bu::MyriadStream ms = mStore.openStream( 1 );
-                        ms.write( Myriad_Fs_MAGIC_CODE, 4 );
-                        int8_t iVer = 1;
-                        int32_t iTmp = 1;
-                        ms.write( &iVer, 1 );
-                        ms.write( &iTmp, 4 ); // iNumNodes
-                        iTmp = 0;
-                        ms.write( &iTmp, 4 ); // iInode
-                        ms.write( &iTmp, 4 ); // iPosition
-                        hNodeIndex.insert( 0, 0 );
-                }
-
-                // Create initial inode stream, with one root node.
-                {
-                        mStore.createStream( 2 );
-                        Bu::MyriadStream ms = mStore.openStream( 2 );
-                        RawStat rs;
-                        rs.iNode = 0;
-                        rs.iUser = iUser;
-                        rs.iGroup = iGroup;
-                        rs.uPerms = 0755|typeDir;
-                        rs.iLinks = 1;
-                        rs.uStreamIndex = 3;
-                        rs.iCTime = rs.iMTime = rs.iATime = time(NULL);
-                        ms.write( &rs, sizeof(RawStat) );
-                }
-
-                // Create inode 0's storage stream.
-                {
-                        mStore.createStream( 3 );
-                        Bu::MyriadStream ms = mStore.openStream( 3 );
-                        int32_t iTmp32 = 0;
-                        ms.write( &iTmp32, 4 );         // iChildCount
-                }
-        }
+    if( mStore.hasStream( 1 ) )
+    {
+        // Check to see if this is a MyriadFs stream.
+        Bu::MyriadStream ms = mStore.openStream( 1 );
+        char sMagic[4];
+        if( ms.read( sMagic, 4 ) < 4 )
+            throw MyriadFsException("The provided stream does not appear to be "
+                "a MyriadFs stream.");
+        if( ::strncmp( sMagic, Myriad_Fs_MAGIC_CODE, 4 ) )
+            throw MyriadFsException("The provided stream does not appear to be "
+                "a MyriadFs stream.");
+    
+        int8_t iVer;
+        ms.read( &iVer, 1 );
+
+        int32_t iNumNodes;
+        ms.read( &iNumNodes, 4 );
+        for( int32_t j = 0; j < iNumNodes; j++ )
+        {
+            int32_t iNode;
+            int32_t iPos;
+            ms.read( &iNode, 4 );
+            ms.read( &iPos, 4 );
+            hNodeIndex.insert( iNode, iPos );
+        }
+    }
+    else
+    {
+        // Create initial header stream
+        {
+            mStore.createStream( 1 );
+            Bu::MyriadStream ms = mStore.openStream( 1 );
+            ms.write( Myriad_Fs_MAGIC_CODE, 4 );
+            int8_t iVer = 1;
+            int32_t iTmp = 1;
+            ms.write( &iVer, 1 );
+            ms.write( &iTmp, 4 ); // iNumNodes
+            iTmp = 0;
+            ms.write( &iTmp, 4 ); // iInode
+            ms.write( &iTmp, 4 ); // iPosition
+            hNodeIndex.insert( 0, 0 );
+        }
+
+        // Create initial inode stream, with one root node.
+        {
+            mStore.createStream( 2 );
+            Bu::MyriadStream ms = mStore.openStream( 2 );
+            RawStat rs;
+            rs.iNode = 0;
+            rs.iUser = iUser;
+            rs.iGroup = iGroup;
+            rs.uPerms = 0755|typeDir;
+            rs.iLinks = 1;
+            rs.uStreamIndex = 3;
+            rs.iCTime = rs.iMTime = rs.iATime = time(NULL);
+            ms.write( &rs, sizeof(RawStat) );
+        }
+
+        // Create inode 0's storage stream.
+        {
+            mStore.createStream( 3 );
+            Bu::MyriadStream ms = mStore.openStream( 3 );
+            int32_t iTmp32 = 0;
+            ms.write( &iTmp32, 4 );     // iChildCount
+        }
+    }
 }
 
 Bu::MyriadFs::~MyriadFs()
 {
-        writeHeader();
+    writeHeader();
 }
 
 void Bu::MyriadFs::stat( const Bu::String &sPath, Bu::MyriadFs::Stat &rBuf )
 {
-        int32_t iParent;
-        int32_t iNode = lookupInode( sPath, iParent );
-        Bu::MyriadStream is = mStore.openStream( 2 );
-        stat( iNode, rBuf, is );
+    int32_t iParent;
+    int32_t iNode = lookupInode( sPath, iParent );
+    Bu::MyriadStream is = mStore.openStream( 2 );
+    stat( iNode, rBuf, is );
 }
 
 Bu::MyriadStream Bu::MyriadFs::open( const Bu::String &sPath, int /*iMode*/,
-                uint16_t uPerms )
-{
-        int32_t iParent = -1;
-        int32_t iNode;
-        try
-        {
-                iNode = lookupInode( sPath, iParent );
-                sio << "File found." << sio.nl;
-                // The file was found
-                return openByInode( iNode );
-        }
-        catch( Bu::MyriadFsException &e )
-        {
-                if( iParent < 0 )
-                        throw;
-
-                // This means that an intermediate path component couldn't be found
-                if( e.getErrorCode() == 1 )
-                        throw;
-
-                // The file wasn't found, but the path leading up to it was.
-                // first, figure out the final path element...
-                Bu::String sName = filePart( sPath );
-                sio << "End filename: " << sName << sio.nl;
-                sio << "Parent inode: " << iParent << sio.nl;
-                iNode = create( iParent, sName, (uPerms&permMask)|typeRegFile, 0 );
-                sio << "New iNode: " << iNode << sio.nl;
-                return openByInode( iNode );
-        }
+        uint16_t uPerms )
+{
+    int32_t iParent = -1;
+    int32_t iNode;
+    try
+    {
+        iNode = lookupInode( sPath, iParent );
+        sio << "File found." << sio.nl;
+        // The file was found
+        return openByInode( iNode );
+    }
+    catch( Bu::MyriadFsException &e )
+    {
+        if( iParent < 0 )
+            throw;
+
+        // This means that an intermediate path component couldn't be found
+        if( e.getErrorCode() == 1 )
+            throw;
+
+        // The file wasn't found, but the path leading up to it was.
+        // first, figure out the final path element...
+        Bu::String sName = filePart( sPath );
+        sio << "End filename: " << sName << sio.nl;
+        sio << "Parent inode: " << iParent << sio.nl;
+        iNode = create( iParent, sName, (uPerms&permMask)|typeRegFile, 0 );
+        sio << "New iNode: " << iNode << sio.nl;
+        return openByInode( iNode );
+    }
 }
 
 void Bu::MyriadFs::create( const Bu::String &sPath, uint16_t iPerms )
 {
-        create( sPath, iPerms, 0 );
+    create( sPath, iPerms, 0 );
 }
 
 void Bu::MyriadFs::create( const Bu::String &sPath, uint16_t iPerms,
-                uint16_t iDevHi, uint16_t iDevLo )
+        uint16_t iDevHi, uint16_t iDevLo )
 {
-        create( sPath, iPerms, ((uint32_t)iDevHi<<16)|(uint32_t)iDevLo );
+    create( sPath, iPerms, ((uint32_t)iDevHi<<16)|(uint32_t)iDevLo );
 }
 
 void Bu::MyriadFs::create( const Bu::String &sPath, uint16_t iPerms,
-                uint32_t uSpecial )
-{
-        int32_t iParent = -1;
-        int32_t iNode;
-        try
-        {
-                iNode = lookupInode( sPath, iParent );
-                sio << "File found." << sio.nl;
-                // The file was found
-                throw Bu::MyriadFsException("Path already exists.");
-        }
-        catch( Bu::MyriadFsException &e )
-        {
-                if( iParent < 0 )
-                        throw;
-
-                // This means that an intermediate path component couldn't be found
-                if( e.getErrorCode() == 1 )
-                        throw;
-
-                // The file wasn't found, but the path leading up to it was.
-                // first, figure out the final path element...
-                Bu::String sName = filePart( sPath );
-                sio << "End filename: " << sName << sio.nl;
-                sio << "Parent inode: " << iParent << sio.nl;
-                iNode = create( iParent, sName, iPerms, uSpecial );
-                sio << "New iNode: " << iNode << sio.nl;
-        }
+        uint32_t uSpecial )
+{
+    int32_t iParent = -1;
+    int32_t iNode;
+    try
+    {
+        iNode = lookupInode( sPath, iParent );
+        sio << "File found." << sio.nl;
+        // The file was found
+        throw Bu::MyriadFsException("Path already exists.");
+    }
+    catch( Bu::MyriadFsException &e )
+    {
+        if( iParent < 0 )
+            throw;
+
+        // This means that an intermediate path component couldn't be found
+        if( e.getErrorCode() == 1 )
+            throw;
+
+        // The file wasn't found, but the path leading up to it was.
+        // first, figure out the final path element...
+        Bu::String sName = filePart( sPath );
+        sio << "End filename: " << sName << sio.nl;
+        sio << "Parent inode: " << iParent << sio.nl;
+        iNode = create( iParent, sName, iPerms, uSpecial );
+        sio << "New iNode: " << iNode << sio.nl;
+    }
 }
 
 void Bu::MyriadFs::mkDir( const Bu::String &sPath, uint16_t iPerms )
 {
-        create( sPath, (iPerms&permMask)|typeDir, 0 );
+    create( sPath, (iPerms&permMask)|typeDir, 0 );
 }
 
 void Bu::MyriadFs::mkSymLink( const Bu::String &sTarget,
-                const Bu::String &sPath )
-{
-        int32_t iParent = -1;
-        int32_t iNode;
-        try
-        {
-                iNode = lookupInode( sPath, iParent );
-                throw Bu::MyriadFsException("Path already exists.");
-        }
-        catch( Bu::MyriadFsException &e )
-        {
-                if( iParent < 0 )
-                        throw;
-
-                // This means that an intermediate path component couldn't be found
-                if( e.getErrorCode() == 1 )
-                        throw;
-
-                // The file wasn't found, but the path leading up to it was.
-                // first, figure out the final path element...
-                Bu::String sName = filePart( sPath );
-                sio << "End filename: " << sName << sio.nl;
-                sio << "Parent inode: " << iParent << sio.nl;
-                iNode = create( iParent, sName, 0777|typeSymLink, 0 );
-                sio << "New iNode: " << iNode << sio.nl;
-                MyriadStream ms = openByInode( iNode );
-                ms.write( sTarget );
-        }
+        const Bu::String &sPath )
+{
+    int32_t iParent = -1;
+    int32_t iNode;
+    try
+    {
+        iNode = lookupInode( sPath, iParent );
+        throw Bu::MyriadFsException("Path already exists.");
+    }
+    catch( Bu::MyriadFsException &e )
+    {
+        if( iParent < 0 )
+            throw;
+
+        // This means that an intermediate path component couldn't be found
+        if( e.getErrorCode() == 1 )
+            throw;
+
+        // The file wasn't found, but the path leading up to it was.
+        // first, figure out the final path element...
+        Bu::String sName = filePart( sPath );
+        sio << "End filename: " << sName << sio.nl;
+        sio << "Parent inode: " << iParent << sio.nl;
+        iNode = create( iParent, sName, 0777|typeSymLink, 0 );
+        sio << "New iNode: " << iNode << sio.nl;
+        MyriadStream ms = openByInode( iNode );
+        ms.write( sTarget );
+    }
 }
 
 void Bu::MyriadFs::mkHardLink( const Bu::String &sTarget,
-                const Bu::String &sPath )
-{
-        int32_t iParent = -1;
-        int32_t iNode;
-        
-        iNode = lookupInode( sTarget, iParent );
-
-        try
-        {
-                lookupInode( sPath, iParent );
-                throw Bu::MyriadFsException("Path already exists.");
-        }
-        catch( Bu::MyriadFsException &e )
-        {
-                if( iParent < 0 )
-                        throw;
-
-                // This means that an intermediate path component couldn't be found
-                if( e.getErrorCode() == 1 )
-                        throw;
-
-                // The file wasn't found, but the path leading up to it was.
-                // first, figure out the final path element...
-                Bu::String sName = filePart( sPath );
-                sio << "End filename: " << sName << sio.nl;
-                sio << "Parent inode: " << iParent << sio.nl;
-                addToDir( iParent, iNode, sName );
-                MyriadStream is = mStore.openStream( 2 );
-                RawStat rs;
-                readInode( iNode, rs, is );
-                rs.iLinks++;
-                writeInode( rs, is );
-        }
+        const Bu::String &sPath )
+{
+    int32_t iParent = -1;
+    int32_t iNode;
+    
+    iNode = lookupInode( sTarget, iParent );
+
+    try
+    {
+        lookupInode( sPath, iParent );
+        throw Bu::MyriadFsException("Path already exists.");
+    }
+    catch( Bu::MyriadFsException &e )
+    {
+        if( iParent < 0 )
+            throw;
+
+        // This means that an intermediate path component couldn't be found
+        if( e.getErrorCode() == 1 )
+            throw;
+
+        // The file wasn't found, but the path leading up to it was.
+        // first, figure out the final path element...
+        Bu::String sName = filePart( sPath );
+        sio << "End filename: " << sName << sio.nl;
+        sio << "Parent inode: " << iParent << sio.nl;
+        addToDir( iParent, iNode, sName );
+        MyriadStream is = mStore.openStream( 2 );
+        RawStat rs;
+        readInode( iNode, rs, is );
+        rs.iLinks++;
+        writeInode( rs, is );
+    }
 }
 
 Bu::String Bu::MyriadFs::readSymLink( const Bu::String &sPath )
 {
-        int32_t iParent = -1;
-        int32_t iNode;
-        iNode = lookupInode( sPath, iParent );
-        MyriadStream ms = openByInode( iNode );
-        Bu::String sRet;
-        sRet.setSize( ms.getSize() );
-        ms.read( sRet.getStr(), ms.getSize() );
-        return sRet;
+    int32_t iParent = -1;
+    int32_t iNode;
+    iNode = lookupInode( sPath, iParent );
+    MyriadStream ms = openByInode( iNode );
+    Bu::String sRet;
+    sRet.setSize( ms.getSize() );
+    ms.read( sRet.getStr(), ms.getSize() );
+    return sRet;
 }
 
 Bu::MyriadFs::Dir Bu::MyriadFs::readDir( const Bu::String &sPath )
 {
-        int32_t iParent = -1;
-        int32_t iNode = lookupInode( sPath, iParent );
-        return readDir( iNode );
+    int32_t iParent = -1;
+    int32_t iNode = lookupInode( sPath, iParent );
+    return readDir( iNode );
 }
 
 void Bu::MyriadFs::setTimes( const Bu::String &sPath, int64_t iATime,
-                int64_t iMTime )
+        int64_t iMTime )
 {
-        int32_t iParent = -1;
-        int32_t iNode;
+    int32_t iParent = -1;
+    int32_t iNode;
 
-        iNode = lookupInode( sPath, iParent );
-        
-        setTimes( iNode, iATime, iMTime );
+    iNode = lookupInode( sPath, iParent );
+    
+    setTimes( iNode, iATime, iMTime );
 }
 
 void Bu::MyriadFs::unlink( const Bu::String &sPath )
 {
-        int32_t iParent = -1;
-//      int32_t iNode;
-
-        /*iNode =*/ lookupInode( sPath, iParent );
-
-        Dir lDir = readDir( iParent );
-
-        Bu::String sName = filePart( sPath );
-
-        for( Dir::iterator i = lDir.begin(); i; i++ )
-        {
-                if( sName == (*i).sName )
-                {
-                        RawStat rs;
-                        readInode( (*i).iNode, rs );
-                        if( (rs.uPerms&typeMask) == typeDir )
-                        {
-                                MyriadStream msDir = mStore.openStream( rs.uStreamIndex );
-                                int32_t iCount;
-                                msDir.read( &iCount, 4 );
-                                if( iCount > 0 )
-                                {
-                                        throw Bu::MyriadFsException("Directory not empty.");
-                                }
-                        }
-                        if( --rs.iLinks == 0 )
-                        {
-                                destroyNode( (*i).iNode );
-                        }
-                        else
-                        {
-                                writeInode( rs );
-                        }
-                        lDir.erase( i );
-                        break;
-                }
-        }
-        
-        Bu::MyriadStream ms = openByInode( iParent );
-        int32_t iNumChildren = lDir.getSize();
-        ms.write( &iNumChildren, 4 );
-        for( Dir::iterator i = lDir.begin(); i; i++ )
-        {
-                ms.write( &(*i).iNode, 4 );
-                uint8_t iSize = (*i).sName.getSize();
-                ms.write( &iSize, 1 );
-                ms.write( (*i).sName.getStr(), iSize );
-        }
-        ms.setSize( ms.tell() );
+    int32_t iParent = -1;
+//  int32_t iNode;
+
+    /*iNode =*/ lookupInode( sPath, iParent );
+
+    Dir lDir = readDir( iParent );
+
+    Bu::String sName = filePart( sPath );
+
+    for( Dir::iterator i = lDir.begin(); i; i++ )
+    {
+        if( sName == (*i).sName )
+        {
+            RawStat rs;
+            readInode( (*i).iNode, rs );
+            if( (rs.uPerms&typeMask) == typeDir )
+            {
+                MyriadStream msDir = mStore.openStream( rs.uStreamIndex );
+                int32_t iCount;
+                msDir.read( &iCount, 4 );
+                if( iCount > 0 )
+                {
+                    throw Bu::MyriadFsException("Directory not empty.");
+                }
+            }
+            if( --rs.iLinks == 0 )
+            {
+                destroyNode( (*i).iNode );
+            }
+            else
+            {
+                writeInode( rs );
+            }
+            lDir.erase( i );
+            break;
+        }
+    }
+    
+    Bu::MyriadStream ms = openByInode( iParent );
+    int32_t iNumChildren = lDir.getSize();
+    ms.write( &iNumChildren, 4 );
+    for( Dir::iterator i = lDir.begin(); i; i++ )
+    {
+        ms.write( &(*i).iNode, 4 );
+        uint8_t iSize = (*i).sName.getSize();
+        ms.write( &iSize, 1 );
+        ms.write( (*i).sName.getStr(), iSize );
+    }
+    ms.setSize( ms.tell() );
 }
 
 void Bu::MyriadFs::setFileSize( const Bu::String &sPath, int32_t iSize )
 {
-        int32_t iParent = -1;
-        int32_t iNode;
-        iNode = lookupInode( sPath, iParent );
-        MyriadStream ms = openByInode( iNode );
-        ms.setSize( iSize );
+    int32_t iParent = -1;
+    int32_t iNode;
+    iNode = lookupInode( sPath, iParent );
+    MyriadStream ms = openByInode( iNode );
+    ms.setSize( iSize );
 }
 
 void Bu::MyriadFs::rename( const Bu::String &sFrom, const Bu::String &sTo )
 {
-        mkHardLink( sFrom, sTo );
-        unlink( sFrom );
+    mkHardLink( sFrom, sTo );
+    unlink( sFrom );
 }
 
 dev_t Bu::MyriadFs::devToSys( uint32_t uDev )
 {
-        return (((uDev&0xFFFF0000)>>8)&0xFF00) | ((uDev&0xFF));
+    return (((uDev&0xFFFF0000)>>8)&0xFF00) | ((uDev&0xFF));
 }
 
 uint32_t Bu::MyriadFs::sysToDev( dev_t uDev )
 {
-        return (((uint32_t)uDev&0xFF00)<<8) | ((uint32_t)uDev&0xFF);
+    return (((uint32_t)uDev&0xFF00)<<8) | ((uint32_t)uDev&0xFF);
 }
 
 int32_t Bu::MyriadFs::lookupInode( const Bu::String &sPath, int32_t &iParent )
 {
-        if( sPath == "/" )
-        {
-                return 0;
-        }
-        if( sPath[0] == '/' )
-        {
-                // Absolute lookup
-                return lookupInode( sPath.begin()+1, 0, iParent );
-        }
-        else
-        {
-                // Relative lookup
-                throw Bu::ExceptionBase(
-                        "Relative lookups in MyriadFs are not working yet.");
-        }
+    if( sPath == "/" )
+    {
+        return 0;
+    }
+    if( sPath[0] == '/' )
+    {
+        // Absolute lookup
+        return lookupInode( sPath.begin()+1, 0, iParent );
+    }
+    else
+    {
+        // Relative lookup
+        throw Bu::ExceptionBase(
+            "Relative lookups in MyriadFs are not working yet.");
+    }
 }
 
 int32_t Bu::MyriadFs::lookupInode( Bu::String::const_iterator iStart,
-                int32_t iNode, int32_t &iParent )
-{
-        iParent = iNode;
-
-        Bu::String::const_iterator iEnd = iStart.find('/');
-        Bu::String sTok( iStart, iEnd );
-
-//      sio << "Direcotry component: " << sTok << sio.nl;
-
-        Dir lDir = readDir( iNode );
-
-        for( Dir::iterator i = lDir.begin(); i; i++ )
-        {
-                if( (*i).sName == sTok )
-                {
-                        // We found an item
-                        if( !iEnd )
-                        {
-                                // It's the last one in the requested path, return it
-                                return (*i).iNode;
-                        }
-                        else
-                        {
-                                // Not the last one in our path, double check it's a dir
-                                if( ((*i).uPerms&typeMask) == typeDir )
-                                {
-                                        return lookupInode( iEnd+1, (*i).iNode, iParent );
-                                }
-                                else
-                                {
-                                        iParent = -1;
-                                        throw Bu::MyriadFsException(
-                                                "Element '%s' in given path is not a directory.",
-                                                sTok.getStr() );
-                                }
-                        }
-                }
-        }
-
-        if( iEnd )
-                throw Bu::MyriadFsException( 1, "Path not found");
-        else
-                throw Bu::MyriadFsException( 2, "Path not found");
+        int32_t iNode, int32_t &iParent )
+{
+    iParent = iNode;
+
+    Bu::String::const_iterator iEnd = iStart.find('/');
+    Bu::String sTok( iStart, iEnd );
+
+//  sio << "Direcotry component: " << sTok << sio.nl;
+
+    Dir lDir = readDir( iNode );
+
+    for( Dir::iterator i = lDir.begin(); i; i++ )
+    {
+        if( (*i).sName == sTok )
+        {
+            // We found an item
+            if( !iEnd )
+            {
+                // It's the last one in the requested path, return it
+                return (*i).iNode;
+            }
+            else
+            {
+                // Not the last one in our path, double check it's a dir
+                if( ((*i).uPerms&typeMask) == typeDir )
+                {
+                    return lookupInode( iEnd+1, (*i).iNode, iParent );
+                }
+                else
+                {
+                    iParent = -1;
+                    throw Bu::MyriadFsException(
+                        "Element '%s' in given path is not a directory.",
+                        sTok.getStr() );
+                }
+            }
+        }
+    }
+
+    if( iEnd )
+        throw Bu::MyriadFsException( 1, "Path not found");
+    else
+        throw Bu::MyriadFsException( 2, "Path not found");
 }
 
 void Bu::MyriadFs::readInode( int32_t iNode, RawStat &rs, MyriadStream &rIs )
 {
-        rIs.setPos( hNodeIndex.get( iNode )*sizeof(RawStat) );
-        if( rIs.read( &rs, sizeof(RawStat) ) < (int)sizeof(RawStat) )
-                throw Bu::MyriadFsException("Filesystem corruption detected.");
-        if( rs.iNode != iNode )
-                throw Bu::MyriadFsException("Filesystem corruption detected.");
+    rIs.setPos( hNodeIndex.get( iNode )*sizeof(RawStat) );
+    if( rIs.read( &rs, sizeof(RawStat) ) < (int)sizeof(RawStat) )
+        throw Bu::MyriadFsException("Filesystem corruption detected.");
+    if( rs.iNode != iNode )
+        throw Bu::MyriadFsException("Filesystem corruption detected.");
 }
 
 void Bu::MyriadFs::readInode( int32_t iNode, RawStat &rs )
 {
-        MyriadStream ms = mStore.openStream( 2 );
-        readInode( iNode, rs, ms );
+    MyriadStream ms = mStore.openStream( 2 );
+    readInode( iNode, rs, ms );
 }
 
 void Bu::MyriadFs::writeInode( const RawStat &rs,
-                MyriadStream &rOs )
+        MyriadStream &rOs )
 {
-        rOs.setSize( hNodeIndex.getSize()*sizeof(RawStat) );
-        rOs.setPos( hNodeIndex.get( rs.iNode )*sizeof(RawStat) );
-        if( rOs.write( &rs, sizeof(RawStat) ) < (int)sizeof(RawStat) )
-                throw Bu::MyriadFsException("Error writing inode to header stream.");
+    rOs.setSize( hNodeIndex.getSize()*sizeof(RawStat) );
+    rOs.setPos( hNodeIndex.get( rs.iNode )*sizeof(RawStat) );
+    if( rOs.write( &rs, sizeof(RawStat) ) < (int)sizeof(RawStat) )
+        throw Bu::MyriadFsException("Error writing inode to header stream.");
 }
 
 void Bu::MyriadFs::writeInode( const RawStat &rs )
 {
-        MyriadStream ms = mStore.openStream( 2 );
-        writeInode( rs, ms );
+    MyriadStream ms = mStore.openStream( 2 );
+    writeInode( rs, ms );
 }
 
 Bu::MyriadFs::Dir Bu::MyriadFs::readDir( int32_t iNode )
 {
-        Bu::MyriadStream ms = openByInode( iNode );
-        int32_t iNumChildren = 0;
-        ms.read( &iNumChildren, 4 );
-        
-        Bu::MyriadStream is = mStore.openStream( 2 );
-        Dir lDir;
-//      sio << "Reading dir, " << iNumChildren << " entries:" << sio.nl;
-        for( int32_t j = 0; j < iNumChildren; j++ )
-        {
-                int32_t iChildNode;
-                ms.read( &iChildNode, 4 );
-                Stat s;
-                stat( iChildNode, s, is );
-                uint8_t uLen;
-                ms.read( &uLen, 1 );
-                s.sName.setSize( uLen );
-                ms.read( s.sName.getStr(), uLen );
-                lDir.append( s );
-
-//              sio << "    " << s.sName << sio.nl;
-        }
-
-        return lDir;
+    Bu::MyriadStream ms = openByInode( iNode );
+    int32_t iNumChildren = 0;
+    ms.read( &iNumChildren, 4 );
+    
+    Bu::MyriadStream is = mStore.openStream( 2 );
+    Dir lDir;
+//  sio << "Reading dir, " << iNumChildren << " entries:" << sio.nl;
+    for( int32_t j = 0; j < iNumChildren; j++ )
+    {
+        int32_t iChildNode;
+        ms.read( &iChildNode, 4 );
+        Stat s;
+        stat( iChildNode, s, is );
+        uint8_t uLen;
+        ms.read( &uLen, 1 );
+        s.sName.setSize( uLen );
+        ms.read( s.sName.getStr(), uLen );
+        lDir.append( s );
+
+//      sio << "    " << s.sName << sio.nl;
+    }
+
+    return lDir;
 }
 
 Bu::MyriadStream Bu::MyriadFs::openByInode( int32_t iNode )
 {
-        RawStat rs;
-        readInode( iNode, rs );
-        switch( (rs.uPerms&typeMask) )
-        {
-                case typeDir:
-                case typeSymLink:
-                case typeRegFile:
-                        return mStore.openStream( rs.uStreamIndex );
+    RawStat rs;
+    readInode( iNode, rs );
+    switch( (rs.uPerms&typeMask) )
+    {
+        case typeDir:
+        case typeSymLink:
+        case typeRegFile:
+            return mStore.openStream( rs.uStreamIndex );
 
-                default:
-                        throw Bu::MyriadFsException(
-                                "inode incorrect type for low-level openByInode.");
-        }
+        default:
+            throw Bu::MyriadFsException(
+                "inode incorrect type for low-level openByInode.");
+    }
 }
 
 void Bu::MyriadFs::addToDir( int32_t iDir, int32_t iNode,
-                const Bu::String &sName )
-{
-        if( sName.getSize() > 255 )
-        {
-                throw Bu::MyriadFsException("Filename too long, max is 255 bytes.");
-        }
-        Bu::MyriadStream ms = openByInode( iDir );
-        int32_t iNumChildren = 0;
-        ms.read( &iNumChildren, 4 );
-        iNumChildren++;
-        ms.setPos( 0 );
-        ms.write( &iNumChildren, 4 );
-        ms.setPosEnd( 0 );
-        ms.write( &iNode, 4 );
-        uint8_t uLen = sName.getSize();
-        ms.write( &uLen, 1 );
-        ms.write( sName.getStr(), uLen );
+        const Bu::String &sName )
+{
+    if( sName.getSize() > 255 )
+    {
+        throw Bu::MyriadFsException("Filename too long, max is 255 bytes.");
+    }
+    Bu::MyriadStream ms = openByInode( iDir );
+    int32_t iNumChildren = 0;
+    ms.read( &iNumChildren, 4 );
+    iNumChildren++;
+    ms.setPos( 0 );
+    ms.write( &iNumChildren, 4 );
+    ms.setPosEnd( 0 );
+    ms.write( &iNode, 4 );
+    uint8_t uLen = sName.getSize();
+    ms.write( &uLen, 1 );
+    ms.write( sName.getStr(), uLen );
 }
 
 int32_t Bu::MyriadFs::create( int32_t iParent, const Bu::String &sName,
-                uint16_t uPerms, uint32_t uSpecial )
+        uint16_t uPerms, uint32_t uSpecial )
 {
-        int32_t iNode = allocInode( uPerms, uSpecial );
-        addToDir( iParent, iNode, sName );
-        return iNode;
+    int32_t iNode = allocInode( uPerms, uSpecial );
+    addToDir( iParent, iNode, sName );
+    return iNode;
 }
 
 int32_t Bu::MyriadFs::allocInode( uint16_t uPerms, uint32_t uSpecial )
 {
-        int32_t iNode = 0;
-        for(; iNode < 0xfffffff; iNode++ )
-        {
-                if( !hNodeIndex.has( iNode ) )
-                {
-                        hNodeIndex.insert( iNode, hNodeIndex.getSize() );
-                        RawStat rs;
-                        rs.iNode = iNode;
-                        rs.iUser = iUser;
-                        rs.iGroup = iGroup;
-                        rs.uPerms = uPerms;
-                        rs.iLinks = 1;
-                        switch( (uPerms&typeMask) )
-                        {
-                                case typeRegFile:
-                                case typeSymLink:
-                                        rs.uStreamIndex = mStore.createStream();
-                                        break;
-                                
-                                case typeDir:
-                                        rs.uStreamIndex = mStore.createStream();
-                                        sio << "Creating directory node, storage: "
-                                                << rs.uStreamIndex << sio.nl;
-                                        {
-                                                Bu::MyriadStream msDir = mStore.openStream(
-                                                        rs.uStreamIndex
-                                                        );
-                                                uint32_t uSize = 0;
-                                                msDir.write( &uSize, 4 );
-                                        }
-                                        break;
-
-                                case typeChrDev:
-                                case typeBlkDev:
-                                        rs.uStreamIndex = uSpecial;
-                                        break;
-
-                                default:
-                                        rs.uStreamIndex = 0;
-                                        break;
-                        }
-                        rs.iATime = time(NULL);
-                        rs.iMTime = time(NULL);
-                        rs.iCTime = time(NULL);
-                        writeInode( rs );
-
-                        return iNode;
-                }
-        }
-
-        throw Bu::MyriadFsException(
-                "No inode could be allocated.  You've run out!");
+    int32_t iNode = 0;
+    for(; iNode < 0xfffffff; iNode++ )
+    {
+        if( !hNodeIndex.has( iNode ) )
+        {
+            hNodeIndex.insert( iNode, hNodeIndex.getSize() );
+            RawStat rs;
+            rs.iNode = iNode;
+            rs.iUser = iUser;
+            rs.iGroup = iGroup;
+            rs.uPerms = uPerms;
+            rs.iLinks = 1;
+            switch( (uPerms&typeMask) )
+            {
+                case typeRegFile:
+                case typeSymLink:
+                    rs.uStreamIndex = mStore.createStream();
+                    break;
+                
+                case typeDir:
+                    rs.uStreamIndex = mStore.createStream();
+                    sio << "Creating directory node, storage: "
+                        << rs.uStreamIndex << sio.nl;
+                    {
+                        Bu::MyriadStream msDir = mStore.openStream(
+                            rs.uStreamIndex
+                            );
+                        uint32_t uSize = 0;
+                        msDir.write( &uSize, 4 );
+                    }
+                    break;
+
+                case typeChrDev:
+                case typeBlkDev:
+                    rs.uStreamIndex = uSpecial;
+                    break;
+
+                default:
+                    rs.uStreamIndex = 0;
+                    break;
+            }
+            rs.iATime = time(NULL);
+            rs.iMTime = time(NULL);
+            rs.iCTime = time(NULL);
+            writeInode( rs );
+
+            return iNode;
+        }
+    }
+
+    throw Bu::MyriadFsException(
+        "No inode could be allocated.  You've run out!");
 }
 
 void Bu::MyriadFs::stat( int32_t iNode, Stat &rBuf, MyriadStream &rIs )
 {
-        RawStat rs;
-        readInode( iNode, rs, rIs );
-        rBuf.iNode = iNode;
-        rBuf.iUser = rs.iUser;
-        rBuf.iGroup = rs.iGroup;
-        rBuf.uPerms = rs.uPerms;
-        rBuf.iLinks = rs.iLinks;
-        rBuf.iATime = rs.iATime;
-        rBuf.iMTime = rs.iMTime;
-        rBuf.iCTime = rs.iCTime;
-        rBuf.uDev = 0;
-        rBuf.iSize = 0;
-        switch( (rBuf.uPerms&typeMask) )
-        {
-                case typeRegFile:
-                case typeSymLink:
-                        rBuf.iSize = mStore.getStreamSize( rs.uStreamIndex );
-                        break;
-
-                case typeChrDev:
-                case typeBlkDev:
-                        rBuf.uDev = rs.uStreamIndex;
-                        break;
-
-                default:
-                        rBuf.iSize = 0;
-                        break;
-        }
+    RawStat rs;
+    readInode( iNode, rs, rIs );
+    rBuf.iNode = iNode;
+    rBuf.iUser = rs.iUser;
+    rBuf.iGroup = rs.iGroup;
+    rBuf.uPerms = rs.uPerms;
+    rBuf.iLinks = rs.iLinks;
+    rBuf.iATime = rs.iATime;
+    rBuf.iMTime = rs.iMTime;
+    rBuf.iCTime = rs.iCTime;
+    rBuf.uDev = 0;
+    rBuf.iSize = 0;
+    switch( (rBuf.uPerms&typeMask) )
+    {
+        case typeRegFile:
+        case typeSymLink:
+            rBuf.iSize = mStore.getStreamSize( rs.uStreamIndex );
+            break;
+
+        case typeChrDev:
+        case typeBlkDev:
+            rBuf.uDev = rs.uStreamIndex;
+            break;
+
+        default:
+            rBuf.iSize = 0;
+            break;
+    }
 }
 
 void Bu::MyriadFs::writeHeader()
 {
-        Bu::MyriadStream ms = mStore.openStream( 1 );
-        ms.write( Myriad_Fs_MAGIC_CODE, 4 );
-        int8_t iVer = 1;
-        int32_t iNumNodes = hNodeIndex.getSize();
-        ms.write( &iVer, 1 );
-        ms.write( &iNumNodes, 4 ); // iNumNodes
-        for( NodeIndex::iterator i = hNodeIndex.begin(); i; i++ )
-        {
-                int32_t iNode = i.getKey();
-                int32_t iPosition = i.getValue();
-                ms.write( &iNode, 4 );
-                ms.write( &iPosition, 4 );
-        }
+    Bu::MyriadStream ms = mStore.openStream( 1 );
+    ms.write( Myriad_Fs_MAGIC_CODE, 4 );
+    int8_t iVer = 1;
+    int32_t iNumNodes = hNodeIndex.getSize();
+    ms.write( &iVer, 1 );
+    ms.write( &iNumNodes, 4 ); // iNumNodes
+    for( NodeIndex::iterator i = hNodeIndex.begin(); i; i++ )
+    {
+        int32_t iNode = i.getKey();
+        int32_t iPosition = i.getValue();
+        ms.write( &iNode, 4 );
+        ms.write( &iPosition, 4 );
+    }
 
-        // Truncate the stream afterwards so we don't use up too much space.
-        ms.setSize( ms.tell() );
+    // Truncate the stream afterwards so we don't use up too much space.
+    ms.setSize( ms.tell() );
 }
 
 void Bu::MyriadFs::setTimes( int32_t iNode, int64_t iATime, int64_t iMTime )
 {
-        RawStat rs;
-        Bu::MyriadStream is = mStore.openStream( 2 );
+    RawStat rs;
+    Bu::MyriadStream is = mStore.openStream( 2 );
 
-        readInode( iNode, rs, is );
-        rs.iATime = iATime;
-        rs.iMTime = iMTime;
-        writeInode( rs, is );
+    readInode( iNode, rs, is );
+    rs.iATime = iATime;
+    rs.iMTime = iMTime;
+    writeInode( rs, is );
 }
 
 void Bu::MyriadFs::destroyNode( int32_t iNode )
 {
-        if( iNode == 0 )
-                throw Bu::MyriadFsException("You cannot destroy the root.");
+    if( iNode == 0 )
+        throw Bu::MyriadFsException("You cannot destroy the root.");
 
-        Bu::MyriadStream is = mStore.openStream( 2 );
+    Bu::MyriadStream is = mStore.openStream( 2 );
 
-        // This will be overwritten with the last node
-        uint32_t iPosition = hNodeIndex.get( iNode );
-        RawStat rsOld;
-        readInode( iNode, rsOld, is );
-        switch( (rsOld.uPerms&typeMask) )
-        {
-                case typeRegFile:
-                case typeDir:
-                case typeSymLink:
-                        mStore.deleteStream( rsOld.uStreamIndex );
-                        break;
-        }
+    // This will be overwritten with the last node
+    uint32_t iPosition = hNodeIndex.get( iNode );
+    RawStat rsOld;
+    readInode( iNode, rsOld, is );
+    switch( (rsOld.uPerms&typeMask) )
+    {
+        case typeRegFile:
+        case typeDir:
+        case typeSymLink:
+            mStore.deleteStream( rsOld.uStreamIndex );
+            break;
+    }
 
-        hNodeIndex.erase( iNode );
+    hNodeIndex.erase( iNode );
 
-        // Read the last node, can't use the helpers, because we don't know the
-        // iNode yet.
-        if( iPosition != hNodeIndex.getSize() )
-        {
-                // If this is the last node, then we don't need to do anything, but
-                // this case handles what to do if we aren't on the last node
-                RawStat rs;
-                is.setPos( (hNodeIndex.getSize())*sizeof(RawStat) );
-                is.read( &rs, sizeof(RawStat) );
+    // Read the last node, can't use the helpers, because we don't know the
+    // iNode yet.
+    if( iPosition != hNodeIndex.getSize() )
+    {
+        // If this is the last node, then we don't need to do anything, but
+        // this case handles what to do if we aren't on the last node
+        RawStat rs;
+        is.setPos( (hNodeIndex.getSize())*sizeof(RawStat) );
+        is.read( &rs, sizeof(RawStat) );
 
-                hNodeIndex.get( rs.iNode ) = iPosition;
-                writeInode( rs, is );
-        }
+        hNodeIndex.get( rs.iNode ) = iPosition;
+        writeInode( rs, is );
+    }
 
-        is.setSize( hNodeIndex.getSize() * sizeof(RawStat) );
+    is.setSize( hNodeIndex.getSize() * sizeof(RawStat) );
 }
 
 Bu::String Bu::MyriadFs::filePart( const Bu::String &sPath )
 {
-        Bu::String::const_iterator iStart = sPath.begin();
-        if( *iStart == '/' )
-                iStart++;
-        for( Bu::String::const_iterator iEnd = iStart.find('/'); iEnd;
-                 iStart = iEnd+1, iEnd = iStart.find('/') ) { }
-        return Bu::String( iStart, sPath.end() );
+    Bu::String::const_iterator iStart = sPath.begin();
+    if( *iStart == '/' )
+        iStart++;
+    for( Bu::String::const_iterator iEnd = iStart.find('/'); iEnd;
+         iStart = iEnd+1, iEnd = iStart.find('/') ) { }
+    return Bu::String( iStart, sPath.end() );
 }
 
diff --git a/src/unstable/myriadfs.h b/src/unstable/myriadfs.h
index 126be7a..dfb051b 100644
--- a/src/unstable/myriadfs.h
+++ b/src/unstable/myriadfs.h
@@ -14,190 +14,190 @@
 
 namespace Bu
 {
-        class Stream;
-
-        subExceptionDecl( MyriadFsException );
-
-        /**
-         * A POSIX compliant, node based filesystem built on top of Myriad.
-         *
-         * A header is placed into stream 1.
-         * Header format:
-         *   int32_t iMagicHeader  (A7188B39)
-         *   int8_t iVersion (1)
-         *   int32_t iNumNodes
-         *   NodeLookup[iNumNodes] nNode
-         *
-         * Node lookup:
-         *   int32_t iInode
-         *   int32_t iPosition
-         *
-         * The node headers or inode structures have a base size of 44 bytes.
-         * The name is stored in the directory format.
-         * Basic node header format:
-         *   int32_t iNode
-         *   int32_t iUser
-         *   int32_t iGroup
-         *   uint16_t uPerms
-         *   int16_t iLinks
-         *   uint32_t uStreamIndex
-         *   int64_t iATime
-         *   int64_t iMTime
-         *   int64_t iCTime
-         *
-         * Some types get special formats for their assosiated data stream, or
-         * other special considerations, here's a list:
-         *
-         * - typeFifo: No stream, uStreamIndex unused (probably)
-         * - typeChrDev: No stream, uStreamIndex is device hi/lo
-         * - typeDir: The stream contains a directory contents listing, described
-         *            below
-         * - typeBlkDev: No stream, uStreamIndex is device hi/lo
-         * - typeRegFile: The stream is the file data
-         * - typeSymLink: The stream is the destination of the symlink
-         * - typeSocket: No steram, uStreamIndex unused (probably)
-         *
-         * Directory streams have this simple listing format.  They contain a list
-         * of all child elements, with no particular order at the moment.  The . and
-         * .. entries are not listed, they are implicit:
-         *   int32_t iNumNodes
-         *   NodeTable[iNumNodes] nChildren
-         *
-         * NodeTable:
-         *   int32_t iInode
-         *   uint8_t uNameSize
-         *   char[uNameSize] sName
-         */
-        class MyriadFs
-        {
-        public:
-                MyriadFs( Bu::Stream &rStore, int iBlockSize=512 );
-                virtual ~MyriadFs();
-
-                enum
-                {
-                        permOthX        = 0000001,
-                        permOthW        = 0000002,
-                        permOthR        = 0000004,
-                        permGrpX        = 0000010,
-                        permGrpW        = 0000020,
-                        permGrpR        = 0000040,
-                        permUsrX        = 0000100,
-                        permUsrW        = 0000200,
-                        permUsrR        = 0000400,
-                        permSticky      = 0001000,
-                        permSetGid      = 0002000,
-                        permSetUid      = 0004000,
-                        permMask        = 0007777,
-                        typeFifo        = 0010000,
-                        typeChrDev      = 0020000,
-                        typeDir         = 0040000,
-                        typeBlkDev      = 0060000,
-                        typeRegFile     = 0100000,
-                        typeSymLink     = 0120000,
-                        typeSocket      = 0140000,
-                        typeMask        = 0170000
-                };
-
-                enum
-                {
-                        Read            = 0x01, ///< Open file for reading
-                        Write           = 0x02, ///< Open file for writing
-                        Create          = 0x04, ///< Create file if it doesn't exist
-                        Truncate        = 0x08, ///< Truncate file if it does exist
-                        Append          = 0x10, ///< Always append on every write
-                        NonBlock        = 0x20, ///< Open file in non-blocking mode
-                        Exclusive       = 0x44, ///< Create file, if it exists then fail
-
-                        // Helpful mixes
-                        ReadWrite       = 0x03, ///< Open for reading and writing
-                        WriteNew        = 0x0E  ///< Create a file (or truncate) for writing.
-                                                                /// Same as Write|Create|Truncate
-                };
-                
-                class Stat
-                {
-                public:
-                        int32_t iNode;
-                        int32_t iUser;
-                        int32_t iGroup;
-                        uint16_t uPerms;
-                        int16_t iLinks;
-                        int64_t iATime;
-                        int64_t iMTime;
-                        int64_t iCTime;
-                        int32_t iSize;
-                        uint32_t uDev;
-                        Bu::String sName;
-                };
-                typedef Bu::List<Stat> Dir;
-
-                void stat( const Bu::String &sPath, Stat &rBuf );
-                MyriadStream open( const Bu::String &sPath, int iMode,
-                        uint16_t uPerms=0664 );
-                void create( const Bu::String &sPath, uint16_t iPerms );
-                void create( const Bu::String &sPath, uint16_t iPerms,
-                                uint16_t iDevHi, uint16_t iDevLo );
-                void create( const Bu::String &sPath, uint16_t iPerms,
-                                uint32_t uSpecial );
-                void mkDir( const Bu::String &sPath, uint16_t iPerms );
-                void mkSymLink( const Bu::String &sTarget, const Bu::String &sPath );
-                void mkHardLink( const Bu::String &sTarget, const Bu::String &sPath );
-                Bu::String readSymLink( const Bu::String &sPath );
-                Dir readDir( const Bu::String &sPath );
-                void setTimes( const Bu::String &sPath, int64_t iATime,
-                                int64_t iMTime );
-                void unlink( const Bu::String &sPath );
-                void setFileSize( const Bu::String &sPath, int32_t iSize );
-                void rename( const Bu::String &sFrom, const Bu::String &sTo );
-
-                static dev_t devToSys( uint32_t uDev );
-                static uint32_t sysToDev( dev_t uDev );
-
-        private:
-                class RawStat
-                {
-                public:
-                        int32_t iNode;
-                        int32_t iUser;
-                        int32_t iGroup;
-                        uint16_t uPerms;
-                        int16_t iLinks;
-                        uint32_t uStreamIndex;
-                        int64_t iATime;
-                        int64_t iMTime;
-                        int64_t iCTime;
-                };
-                typedef Bu::Hash<int32_t, int32_t> NodeIndex;
-
-        private:
-                int32_t lookupInode( const Bu::String &sPath, int32_t &iParent );
-                int32_t lookupInode( Bu::String::const_iterator iStart,
-                                int32_t iNode, int32_t &iParent );
-                void readInode( int32_t iNode, RawStat &rs, MyriadStream &rIs );
-                void readInode( int32_t iNode, RawStat &rs );
-                void writeInode( const RawStat &rs );
-                void writeInode( const RawStat &rs, MyriadStream &rOs );
-                Dir readDir( int32_t iNode );
-                MyriadStream openByInode( int32_t iNode );
-                void addToDir( int32_t iDir, int32_t iNode, const Bu::String &sName );
-                int32_t create( int32_t iParent, const Bu::String &sName,
-                                uint16_t uPerms, uint32_t uSpecial );
-                int32_t allocInode( uint16_t uPerms, uint32_t uSpecial );
-                void stat( int32_t iNode, Stat &rBuf, MyriadStream &rIs );
-                void writeHeader();
-                void setTimes( int32_t iNode, int64_t iATime, int64_t iMTime );
-                void destroyNode( int32_t iNode );
-
-                Bu::String filePart( const Bu::String &sPath );
-
-        private:
-                Bu::Stream &rStore;
-                Bu::Myriad mStore;
-                NodeIndex hNodeIndex;
-                int32_t iUser;
-                int32_t iGroup;
-        };
+    class Stream;
+
+    subExceptionDecl( MyriadFsException );
+
+    /**
+     * A POSIX compliant, node based filesystem built on top of Myriad.
+     *
+     * A header is placed into stream 1.
+     * Header format:
+     *   int32_t iMagicHeader  (A7188B39)
+     *   int8_t iVersion (1)
+     *   int32_t iNumNodes
+     *   NodeLookup[iNumNodes] nNode
+     *
+     * Node lookup:
+     *   int32_t iInode
+     *   int32_t iPosition
+     *
+     * The node headers or inode structures have a base size of 44 bytes.
+     * The name is stored in the directory format.
+     * Basic node header format:
+     *   int32_t iNode
+     *   int32_t iUser
+     *   int32_t iGroup
+     *   uint16_t uPerms
+     *   int16_t iLinks
+     *   uint32_t uStreamIndex
+     *   int64_t iATime
+     *   int64_t iMTime
+     *   int64_t iCTime
+     *
+     * Some types get special formats for their assosiated data stream, or
+     * other special considerations, here's a list:
+     *
+     * - typeFifo: No stream, uStreamIndex unused (probably)
+     * - typeChrDev: No stream, uStreamIndex is device hi/lo
+     * - typeDir: The stream contains a directory contents listing, described
+     *            below
+     * - typeBlkDev: No stream, uStreamIndex is device hi/lo
+     * - typeRegFile: The stream is the file data
+     * - typeSymLink: The stream is the destination of the symlink
+     * - typeSocket: No steram, uStreamIndex unused (probably)
+     *
+     * Directory streams have this simple listing format.  They contain a list
+     * of all child elements, with no particular order at the moment.  The . and
+     * .. entries are not listed, they are implicit:
+     *   int32_t iNumNodes
+     *   NodeTable[iNumNodes] nChildren
+     *
+     * NodeTable:
+     *   int32_t iInode
+     *   uint8_t uNameSize
+     *   char[uNameSize] sName
+     */
+    class MyriadFs
+    {
+    public:
+        MyriadFs( Bu::Stream &rStore, int iBlockSize=512 );
+        virtual ~MyriadFs();
+
+        enum
+        {
+            permOthX    = 0000001,
+            permOthW    = 0000002,
+            permOthR    = 0000004,
+            permGrpX    = 0000010,
+            permGrpW    = 0000020,
+            permGrpR    = 0000040,
+            permUsrX    = 0000100,
+            permUsrW    = 0000200,
+            permUsrR    = 0000400,
+            permSticky  = 0001000,
+            permSetGid  = 0002000,
+            permSetUid  = 0004000,
+            permMask    = 0007777,
+            typeFifo    = 0010000,
+            typeChrDev  = 0020000,
+            typeDir     = 0040000,
+            typeBlkDev  = 0060000,
+            typeRegFile = 0100000,
+            typeSymLink = 0120000,
+            typeSocket  = 0140000,
+            typeMask    = 0170000
+        };
+
+        enum
+        {
+            Read        = 0x01, ///< Open file for reading
+            Write       = 0x02, ///< Open file for writing
+            Create      = 0x04, ///< Create file if it doesn't exist
+            Truncate    = 0x08, ///< Truncate file if it does exist
+            Append      = 0x10, ///< Always append on every write
+            NonBlock    = 0x20, ///< Open file in non-blocking mode
+            Exclusive   = 0x44, ///< Create file, if it exists then fail
+
+            // Helpful mixes
+            ReadWrite   = 0x03, ///< Open for reading and writing
+            WriteNew    = 0x0E  ///< Create a file (or truncate) for writing.
+                                /// Same as Write|Create|Truncate
+        };
+        
+        class Stat
+        {
+        public:
+            int32_t iNode;
+            int32_t iUser;
+            int32_t iGroup;
+            uint16_t uPerms;
+            int16_t iLinks;
+            int64_t iATime;
+            int64_t iMTime;
+            int64_t iCTime;
+            int32_t iSize;
+            uint32_t uDev;
+            Bu::String sName;
+        };
+        typedef Bu::List<Stat> Dir;
+
+        void stat( const Bu::String &sPath, Stat &rBuf );
+        MyriadStream open( const Bu::String &sPath, int iMode,
+            uint16_t uPerms=0664 );
+        void create( const Bu::String &sPath, uint16_t iPerms );
+        void create( const Bu::String &sPath, uint16_t iPerms,
+                uint16_t iDevHi, uint16_t iDevLo );
+        void create( const Bu::String &sPath, uint16_t iPerms,
+                uint32_t uSpecial );
+        void mkDir( const Bu::String &sPath, uint16_t iPerms );
+        void mkSymLink( const Bu::String &sTarget, const Bu::String &sPath );
+        void mkHardLink( const Bu::String &sTarget, const Bu::String &sPath );
+        Bu::String readSymLink( const Bu::String &sPath );
+        Dir readDir( const Bu::String &sPath );
+        void setTimes( const Bu::String &sPath, int64_t iATime,
+                int64_t iMTime );
+        void unlink( const Bu::String &sPath );
+        void setFileSize( const Bu::String &sPath, int32_t iSize );
+        void rename( const Bu::String &sFrom, const Bu::String &sTo );
+
+        static dev_t devToSys( uint32_t uDev );
+        static uint32_t sysToDev( dev_t uDev );
+
+    private:
+        class RawStat
+        {
+        public:
+            int32_t iNode;
+            int32_t iUser;
+            int32_t iGroup;
+            uint16_t uPerms;
+            int16_t iLinks;
+            uint32_t uStreamIndex;
+            int64_t iATime;
+            int64_t iMTime;
+            int64_t iCTime;
+        };
+        typedef Bu::Hash<int32_t, int32_t> NodeIndex;
+
+    private:
+        int32_t lookupInode( const Bu::String &sPath, int32_t &iParent );
+        int32_t lookupInode( Bu::String::const_iterator iStart,
+                int32_t iNode, int32_t &iParent );
+        void readInode( int32_t iNode, RawStat &rs, MyriadStream &rIs );
+        void readInode( int32_t iNode, RawStat &rs );
+        void writeInode( const RawStat &rs );
+        void writeInode( const RawStat &rs, MyriadStream &rOs );
+        Dir readDir( int32_t iNode );
+        MyriadStream openByInode( int32_t iNode );
+        void addToDir( int32_t iDir, int32_t iNode, const Bu::String &sName );
+        int32_t create( int32_t iParent, const Bu::String &sName,
+                uint16_t uPerms, uint32_t uSpecial );
+        int32_t allocInode( uint16_t uPerms, uint32_t uSpecial );
+        void stat( int32_t iNode, Stat &rBuf, MyriadStream &rIs );
+        void writeHeader();
+        void setTimes( int32_t iNode, int64_t iATime, int64_t iMTime );
+        void destroyNode( int32_t iNode );
+
+        Bu::String filePart( const Bu::String &sPath );
+
+    private:
+        Bu::Stream &rStore;
+        Bu::Myriad mStore;
+        NodeIndex hNodeIndex;
+        int32_t iUser;
+        int32_t iGroup;
+    };
 };
 
 #endif
diff --git a/src/unstable/newline.cpp b/src/unstable/newline.cpp
index c7eb94c..50a4d4e 100644
--- a/src/unstable/newline.cpp
+++ b/src/unstable/newline.cpp
@@ -8,8 +8,8 @@
 #include "bu/newline.h"
 
 Bu::NewLine::NewLine( Bu::Stream &rNext ) :
-        Bu::Filter( rNext ),
-        bExChar( false )
+    Bu::Filter( rNext ),
+    bExChar( false )
 {
 }
 
@@ -23,46 +23,46 @@ void Bu::NewLine::start()
 
 Bu::size Bu::NewLine::stop()
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::NewLine::read( void *pBufV, Bu::size iAmnt )
 {
-        Bu::size iTotal = 0;
-        Bu::size iOffset = 0;
-        Bu::size iRead = rNext.read( pBufV, iAmnt );
-        char *pBuf = (char *)pBufV;
+    Bu::size iTotal = 0;
+    Bu::size iOffset = 0;
+    Bu::size iRead = rNext.read( pBufV, iAmnt );
+    char *pBuf = (char *)pBufV;
 
-        for( Bu::size i = 0; i < iRead; i++ )
-        {
-                if( pBuf[i] == '\r' )
-                {
-                        pBuf[i+iOffset] = '\n';
-                        if( pBuf[i+1] == '\n' )
-                        {
-                                iOffset--;
-                        }
-                }
-                else if( pBuf[i] == '\n' )
-                {
-                        pBuf[i+iOffset] = '\n';
-                        if( pBuf[i+1] == '\r' )
-                        {
-                                iOffset--;
-                        }
-                }
-                else if( iOffset )
-                {
-                        pBuf[i+iOffset] = pBuf[i];
-                }
-        }
+    for( Bu::size i = 0; i < iRead; i++ )
+    {
+        if( pBuf[i] == '\r' )
+        {
+            pBuf[i+iOffset] = '\n';
+            if( pBuf[i+1] == '\n' )
+            {
+                iOffset--;
+            }
+        }
+        else if( pBuf[i] == '\n' )
+        {
+            pBuf[i+iOffset] = '\n';
+            if( pBuf[i+1] == '\r' )
+            {
+                iOffset--;
+            }
+        }
+        else if( iOffset )
+        {
+            pBuf[i+iOffset] = pBuf[i];
+        }
+    }
 
-        iTotal += iRead + iOffset;
-        return iTotal;
+    iTotal += iRead + iOffset;
+    return iTotal;
 }
 
 Bu::size Bu::NewLine::write( const void *, Bu::size )
 {
-        return 0;
+    return 0;
 }
 
diff --git a/src/unstable/newline.h b/src/unstable/newline.h
index 417f8cc..1597dc6 100644
--- a/src/unstable/newline.h
+++ b/src/unstable/newline.h
@@ -12,30 +12,30 @@
 
 namespace Bu
 {
-        /**
-         * Converts new-line characters from any standard convention into linefeeds
-         * (\\n) on reading, and converts them to either your OS's standard or a
-         * specified standard, depending on how you construct the class.
-         *
-         * If you're reading in a text file, then this filter is practically
-         * required.
-         */
-        class NewLine : public Bu::Filter
-        {
-        public:
-                NewLine( Bu::Stream &rNext );
-                virtual ~NewLine();
+    /**
+     * Converts new-line characters from any standard convention into linefeeds
+     * (\\n) on reading, and converts them to either your OS's standard or a
+     * specified standard, depending on how you construct the class.
+     *
+     * If you're reading in a text file, then this filter is practically
+     * required.
+     */
+    class NewLine : public Bu::Filter
+    {
+    public:
+        NewLine( Bu::Stream &rNext );
+        virtual ~NewLine();
 
-                virtual void start();
-                virtual Bu::size stop();
+        virtual void start();
+        virtual Bu::size stop();
 
-                virtual Bu::size read( void *pBuf, Bu::size iAmnt );
-                virtual Bu::size write( const void *pBuf, Bu::size iAmnt );
+        virtual Bu::size read( void *pBuf, Bu::size iAmnt );
+        virtual Bu::size write( const void *pBuf, Bu::size iAmnt );
 
-        private:
-                bool bExChar;
-                char cExChar;
-        };
+    private:
+        bool bExChar;
+        char cExChar;
+    };
 };
 
 #endif
diff --git a/src/unstable/settings.cpp b/src/unstable/settings.cpp
index b812b60..ced8c97 100644
--- a/src/unstable/settings.cpp
+++ b/src/unstable/settings.cpp
@@ -5,46 +5,46 @@
 #include "bu/settingsdriverini.h"
 
 Bu::Settings::Settings( const Bu::UtfString &sCompany,
-                const Bu::UtfString &sProduct, Bu::Settings::Driver eDriver ) :
-        sCompany( sCompany ),
-        sProduct( sProduct ),
-        pDriver( NULL )
+        const Bu::UtfString &sProduct, Bu::Settings::Driver eDriver ) :
+    sCompany( sCompany ),
+    sProduct( sProduct ),
+    pDriver( NULL )
 {
-        switch( eDriver )
-        {
-                case DriverNative:
+    switch( eDriver )
+    {
+        case DriverNative:
 #if defined( WIN32 )
-                        pDriver = new Bu::SettingsDriverRegistry();
+            pDriver = new Bu::SettingsDriverRegistry();
 #else
-                        pDriver = new Bu::SettingsDriverIni();
+            pDriver = new Bu::SettingsDriverIni();
 #endif
-                        break;
+            break;
 
-                case DriverTaf:
-                        pDriver = new Bu::SettingsDriverTaf();
-                        break;
+        case DriverTaf:
+            pDriver = new Bu::SettingsDriverTaf();
+            break;
 
-                case DriverIni:
-                        pDriver = new Bu::SettingsDriverIni();
-                        break;
-        }
+        case DriverIni:
+            pDriver = new Bu::SettingsDriverIni();
+            break;
+    }
 
-        pDriver->init( sCompany, sProduct );
+    pDriver->init( sCompany, sProduct );
 }
 
 Bu::Settings::~Settings()
 {
-        delete pDriver;
+    delete pDriver;
 }
 
 void Bu::Settings::set( const Bu::UtfString &sKey, const Bu::UtfString &sValue )
 {
-        pDriver->set( sKey, sValue );
+    pDriver->set( sKey, sValue );
 }
 
 Bu::UtfString Bu::Settings::get( const Bu::UtfString &sKey,
-                const Bu::UtfString &sValue )
+        const Bu::UtfString &sValue )
 {
-        return pDriver->get( sKey, sValue );
+    return pDriver->get( sKey, sValue );
 }
 
diff --git a/src/unstable/settings.h b/src/unstable/settings.h
index c1d0e1c..80d3049 100644
--- a/src/unstable/settings.h
+++ b/src/unstable/settings.h
@@ -5,31 +5,31 @@
 
 namespace Bu
 {
-        /**
-         * Simple access to configuration data.  Provides a consistant, cross
-         * platform interface to configuration data using native storage.
-         */
-        class Settings
-        {
-        public:
-                enum Driver
-                {
-                        DriverNative,
-                        DriverTaf,
-                        DriverIni
-                };
-                Settings( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct,
-                        Driver driver=DriverNative );
-                virtual ~Settings();
+    /**
+     * Simple access to configuration data.  Provides a consistant, cross
+     * platform interface to configuration data using native storage.
+     */
+    class Settings
+    {
+    public:
+        enum Driver
+        {
+            DriverNative,
+            DriverTaf,
+            DriverIni
+        };
+        Settings( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct,
+            Driver driver=DriverNative );
+        virtual ~Settings();
 
-                void set( const Bu::UtfString &sKey, const Bu::UtfString &sValue );
-                Bu::UtfString get( const Bu::UtfString &sKey, const Bu::UtfString &sValue=Bu::UtfString() );
+        void set( const Bu::UtfString &sKey, const Bu::UtfString &sValue );
+        Bu::UtfString get( const Bu::UtfString &sKey, const Bu::UtfString &sValue=Bu::UtfString() );
 
-        private:
-                Bu::UtfString sCompany;
-                Bu::UtfString sProduct;
-                class SettingsDriver *pDriver;
-        };
+    private:
+        Bu::UtfString sCompany;
+        Bu::UtfString sProduct;
+        class SettingsDriver *pDriver;
+    };
 };
 
 #endif
diff --git a/src/unstable/settingsdriver.h b/src/unstable/settingsdriver.h
index 47b7d9d..4dfe09c 100644
--- a/src/unstable/settingsdriver.h
+++ b/src/unstable/settingsdriver.h
@@ -5,24 +5,24 @@
 
 namespace Bu
 {
-        class Settings;
+    class Settings;
 
-        /**
-         * Base class for i/o interfaces for Bu::Settings.  By subclassing this you
-         * can provide custom storage for application settings.
-         */
-        class SettingsDriver
-        {
-        friend class Bu::Settings;
-        public:
-                SettingsDriver();
-                virtual ~SettingsDriver();
+    /**
+     * Base class for i/o interfaces for Bu::Settings.  By subclassing this you
+     * can provide custom storage for application settings.
+     */
+    class SettingsDriver
+    {
+    friend class Bu::Settings;
+    public:
+        SettingsDriver();
+        virtual ~SettingsDriver();
 
-        protected:
-                virtual void init( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct )=0;
-                virtual void set( const Bu::UtfString &sKey, const Bu::UtfString  &sValue )=0;
-                virtual Bu::UtfString get( const Bu::UtfString &sKey, const Bu::UtfString &sValue )=0;
-        };
+    protected:
+        virtual void init( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct )=0;
+        virtual void set( const Bu::UtfString &sKey, const Bu::UtfString  &sValue )=0;
+        virtual Bu::UtfString get( const Bu::UtfString &sKey, const Bu::UtfString &sValue )=0;
+    };
 };
 
 #endif
diff --git a/src/unstable/settingsdriverini.cpp b/src/unstable/settingsdriverini.cpp
index 90debcb..31bc146 100644
--- a/src/unstable/settingsdriverini.cpp
+++ b/src/unstable/settingsdriverini.cpp
@@ -15,146 +15,146 @@ Bu::SettingsDriverIni::SettingsDriverIni()
 
 Bu::SettingsDriverIni::~SettingsDriverIni()
 {
-        Bu::File fOut( sPath, Bu::File::WriteNew );
-        Bu::Buffer bOut( fOut );
-        Bu::Formatter f( bOut );
-
-        for( GroupHash::iterator i = hGroup.begin(); i; i++ )
-        {
-                f << "[" << i.getKey().get() << "]" << f.nl;
-                for( StrHash::iterator k = (*i).begin(); k; k++ )
-                {
-                        f << k.getKey().get() << " = " << k.getValue().get() << f.nl;
-                }
-                f << f.nl;
-        }
+    Bu::File fOut( sPath, Bu::File::WriteNew );
+    Bu::Buffer bOut( fOut );
+    Bu::Formatter f( bOut );
+
+    for( GroupHash::iterator i = hGroup.begin(); i; i++ )
+    {
+        f << "[" << i.getKey().get() << "]" << f.nl;
+        for( StrHash::iterator k = (*i).begin(); k; k++ )
+        {
+            f << k.getKey().get() << " = " << k.getValue().get() << f.nl;
+        }
+        f << f.nl;
+    }
 }
 
 void Bu::SettingsDriverIni::init( const Bu::UtfString &sCompany,
-                const Bu::UtfString &sProduct )
+        const Bu::UtfString &sProduct )
 {
-        Bu::UtfString us( getenv("HOME") );
-        us += "/.config/";
-        us += sCompany;
-        us += "/";
-        us += sProduct;
-        sPath = us.get();
-        try
-        {
-                Bu::File fIn( sPath, Bu::File::Read|Bu::File::Create );
-                Bu::Buffer bIn( fIn );
-                StrHash hKeys;
-                Bu::String sGroup;
-                bool bStart = true;
-                while( !bIn.isEos() )
-                {
-                        Bu::String sIn = bIn.readLine();
-                        if( sIn.isEmpty() )
-                                continue;
-                        if( sIn[0] == '[' )
-                        {
-                                if( bStart != true )
-                                {
-                                        hGroup.insert( sGroup, hKeys );
-                                        hKeys.clear();
-                                }
-                                sGroup = Bu::String( sIn.begin()+1, sIn.find(']') );
-                                bStart = false;
-                        }
-                        else
-                        {
-                                Bu::String::iterator i = sIn.find('=');
-                                if( !i )
-                                        continue;
-
-                                hKeys.insert( Bu::String( sIn.begin(), i ).trimWhitespace(),
-                                        Bu::String( i+1, sIn.end() ).trimWhitespace() );
-                        }
-                }
-                hGroup.insert( sGroup, hKeys );
-        }
-        catch(...)
-        {
-        }
+    Bu::UtfString us( getenv("HOME") );
+    us += "/.config/";
+    us += sCompany;
+    us += "/";
+    us += sProduct;
+    sPath = us.get();
+    try
+    {
+        Bu::File fIn( sPath, Bu::File::Read|Bu::File::Create );
+        Bu::Buffer bIn( fIn );
+        StrHash hKeys;
+        Bu::String sGroup;
+        bool bStart = true;
+        while( !bIn.isEos() )
+        {
+            Bu::String sIn = bIn.readLine();
+            if( sIn.isEmpty() )
+                continue;
+            if( sIn[0] == '[' )
+            {
+                if( bStart != true )
+                {
+                    hGroup.insert( sGroup, hKeys );
+                    hKeys.clear();
+                }
+                sGroup = Bu::String( sIn.begin()+1, sIn.find(']') );
+                bStart = false;
+            }
+            else
+            {
+                Bu::String::iterator i = sIn.find('=');
+                if( !i )
+                    continue;
+
+                hKeys.insert( Bu::String( sIn.begin(), i ).trimWhitespace(),
+                    Bu::String( i+1, sIn.end() ).trimWhitespace() );
+            }
+        }
+        hGroup.insert( sGroup, hKeys );
+    }
+    catch(...)
+    {
+    }
 }
 
 void Bu::SettingsDriverIni::set( const Bu::UtfString &sKey, const Bu::UtfString  &sValue )
 {
-        Bu::String suKey = sKey.get();
-        Bu::String::iterator i = suKey.find('/');
-        Bu::UtfString sGrp;
-        Bu::UtfString sId;
-        if( !i )
-        {
-                sGrp = "";
-                sId = sKey;
-        }
-        else
-        {
-                Bu::String::iterator in;
-                for(;;)
-                {
-                        in = i;
-                        i = (in + 1).find('/');
-                        if( !i )
-                                break;
-                }
-
-                sGrp.set( Bu::String( suKey.begin(), in ) );
-                sId.set( Bu::String( in+1, suKey.end() ) );
-        }
-
-//      sio << "Group: " << sGrp.get() << sio.nl
-//              << "Key:   " << sId.get() << sio.nl;
-
-        if( !hGroup.has( sGrp ) )
-        {
-                StrHash hVal;
-                hVal.insert( sId, sValue );
-                hGroup.insert( sGrp, hVal );
-        }
-        else
-        {
-                hGroup.get( sGrp ).insert( sId, sValue );
-        }
+    Bu::String suKey = sKey.get();
+    Bu::String::iterator i = suKey.find('/');
+    Bu::UtfString sGrp;
+    Bu::UtfString sId;
+    if( !i )
+    {
+        sGrp = "";
+        sId = sKey;
+    }
+    else
+    {
+        Bu::String::iterator in;
+        for(;;)
+        {
+            in = i;
+            i = (in + 1).find('/');
+            if( !i )
+                break;
+        }
+
+        sGrp.set( Bu::String( suKey.begin(), in ) );
+        sId.set( Bu::String( in+1, suKey.end() ) );
+    }
+
+//  sio << "Group: " << sGrp.get() << sio.nl
+//      << "Key:   " << sId.get() << sio.nl;
+
+    if( !hGroup.has( sGrp ) )
+    {
+        StrHash hVal;
+        hVal.insert( sId, sValue );
+        hGroup.insert( sGrp, hVal );
+    }
+    else
+    {
+        hGroup.get( sGrp ).insert( sId, sValue );
+    }
 }
 
 Bu::UtfString Bu::SettingsDriverIni::get( const Bu::UtfString &sKey, const Bu::UtfString &sValue )
 {
-        Bu::String suKey = sKey.get();
-        Bu::String::iterator i = suKey.find('/');
-        Bu::UtfString sGrp;
-        Bu::UtfString sId;
-        if( !i )
-        {
-                sGrp = "";
-                sId = sKey;
-        }
-        else
-        {
-                Bu::String::iterator in;
-                for(;;)
-                {
-                        in = i;
-                        i = (in + 1).find('/');
-                        if( !i )
-                                break;
-                }
-
-                sGrp.set( Bu::String( suKey.begin(), in ) );
-                sId.set( Bu::String( in+1, suKey.end() ) );
-        }
-
-//      sio << "Group: " << sGrp.get() << sio.nl
-//              << "Key:   " << sId.get() << sio.nl;
-
-        try
-        {
-                return hGroup.get( sGrp ).get( sId );
-        }
-        catch(...)
-        {
-                return sValue;
-        }
+    Bu::String suKey = sKey.get();
+    Bu::String::iterator i = suKey.find('/');
+    Bu::UtfString sGrp;
+    Bu::UtfString sId;
+    if( !i )
+    {
+        sGrp = "";
+        sId = sKey;
+    }
+    else
+    {
+        Bu::String::iterator in;
+        for(;;)
+        {
+            in = i;
+            i = (in + 1).find('/');
+            if( !i )
+                break;
+        }
+
+        sGrp.set( Bu::String( suKey.begin(), in ) );
+        sId.set( Bu::String( in+1, suKey.end() ) );
+    }
+
+//  sio << "Group: " << sGrp.get() << sio.nl
+//      << "Key:   " << sId.get() << sio.nl;
+
+    try
+    {
+        return hGroup.get( sGrp ).get( sId );
+    }
+    catch(...)
+    {
+        return sValue;
+    }
 }
 
diff --git a/src/unstable/settingsdriverini.h b/src/unstable/settingsdriverini.h
index c3942d6..bd3097d 100644
--- a/src/unstable/settingsdriverini.h
+++ b/src/unstable/settingsdriverini.h
@@ -7,23 +7,23 @@
 
 namespace Bu
 {
-        class SettingsDriverIni : public SettingsDriver
-        {
-        public:
-                SettingsDriverIni();
-                virtual ~SettingsDriverIni();
+    class SettingsDriverIni : public SettingsDriver
+    {
+    public:
+        SettingsDriverIni();
+        virtual ~SettingsDriverIni();
 
-        protected:
-                virtual void init( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct );
-                virtual void set( const Bu::UtfString &sKey, const Bu::UtfString  &sValue );            
-                virtual Bu::UtfString get( const Bu::UtfString &sKey, const Bu::UtfString &sValue );
+    protected:
+        virtual void init( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct );
+        virtual void set( const Bu::UtfString &sKey, const Bu::UtfString  &sValue );        
+        virtual Bu::UtfString get( const Bu::UtfString &sKey, const Bu::UtfString &sValue );
 
-        private:
-                Bu::String sPath;
-                typedef Bu::Hash<Bu::UtfString, Bu::UtfString> StrHash;
-                typedef Bu::Hash<Bu::UtfString, StrHash> GroupHash;
-                GroupHash hGroup;
-        };
+    private:
+        Bu::String sPath;
+        typedef Bu::Hash<Bu::UtfString, Bu::UtfString> StrHash;
+        typedef Bu::Hash<Bu::UtfString, StrHash> GroupHash;
+        GroupHash hGroup;
+    };
 };
 
 #endif
diff --git a/src/unstable/settingsdriverregistry.cpp b/src/unstable/settingsdriverregistry.cpp
index 89eda7b..983f48e 100644
--- a/src/unstable/settingsdriverregistry.cpp
+++ b/src/unstable/settingsdriverregistry.cpp
@@ -12,80 +12,80 @@ Bu::SettingsDriverRegistry::SettingsDriverRegistry()
 

 Bu::SettingsDriverRegistry::~SettingsDriverRegistry()

 {

-        RegCloseKey( *phKey );

+    RegCloseKey( *phKey );

 }

 

 void Bu::SettingsDriverRegistry::init( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct )

 {

-        Bu::UtfString us("Software\\");

-        us += sCompany;

-        us += "\\";

-        us += sProduct;

-        rphKey = new HKEY;

-        RegCreateKeyExA( HKEY_CURRENT_USER, us.get().getStr(), 0, NULL, 0, KEY_ALL_ACCESS, NULL, phKey, NULL );

+    Bu::UtfString us("Software\\");

+    us += sCompany;

+    us += "\\";

+    us += sProduct;

+    rphKey = new HKEY;

+    RegCreateKeyExA( HKEY_CURRENT_USER, us.get().getStr(), 0, NULL, 0, KEY_ALL_ACCESS, NULL, phKey, NULL );

 }

 

 void Bu::SettingsDriverRegistry::set( const Bu::UtfString &sKey, const Bu::UtfString  &sValue )

 {

-        Bu::StringList lPath = sKey.get().split('/');

-        Bu::StringList::iterator i = lPath.begin();

-        Bu::StringList::iterator in;

+    Bu::StringList lPath = sKey.get().split('/');

+    Bu::StringList::iterator i = lPath.begin();

+    Bu::StringList::iterator in;

 

-        Bu::String sPKey;

-        for(; i;)

-        {

-                in = i;

-                in++;

-                if( in )

-                {

-                        if( !sPKey.isEmpty() )

-                                sPKey += "\\";

-                        sPKey += *i;

-                }

-                i = in;

-        }

+    Bu::String sPKey;

+    for(; i;)

+    {

+        in = i;

+        in++;

+        if( in )

+        {

+            if( !sPKey.isEmpty() )

+                sPKey += "\\";

+            sPKey += *i;

+        }

+        i = in;

+    }

 

-        HKEY key;

-        RegCreateKeyExA( *phKey, sPKey.getStr(), 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL );

-        Bu::String sTmp = sValue.get();

-        RegSetValueExA( key, lPath.last().getStr(), 0, REG_SZ, (BYTE *)sTmp.getStr(), sTmp.getSize()+1 ); 

-        RegCloseKey( key );

+    HKEY key;

+    RegCreateKeyExA( *phKey, sPKey.getStr(), 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL );

+    Bu::String sTmp = sValue.get();

+    RegSetValueExA( key, lPath.last().getStr(), 0, REG_SZ, (BYTE *)sTmp.getStr(), sTmp.getSize()+1 ); 

+    RegCloseKey( key );

 }

 

 Bu::UtfString Bu::SettingsDriverRegistry::get( const Bu::UtfString &sKey, const Bu::UtfString &sValue )

 {

-        Bu::StringList lPath = sKey.get().split('/');

-        Bu::StringList::iterator i = lPath.begin();

-        Bu::StringList::iterator in;

+    Bu::StringList lPath = sKey.get().split('/');

+    Bu::StringList::iterator i = lPath.begin();

+    Bu::StringList::iterator in;

 

-        Bu::String sPKey;

-        for(; i;)

-        {

-                in = i;

-                in++;

-                if( in )

-                {

-                        if( !sPKey.isEmpty() )

-                                sPKey += "\\";

-                        sPKey += *i;

-                }

-                i = in;

-        }

+    Bu::String sPKey;

+    for(; i;)

+    {

+        in = i;

+        in++;

+        if( in )

+        {

+            if( !sPKey.isEmpty() )

+                sPKey += "\\";

+            sPKey += *i;

+        }

+        i = in;

+    }

 

-        HKEY key;

-        if( RegOpenKeyExA( *phKey, sPKey.getStr(), 0, KEY_ALL_ACCESS, &key ) 

-                != ERROR_SUCCESS )

-                return sValue;

-        char buf[4096];

-        DWORD iRet = 4096;

-        if( RegQueryValueEx( key, lPath.last().getStr(), NULL, NULL, (BYTE *)buf, &iRet ) != ERROR_SUCCESS )

-        {

-                RegCloseKey( key );

-                return sValue;

-        }

-        RegCloseKey( key );

-        

-        return Bu::UtfString( Bu::String( buf, iRet ) );

+    HKEY key;

+    if( RegOpenKeyExA( *phKey, sPKey.getStr(), 0, KEY_ALL_ACCESS, &key ) 

+        != ERROR_SUCCESS )

+        return sValue;

+    char buf[4096];

+    DWORD iRet = 4096;

+    if( RegQueryValueEx( key, lPath.last().getStr(), NULL, NULL, (BYTE *)buf, &iRet ) != ERROR_SUCCESS )

+    {

+        RegCloseKey( key );

+        return sValue;

+    }

+    RegCloseKey( key );

+    

+    return Bu::UtfString( Bu::String( buf, iRet ) );

 }

 

 #endif

diff --git a/src/unstable/settingsdriverregistry.h b/src/unstable/settingsdriverregistry.h
index 2d718d2..d1a2896 100644
--- a/src/unstable/settingsdriverregistry.h
+++ b/src/unstable/settingsdriverregistry.h
@@ -7,20 +7,20 @@
 

 namespace Bu

 {

-        class SettingsDriverRegistry : public SettingsDriver

-        {

-        public:

-                SettingsDriverRegistry();

-                virtual ~SettingsDriverRegistry();

+    class SettingsDriverRegistry : public SettingsDriver

+    {

+    public:

+        SettingsDriverRegistry();

+        virtual ~SettingsDriverRegistry();

 

-        protected:

-                virtual void init( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct );

-                virtual void set( const Bu::UtfString &sKey, const Bu::UtfString  &sValue );

-                virtual Bu::UtfString get( const Bu::UtfString &sKey, const Bu::UtfString &sValue );

+    protected:

+        virtual void init( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct );

+        virtual void set( const Bu::UtfString &sKey, const Bu::UtfString  &sValue );

+        virtual Bu::UtfString get( const Bu::UtfString &sKey, const Bu::UtfString &sValue );

 

-        private:

-                void *rphKey;

-        };

+    private:

+        void *rphKey;

+    };

 };

 

 #endif

diff --git a/src/unstable/settingsdrivertaf.cpp b/src/unstable/settingsdrivertaf.cpp
index 8cbcbc5..3fd61b3 100644
--- a/src/unstable/settingsdrivertaf.cpp
+++ b/src/unstable/settingsdrivertaf.cpp
@@ -6,97 +6,97 @@
 #include <stdlib.h>
 
 Bu::SettingsDriverTaf::SettingsDriverTaf() :
-        pRoot( NULL )
+    pRoot( NULL )
 {
 }
 
 Bu::SettingsDriverTaf::~SettingsDriverTaf()
 {
-        if( !pRoot )
-                return;
+    if( !pRoot )
+        return;
 
-        Bu::File fOut( sPath, Bu::File::WriteNew );
-        Bu::TafWriter tw( fOut );
-        tw.writeGroup( pRoot );
-        delete pRoot;
+    Bu::File fOut( sPath, Bu::File::WriteNew );
+    Bu::TafWriter tw( fOut );
+    tw.writeGroup( pRoot );
+    delete pRoot;
 }
 
 void Bu::SettingsDriverTaf::init( const Bu::UtfString &sCompany,
-                const Bu::UtfString &sProduct )
+        const Bu::UtfString &sProduct )
 {
-        Bu::UtfString us( getenv("HOME") );
-        us += "/.config/";
-        us += sCompany;
-        us += "/";
-        us += sProduct;
-        sPath = us.get();
-        try
-        {
-                Bu::File fIn( sPath, Bu::File::Read|Bu::File::Create );
-                Bu::TafReader tr( fIn );
-                pRoot = tr.readGroup();
-        }
-        catch(...)
-        {
-        }
-        if( !pRoot )
-        {
-                pRoot = new Bu::TafGroup( sProduct.get() );
-        }
+    Bu::UtfString us( getenv("HOME") );
+    us += "/.config/";
+    us += sCompany;
+    us += "/";
+    us += sProduct;
+    sPath = us.get();
+    try
+    {
+        Bu::File fIn( sPath, Bu::File::Read|Bu::File::Create );
+        Bu::TafReader tr( fIn );
+        pRoot = tr.readGroup();
+    }
+    catch(...)
+    {
+    }
+    if( !pRoot )
+    {
+        pRoot = new Bu::TafGroup( sProduct.get() );
+    }
 }
 
 void Bu::SettingsDriverTaf::set( const Bu::UtfString &sKey,
-                const Bu::UtfString &sValue )
+        const Bu::UtfString &sValue )
 {
-        Bu::StringList lPath = sKey.get().split('/');
-        Bu::StringList::iterator i = lPath.begin();
-        Bu::StringList::iterator in;
-        Bu::TafGroup *pGrp = pRoot;
-        for(; i;)
-        {
-                in = i;
-                in++;
-                if( in )
-                {
-                        if( pGrp->hasChild( *i ) )
-                                pGrp = (Bu::TafGroup *)pGrp->getChild( *i );
-                        else
-                                pGrp = pGrp->addGroup( *i );
-                }
-                else
-                {
-                        pGrp->addProperty( *i, sValue.get() );
-                }
-                i = in;
-        }
+    Bu::StringList lPath = sKey.get().split('/');
+    Bu::StringList::iterator i = lPath.begin();
+    Bu::StringList::iterator in;
+    Bu::TafGroup *pGrp = pRoot;
+    for(; i;)
+    {
+        in = i;
+        in++;
+        if( in )
+        {
+            if( pGrp->hasChild( *i ) )
+                pGrp = (Bu::TafGroup *)pGrp->getChild( *i );
+            else
+                pGrp = pGrp->addGroup( *i );
+        }
+        else
+        {
+            pGrp->addProperty( *i, sValue.get() );
+        }
+        i = in;
+    }
 }
 
 Bu::UtfString Bu::SettingsDriverTaf::get( const Bu::UtfString &sKey,
-                const Bu::UtfString &sValue )
+        const Bu::UtfString &sValue )
 {
-        Bu::StringList lPath = sKey.get().split('/');
-        Bu::StringList::iterator i = lPath.begin();
-        Bu::StringList::iterator in;
-        Bu::TafGroup *pGrp = pRoot;
-        for(; i;)
-        {
-                in = i;
-                in++;
-                if( in )
-                {
-                        if( pGrp->hasChild( *i ) )
-                                pGrp = (Bu::TafGroup *)pGrp->getChild( *i );
-                        else
-                                return sValue;
-                }
-                else
-                {
-                        if( pGrp->hasProperty( *i ) )
-                                return pGrp->getProperty( *i );
-                        else
-                                return sValue;
-                }
-                i = in;
-        }
+    Bu::StringList lPath = sKey.get().split('/');
+    Bu::StringList::iterator i = lPath.begin();
+    Bu::StringList::iterator in;
+    Bu::TafGroup *pGrp = pRoot;
+    for(; i;)
+    {
+        in = i;
+        in++;
+        if( in )
+        {
+            if( pGrp->hasChild( *i ) )
+                pGrp = (Bu::TafGroup *)pGrp->getChild( *i );
+            else
+                return sValue;
+        }
+        else
+        {
+            if( pGrp->hasProperty( *i ) )
+                return pGrp->getProperty( *i );
+            else
+                return sValue;
+        }
+        i = in;
+    }
 }
 
diff --git a/src/unstable/settingsdrivertaf.h b/src/unstable/settingsdrivertaf.h
index b5f8b07..28b5f5c 100644
--- a/src/unstable/settingsdrivertaf.h
+++ b/src/unstable/settingsdrivertaf.h
@@ -6,26 +6,26 @@
 
 namespace Bu
 {
-        class TafGroup;
+    class TafGroup;
 
-        /**
-         * The taf driver is flawed until I fix taf editing, I've been meaning to...
-         */
-        class SettingsDriverTaf : public SettingsDriver
-        {
-        public:
-                SettingsDriverTaf();
-                virtual ~SettingsDriverTaf();
+    /**
+     * The taf driver is flawed until I fix taf editing, I've been meaning to...
+     */
+    class SettingsDriverTaf : public SettingsDriver
+    {
+    public:
+        SettingsDriverTaf();
+        virtual ~SettingsDriverTaf();
 
-        protected:
-                virtual void init( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct );
-                virtual void set( const Bu::UtfString &sKey, const Bu::UtfString  &sValue );            
-                virtual Bu::UtfString get( const Bu::UtfString &sKey, const Bu::UtfString &sValue );
+    protected:
+        virtual void init( const Bu::UtfString &sCompany, const Bu::UtfString &sProduct );
+        virtual void set( const Bu::UtfString &sKey, const Bu::UtfString  &sValue );        
+        virtual Bu::UtfString get( const Bu::UtfString &sKey, const Bu::UtfString &sValue );
 
-        private:
-                Bu::String sPath;
-                class Bu::TafGroup *pRoot;
-        };
+    private:
+        Bu::String sPath;
+        class Bu::TafGroup *pRoot;
+    };
 };
 
 #endif
diff --git a/src/unstable/udpsocket.cpp b/src/unstable/udpsocket.cpp
index f554165..141c2cf 100644
--- a/src/unstable/udpsocket.cpp
+++ b/src/unstable/udpsocket.cpp
@@ -24,135 +24,135 @@ namespace Bu { subExceptionDef( UdpSocketException ) }
 #define saTarget ( *((struct sockaddr_in *)paTarget) )
 
 Bu::UdpSocket::UdpSocket( int iUdpSocket ) :
-        iUdpSocket( iUdpSocket ),
-        paTarget( NULL ),
-        bBound( false )
+    iUdpSocket( iUdpSocket ),
+    paTarget( NULL ),
+    bBound( false )
 {
 }
 
 Bu::UdpSocket::UdpSocket( const Bu::String &sAddr, int iPort, int iFlags ) :
-        iUdpSocket( 0 ),
-        paTarget( NULL ),
-        bBound( false )
-{
-        iUdpSocket = socket( PF_INET, SOCK_DGRAM, 0 );
-        if( iUdpSocket < 0 )
-        {
-                throw UdpSocketException("Couldn't open udp socket: %s",
-                        strerror( errno )
-                        );
-        }
-
-        if( (iFlags&Broadcast) )
-        {
-                int broadcast = 1;
-                if( (setsockopt( iUdpSocket, SOL_SOCKET, SO_BROADCAST,
-                        &broadcast, sizeof(broadcast) )) == -1)
-                {
-                        throw UdpSocketException("Couldn't set udp socket to broadcast: %s",
-                                strerror( errno )
-                                );
-                }
-        }
-        
-        paTarget = new struct sockaddr_in;
-        saTarget.sin_family = AF_INET;
-        saTarget.sin_port = htons( iPort );
-        saTarget.sin_addr.s_addr = inet_addr( sAddr.getStr() ); // INADDR_ANY;
-        memset( saTarget.sin_zero, '\0', sizeof(saTarget.sin_zero) );
-        
-        if( (iFlags&Read) )
-        {
-                if( bind( iUdpSocket, (struct sockaddr*)paTarget, sizeof(struct sockaddr_in) )
-                                == -1 )
-                {
-                        throw UdpSocketException("Couldn't bind port to udp socket: %s",
-                                strerror( errno )
-                                );
-                }
-                bBound = true;
-        }
+    iUdpSocket( 0 ),
+    paTarget( NULL ),
+    bBound( false )
+{
+    iUdpSocket = socket( PF_INET, SOCK_DGRAM, 0 );
+    if( iUdpSocket < 0 )
+    {
+        throw UdpSocketException("Couldn't open udp socket: %s",
+            strerror( errno )
+            );
+    }
+
+    if( (iFlags&Broadcast) )
+    {
+        int broadcast = 1;
+        if( (setsockopt( iUdpSocket, SOL_SOCKET, SO_BROADCAST,
+            &broadcast, sizeof(broadcast) )) == -1)
+        {
+            throw UdpSocketException("Couldn't set udp socket to broadcast: %s",
+                strerror( errno )
+                );
+        }
+    }
+    
+    paTarget = new struct sockaddr_in;
+    saTarget.sin_family = AF_INET;
+    saTarget.sin_port = htons( iPort );
+    saTarget.sin_addr.s_addr = inet_addr( sAddr.getStr() ); // INADDR_ANY;
+    memset( saTarget.sin_zero, '\0', sizeof(saTarget.sin_zero) );
+    
+    if( (iFlags&Read) )
+    {
+        if( bind( iUdpSocket, (struct sockaddr*)paTarget, sizeof(struct sockaddr_in) )
+                == -1 )
+        {
+            throw UdpSocketException("Couldn't bind port to udp socket: %s",
+                strerror( errno )
+                );
+        }
+        bBound = true;
+    }
 }
 
 Bu::UdpSocket::~UdpSocket()
 {
-        close();
-        delete (struct sockaddr_in *)paTarget;
-        paTarget = NULL;
+    close();
+    delete (struct sockaddr_in *)paTarget;
+    paTarget = NULL;
 }
 
 Bu::String Bu::UdpSocket::addrToStr( const addr &a )
 {
-        return Bu::String("%1.%2.%3.%4").
-                arg( (a&0xff) ).
-                arg( (a&0xff00)>>8 ).
-                arg( (a&0xff0000)>>16 ).
-                arg( (a&0xff000000)>>24 );
+    return Bu::String("%1.%2.%3.%4").
+        arg( (a&0xff) ).
+        arg( (a&0xff00)>>8 ).
+        arg( (a&0xff0000)>>16 ).
+        arg( (a&0xff000000)>>24 );
 }
 
 void Bu::UdpSocket::close()
 {
-        ::close( iUdpSocket );
+    ::close( iUdpSocket );
 }
 
 Bu::size Bu::UdpSocket::read( void *pBuf, Bu::size nBytes )
 {
-        return recv( iUdpSocket, pBuf, nBytes, 0 );
+    return recv( iUdpSocket, pBuf, nBytes, 0 );
 }
 
 Bu::size Bu::UdpSocket::read( void *pBuf, Bu::size nBytes,
-                Bu::UdpSocket::addr &aHost, int &iPort )
+        Bu::UdpSocket::addr &aHost, int &iPort )
 {
-        sockaddr_in name;
-        socklen_t size = sizeof(name);
-        Bu::size ret = recvfrom( iUdpSocket, pBuf, nBytes, 0,
-                        (struct sockaddr *)&name, &size );
-        aHost = name.sin_addr.s_addr;
-        iPort = ntohs(name.sin_port);
-        return ret;
+    sockaddr_in name;
+    socklen_t size = sizeof(name);
+    Bu::size ret = recvfrom( iUdpSocket, pBuf, nBytes, 0,
+            (struct sockaddr *)&name, &size );
+    aHost = name.sin_addr.s_addr;
+    iPort = ntohs(name.sin_port);
+    return ret;
 }
 
 Bu::size Bu::UdpSocket::write( const void *pBuf, Bu::size nBytes )
 {
-        if( bBound )
-        {
-                return sendto( iUdpSocket, pBuf, nBytes, 0, NULL, 0 );
-        }
-        else
-        {
-                return sendto( iUdpSocket, pBuf, nBytes, 0,
-                        (struct sockaddr*)paTarget, sizeof(struct sockaddr_in) );
-        }
+    if( bBound )
+    {
+        return sendto( iUdpSocket, pBuf, nBytes, 0, NULL, 0 );
+    }
+    else
+    {
+        return sendto( iUdpSocket, pBuf, nBytes, 0,
+            (struct sockaddr*)paTarget, sizeof(struct sockaddr_in) );
+    }
 }
 
 Bu::size Bu::UdpSocket::tell()
 {
-        throw Bu::UnsupportedException();
+    throw Bu::UnsupportedException();
 }
 
 void Bu::UdpSocket::seek( Bu::size )
 {
-        throw Bu::UnsupportedException();
+    throw Bu::UnsupportedException();
 }
 
 void Bu::UdpSocket::setPos( Bu::size )
 {
-        throw Bu::UnsupportedException();
+    throw Bu::UnsupportedException();
 }
 
 void Bu::UdpSocket::setPosEnd( Bu::size )
 {
-        throw Bu::UnsupportedException();
+    throw Bu::UnsupportedException();
 }
 
 bool Bu::UdpSocket::isEos()
 {
-        return false;
+    return false;
 }
 
 bool Bu::UdpSocket::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::UdpSocket::flush()
@@ -161,79 +161,79 @@ void Bu::UdpSocket::flush()
 
 bool Bu::UdpSocket::canRead()
 {
-        return bBound;
+    return bBound;
 }
 
 bool Bu::UdpSocket::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::UdpSocket::isReadable()
 {
-        return bBound;
+    return bBound;
 }
 
 bool Bu::UdpSocket::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::UdpSocket::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::UdpSocket::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::UdpSocket::setBlocking( bool bBlocking )
 {
 #ifndef WIN32
-        if( bBlocking )
-        {
-                fcntl( iUdpSocket, F_SETFL, fcntl( iUdpSocket, F_GETFL, 0 ) & (~O_NONBLOCK) );
-        }
-        else
-        {
-                fcntl( iUdpSocket, F_SETFL, fcntl( iUdpSocket, F_GETFL, 0 ) | O_NONBLOCK );
-        }
+    if( bBlocking )
+    {
+        fcntl( iUdpSocket, F_SETFL, fcntl( iUdpSocket, F_GETFL, 0 ) & (~O_NONBLOCK) );
+    }
+    else
+    {
+        fcntl( iUdpSocket, F_SETFL, fcntl( iUdpSocket, F_GETFL, 0 ) | O_NONBLOCK );
+    }
 #else
-        u_long iMode;
-        if( bBlocking )
-                iMode = 0;
-        else
-                iMode = 1;
-        //-------------------------
-        // Set the socket I/O mode: In this case FIONBIO
-        // enables or disables the blocking mode for the 
-        // socket based on the numerical value of iMode.
-        // If iMode = 0, blocking is enabled; 
-        // If iMode != 0, non-blocking mode is enabled.
-        bu_ioctlsocket(iUdpSocket, FIONBIO, &iMode);
-#endif  
+    u_long iMode;
+    if( bBlocking )
+        iMode = 0;
+    else
+        iMode = 1;
+    //-------------------------
+    // Set the socket I/O mode: In this case FIONBIO
+    // enables or disables the blocking mode for the 
+    // socket based on the numerical value of iMode.
+    // If iMode = 0, blocking is enabled; 
+    // If iMode != 0, non-blocking mode is enabled.
+    bu_ioctlsocket(iUdpSocket, FIONBIO, &iMode);
+#endif  
 }
 
 void Bu::UdpSocket::setSize( Bu::size )
 {
-        throw Bu::UnsupportedException();
+    throw Bu::UnsupportedException();
 }
 
 Bu::size Bu::UdpSocket::getSize() const
 {
-        throw Bu::UnsupportedException();
+    throw Bu::UnsupportedException();
 }
 
 Bu::size Bu::UdpSocket::getBlockSize() const
 {
-        return 1500;
+    return 1500;
 }
 
 Bu::String Bu::UdpSocket::getLocation() const
 {
-        throw Bu::UnsupportedException();
+    throw Bu::UnsupportedException();
 }
 
 #endif
diff --git a/src/unstable/udpsocket.h b/src/unstable/udpsocket.h
index 8f8630a..569a6fb 100644
--- a/src/unstable/udpsocket.h
+++ b/src/unstable/udpsocket.h
@@ -15,68 +15,68 @@
 
 namespace Bu
 {
-        subExceptionDecl( UdpSocketException );
+    subExceptionDecl( UdpSocketException );
 
-        class UdpSocket : public Stream
-        {
-        public:
-                UdpSocket( int iUdpSocket );
-                UdpSocket( const Bu::String &sAddr, int iPort, int iFlags );
-                virtual ~UdpSocket();
+    class UdpSocket : public Stream
+    {
+    public:
+        UdpSocket( int iUdpSocket );
+        UdpSocket( const Bu::String &sAddr, int iPort, int iFlags );
+        virtual ~UdpSocket();
 
-                typedef uint32_t addr;
+        typedef uint32_t addr;
 
-                static Bu::String addrToStr( const addr &a );
+        static Bu::String addrToStr( const addr &a );
 
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size read( void *pBuf, Bu::size nBytes,
-                                addr &sHost, int &iPort );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size read( void *pBuf, Bu::size nBytes,
+                addr &sHost, int &iPort );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
 
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
 
-                virtual void flush();
+        virtual void flush();
 
-                virtual bool canRead();
-                virtual bool canWrite();
+        virtual bool canRead();
+        virtual bool canWrite();
 
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
 
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
 
-                virtual void setSize( Bu::size iSize );
+        virtual void setSize( Bu::size iSize );
 
-                enum {
-                        // Flags
-                        Read            = 0x01, ///< Open udp socket for reading
-                        Write           = 0x02, ///< Open udp socket for writing
-                        ReadWrite       = 0x03, ///< Open for both read and write
-                        Broadcast   = 0x04, ///< Open for broadcast
-                };
+        enum {
+            // Flags
+            Read        = 0x01, ///< Open udp socket for reading
+            Write       = 0x02, ///< Open udp socket for writing
+            ReadWrite   = 0x03, ///< Open for both read and write
+            Broadcast   = 0x04, ///< Open for broadcast
+        };
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-        private:
+    private:
 #ifdef WIN32
-                unsigned int iUdpSocket;
+        unsigned int iUdpSocket;
 #else
-                int iUdpSocket;
+        int iUdpSocket;
 #endif
-                void *paTarget;
-                bool bBound;
-        };
+        void *paTarget;
+        bool bBound;
+    };
 };
 
 #endif
diff --git a/src/unstable/url.cpp b/src/unstable/url.cpp
index 3c9da4b..75131af 100644
--- a/src/unstable/url.cpp
+++ b/src/unstable/url.cpp
@@ -13,8 +13,8 @@
 #include <stdlib.h>
 
 char Bu::Url::hexcode[] = {
-        '0', '1', '2', '3', '4', '5', '6', '7',
-        '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+    '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
 };
 
 Bu::Url::Url()
@@ -23,7 +23,7 @@ Bu::Url::Url()
 
 Bu::Url::Url( const Bu::String &sUrl )
 {
-        parseUrl( sUrl );
+    parseUrl( sUrl );
 }
 
 Bu::Url::~Url()
@@ -32,254 +32,254 @@ Bu::Url::~Url()
 
 void Bu::Url::parseUrl( const Bu::String &sUrl )
 {
-        clear();
+    clear();
 
-        Bu::String::const_iterator i = sUrl.begin();
-        parseProtocol( i );
-        parseUserPass( i );
-        parseHost( i );
-        parsePath( i );
+    Bu::String::const_iterator i = sUrl.begin();
+    parseProtocol( i );
+    parseUserPass( i );
+    parseHost( i );
+    parsePath( i );
 }
 
 Bu::String Bu::Url::decode( const Bu::String &sStr )
 {
-        Bu::String sRet;
-        char buf[3] = {0, 0, 0};
-        for( Bu::String::const_iterator i = sStr.begin(); i; i++ )
-        {
-                if( *i == '+' )
-                {
-                        sRet += ' ';
-                }
-                else if( *i == '%' )
-                {
-                        i++;
-                        buf[0] = *i;
-                        i++;
-                        buf[1] = *i;
-                        sRet += (char)((unsigned char)strtol( buf, NULL, 16 ));
-                }
-                else
-                {
-                        sRet += *i;
-                }
-        }
-        return sRet;
+    Bu::String sRet;
+    char buf[3] = {0, 0, 0};
+    for( Bu::String::const_iterator i = sStr.begin(); i; i++ )
+    {
+        if( *i == '+' )
+        {
+            sRet += ' ';
+        }
+        else if( *i == '%' )
+        {
+            i++;
+            buf[0] = *i;
+            i++;
+            buf[1] = *i;
+            sRet += (char)((unsigned char)strtol( buf, NULL, 16 ));
+        }
+        else
+        {
+            sRet += *i;
+        }
+    }
+    return sRet;
 }
 
 Bu::String Bu::Url::encode( const Bu::String &sStr )
 {
-        Bu::String sRet;
-        for( Bu::String::const_iterator i = sStr.begin(); i; i++ )
-        {
-                if( *i == ' ' )
-                {
-                        sRet += '+';
-                }
-                else if(
-                        (*i >= 'A' && *i <= 'Z') ||
-                        (*i >= 'a' && *i <= 'z') ||
-                        (*i >= '0' && *i <= '9') ||
-                        (*i == '-' || *i == '_' || *i == '.' || *i == '~')
-                        )
-                {
-                        sRet += *i;
-                }
-                else
-                {
-                        unsigned char b = *i;
-                        sRet += '%';
-                        sRet += hexcode[(b>>4)&0xF];
-                        sRet += hexcode[b&0xF];
-                }
-        }
-        return sRet;
+    Bu::String sRet;
+    for( Bu::String::const_iterator i = sStr.begin(); i; i++ )
+    {
+        if( *i == ' ' )
+        {
+            sRet += '+';
+        }
+        else if(
+            (*i >= 'A' && *i <= 'Z') ||
+            (*i >= 'a' && *i <= 'z') ||
+            (*i >= '0' && *i <= '9') ||
+            (*i == '-' || *i == '_' || *i == '.' || *i == '~')
+            )
+        {
+            sRet += *i;
+        }
+        else
+        {
+            unsigned char b = *i;
+            sRet += '%';
+            sRet += hexcode[(b>>4)&0xF];
+            sRet += hexcode[b&0xF];
+        }
+    }
+    return sRet;
 }
 
 void Bu::Url::parseProtocol( Bu::String::const_iterator &i )
 {
-        Bu::String::const_iterator s = i.find("://", 3);
-        if( !s )
-                throw Bu::ExceptionBase("No :// in url");
-        Bu::String sTmp( i, s );
-        setProtocol( sTmp );
-        i = s + 3;
+    Bu::String::const_iterator s = i.find("://", 3);
+    if( !s )
+        throw Bu::ExceptionBase("No :// in url");
+    Bu::String sTmp( i, s );
+    setProtocol( sTmp );
+    i = s + 3;
 }
 
 void Bu::Url::setProtocol( const Bu::String &sNewProto, bool bAutoSetPort )
 {
-        sProtocol = sNewProto;
+    sProtocol = sNewProto;
 #ifndef WIN32
-        if( bAutoSetPort )
-        {
-                struct servent *se = getservbyname( sProtocol.getStr(), "tcp" );
-                if( se )
-                {
-                        iPort = ntohs( se->s_port );
-                }
-        }
+    if( bAutoSetPort )
+    {
+        struct servent *se = getservbyname( sProtocol.getStr(), "tcp" );
+        if( se )
+        {
+            iPort = ntohs( se->s_port );
+        }
+    }
 #endif
 }
 
 void Bu::Url::parseUserPass( Bu::String::const_iterator &i )
 {
-        Bu::String::const_iterator s = i.find('@');
-        if( !s )
-                return;
+    Bu::String::const_iterator s = i.find('@');
+    if( !s )
+        return;
 
-        Bu::String::const_iterator p = i.find(':');
-        if( p )
-        {
-                sUser.set( i, p );
-                sPass.set( p+1, s );
-        }
-        else
-        {
-                sUser.set( i, s );
-        }
+    Bu::String::const_iterator p = i.find(':');
+    if( p )
+    {
+        sUser.set( i, p );
+        sPass.set( p+1, s );
+    }
+    else
+    {
+        sUser.set( i, s );
+    }
 
-        i = s + 1;
+    i = s + 1;
 }
 
 void Bu::Url::parseHost( Bu::String::const_iterator &i )
 {
-        Bu::String::const_iterator s = i;
-        for( ; s && *s != '/'; s++ )
-        {
-                if( *s == ':' )
-                {
-                        sHost.set( i, s );
-                        i = s + 1;
-                        s = i.find('/');
-                        Bu::String sPort( i, s );
-                        iPort = strtol( sPort.getStr(), NULL, 10 );
-                        i = s;
-                        return;
-                }
-        }
-        sHost.set( i, s );
-        i = s;
+    Bu::String::const_iterator s = i;
+    for( ; s && *s != '/'; s++ )
+    {
+        if( *s == ':' )
+        {
+            sHost.set( i, s );
+            i = s + 1;
+            s = i.find('/');
+            Bu::String sPort( i, s );
+            iPort = strtol( sPort.getStr(), NULL, 10 );
+            i = s;
+            return;
+        }
+    }
+    sHost.set( i, s );
+    i = s;
 }
 
 void Bu::Url::parsePath( const Bu::String &sPath )
 {
-        Bu::String::const_iterator i = sPath.begin();
-        parsePath( i );
+    Bu::String::const_iterator i = sPath.begin();
+    parsePath( i );
 }
 
 void Bu::Url::parsePath( Bu::String::const_iterator &i )
 {
-        if( i )
-        {
-                Bu::String::const_iterator s = i.find('?');
-                sPath.set( i, s );
-                i = s + 1;
-                if( s )
-                {
-                        parseParams( i );
-                }
-        }
-        else
-        {
-                sPath = "/";
-        }
+    if( i )
+    {
+        Bu::String::const_iterator s = i.find('?');
+        sPath.set( i, s );
+        i = s + 1;
+        if( s )
+        {
+            parseParams( i );
+        }
+    }
+    else
+    {
+        sPath = "/";
+    }
 }
 
 void Bu::Url::parseParams( const Bu::String &sQuery )
 {
-        Bu::String::const_iterator i = sQuery.begin();
-        parseParams( i );
+    Bu::String::const_iterator i = sQuery.begin();
+    parseParams( i );
 }
 
 void Bu::Url::parseParams( Bu::String::const_iterator &i )
 {
-        bool bName = true;
-        Bu::String sName, sValue;
-        for( Bu::String::const_iterator s = i; s; s++ )
-        {
-                if( bName )
-                {
-                        if( *s == '&' )
-                        {
-                                sName.set( i, s );
-                                sValue.clear();
-                                i = s + 1;
-                                addParam( decode( sName ), decode( sValue ) );
-                        }
-                        else if( *s == '=' )
-                        {
-                                sName.set( i, s );
-                                i = s + 1;
-                                bName = false;
-                        }
-                }
-                else
-                {
-                        if( *s == '&' )
-                        {
-                                sValue.set( i, s );
-                                i = s + 1;
-                                bName = true;
-                                addParam( decode( sName ), decode( sValue ) );
-                        }
-                }
-        }
-        if( i )
-        {
-                if( bName )
-                {
-                        sName.set( i );
-                        sValue.clear();
-                }
-                else
-                {
-                        sValue.set( i );
-                }
-                addParam( decode( sName ), decode( sValue ) );
-        }
+    bool bName = true;
+    Bu::String sName, sValue;
+    for( Bu::String::const_iterator s = i; s; s++ )
+    {
+        if( bName )
+        {
+            if( *s == '&' )
+            {
+                sName.set( i, s );
+                sValue.clear();
+                i = s + 1;
+                addParam( decode( sName ), decode( sValue ) );
+            }
+            else if( *s == '=' )
+            {
+                sName.set( i, s );
+                i = s + 1;
+                bName = false;
+            }
+        }
+        else
+        {
+            if( *s == '&' )
+            {
+                sValue.set( i, s );
+                i = s + 1;
+                bName = true;
+                addParam( decode( sName ), decode( sValue ) );
+            }
+        }
+    }
+    if( i )
+    {
+        if( bName )
+        {
+            sName.set( i );
+            sValue.clear();
+        }
+        else
+        {
+            sValue.set( i );
+        }
+        addParam( decode( sName ), decode( sValue ) );
+    }
 }
 
 void Bu::Url::addParam( const Bu::String &n, const Bu::String &v )
 {
-        lParam.append( Param( n, v ) );
+    lParam.append( Param( n, v ) );
 }
 
 void Bu::Url::clear()
 {
-        sProtocol.clear();
-        sUser.clear();
-        sPass.clear();
-        sHost.clear();
-        sPath.clear();
-        iPort.clear();
+    sProtocol.clear();
+    sUser.clear();
+    sPass.clear();
+    sHost.clear();
+    sPath.clear();
+    iPort.clear();
 }
 
 Bu::String Bu::Url::getFullPath() const
 {
-        Bu::String sBuf = sPath;
-        if( !lParam.isEmpty() )
-        {
-                for( ParamList::const_iterator i = lParam.begin(); i; i++ )
-                {
-                        if( i == lParam.begin() )
-                                sBuf += "?";
-                        else
-                                sBuf += "&";
+    Bu::String sBuf = sPath;
+    if( !lParam.isEmpty() )
+    {
+        for( ParamList::const_iterator i = lParam.begin(); i; i++ )
+        {
+            if( i == lParam.begin() )
+                sBuf += "?";
+            else
+                sBuf += "&";
 
-                        sBuf += encode( (*i).sName );
-                        if( !(*i).sValue.isEmpty() )
-                        {
-                                sBuf += "=" + encode( (*i).sValue );
-                        }
-                }
-        }
+            sBuf += encode( (*i).sName );
+            if( !(*i).sValue.isEmpty() )
+            {
+                sBuf += "=" + encode( (*i).sValue );
+            }
+        }
+    }
 
-        return sBuf;
+    return sBuf;
 }
 
 Bu::String Bu::Url::getUrl() const
 {
-        Bu::String sBuf = sProtocol + "://" + sHost + getFullPath();
-        return sBuf;
+    Bu::String sBuf = sProtocol + "://" + sHost + getFullPath();
+    return sBuf;
 }
 
diff --git a/src/unstable/url.h b/src/unstable/url.h
index 34a335d..3edf94b 100644
--- a/src/unstable/url.h
+++ b/src/unstable/url.h
@@ -13,73 +13,73 @@
 
 namespace Bu
 {
-        class Url
-        {
-        public:
-                typedef struct Param
-                {
-                        Param() { }
-                        Param( const Param &r ) : sName( r.sName ), sValue( r.sValue ) { }
-                        Param( const Bu::String &n, const Bu::String &v ) :
-                                sName( n ), sValue( v ) { }
-                        Bu::String sName;
-                        Bu::String sValue;
-                } Param;
-                typedef Bu::List<Param> ParamList;
+    class Url
+    {
+    public:
+        typedef struct Param
+        {
+            Param() { }
+            Param( const Param &r ) : sName( r.sName ), sValue( r.sValue ) { }
+            Param( const Bu::String &n, const Bu::String &v ) :
+                sName( n ), sValue( v ) { }
+            Bu::String sName;
+            Bu::String sValue;
+        } Param;
+        typedef Bu::List<Param> ParamList;
 
-        public:
-                Url();
-                Url( const Bu::String &sUrl );
-                virtual ~Url();
+    public:
+        Url();
+        Url( const Bu::String &sUrl );
+        virtual ~Url();
 
-                void parseUrl( const Bu::String &sUrl );
-                void parseParams( const Bu::String &sQuery );
-                void parseParams( Bu::String::const_iterator &i );
-                void parsePath( const Bu::String &sPath );
-                void parsePath( Bu::String::const_iterator &i );
-                void clear();
+        void parseUrl( const Bu::String &sUrl );
+        void parseParams( const Bu::String &sQuery );
+        void parseParams( Bu::String::const_iterator &i );
+        void parsePath( const Bu::String &sPath );
+        void parsePath( Bu::String::const_iterator &i );
+        void clear();
 
-                Bu::String getUrl() const;
-                Bu::String getFullPath() const;
+        Bu::String getUrl() const;
+        Bu::String getFullPath() const;
 
-                const Bu::String &getProtocol() const { return sProtocol; }
-                const Bu::String &getUser() const { return sUser; }
-                const Bu::String &getPass() const { return sPass; }
-                const Bu::String &getHost() const { return sHost; }
-                const Bu::String &getPath() const { return sPath; }
-                int getPort() const { return iPort; }
-                ParamList::const_iterator getParamBegin() const
-                        { return lParam.begin(); }
+        const Bu::String &getProtocol() const { return sProtocol; }
+        const Bu::String &getUser() const { return sUser; }
+        const Bu::String &getPass() const { return sPass; }
+        const Bu::String &getHost() const { return sHost; }
+        const Bu::String &getPath() const { return sPath; }
+        int getPort() const { return iPort; }
+        ParamList::const_iterator getParamBegin() const
+            { return lParam.begin(); }
 
-                void setProtocol( const Bu::String &sNewHost, bool bAutoSetPort=true );
-                void setUser( const Bu::String &s ) { sUser = s; }
-                void setPass( const Bu::String &s ) { sPass = s; }
-                void setHost( const Bu::String &s ) { sHost = s; }
-                void setPath( const Bu::String &s ) { sPath = s; }
-                void setPort( int i ) { iPort = i; }
-                void addParam( const Bu::String &n, const Bu::String &v );
+        void setProtocol( const Bu::String &sNewHost, bool bAutoSetPort=true );
+        void setUser( const Bu::String &s ) { sUser = s; }
+        void setPass( const Bu::String &s ) { sPass = s; }
+        void setHost( const Bu::String &s ) { sHost = s; }
+        void setPath( const Bu::String &s ) { sPath = s; }
+        void setPort( int i ) { iPort = i; }
+        void addParam( const Bu::String &n, const Bu::String &v );
 
-                bool hasPort() const { return iPort.has(); }
+        bool hasPort() const { return iPort.has(); }
 
-                static Bu::String decode( const Bu::String &sStr );
-                static Bu::String encode( const Bu::String &sStr );
+        static Bu::String decode( const Bu::String &sStr );
+        static Bu::String encode( const Bu::String &sStr );
 
-        private: // Parsing code
-                void parseProtocol( Bu::String::const_iterator &i );
-                void parseUserPass( Bu::String::const_iterator &i );
-                void parseHost( Bu::String::const_iterator &i );
+    private: // Parsing code
+        void parseProtocol( Bu::String::const_iterator &i );
+        void parseUserPass( Bu::String::const_iterator &i );
+        void parseHost( Bu::String::const_iterator &i );
 
-        private:
-                Bu::String sProtocol;
-                Bu::String sUser;
-                Bu::String sPass;
-                Bu::String sHost;
-                Bu::String sPath;
-                Bu::Atom<int> iPort;
-                ParamList lParam;
+    private:
+        Bu::String sProtocol;
+        Bu::String sUser;
+        Bu::String sPass;
+        Bu::String sHost;
+        Bu::String sPath;
+        Bu::Atom<int> iPort;
+        ParamList lParam;
 
-                static char hexcode[16];
-        };
+        static char hexcode[16];
+    };
 };
 
 #endif
diff --git a/src/unstable/utfstring.cpp b/src/unstable/utfstring.cpp
index 9fe2d02..421d5fb 100644
--- a/src/unstable/utfstring.cpp
+++ b/src/unstable/utfstring.cpp
@@ -20,12 +20,12 @@ Bu::UtfString::UtfString()
 
 Bu::UtfString::UtfString( const Bu::String &sInput, Encoding eEnc )
 {
-        set( sInput, eEnc );
+    set( sInput, eEnc );
 }
 
 Bu::UtfString::UtfString( const char *sInput, Encoding eEnc )
 {
-        set( sInput, eEnc );
+    set( sInput, eEnc );
 }
 
 Bu::UtfString::~UtfString()
@@ -34,340 +34,340 @@ Bu::UtfString::~UtfString()
 
 Bu::UtfString::iterator Bu::UtfString::begin()
 {
-        return Bu::UtfString::iterator( this, 0 );
+    return Bu::UtfString::iterator( this, 0 );
 }
 
 Bu::UtfString::const_iterator Bu::UtfString::begin() const
 {
-        return Bu::UtfString::const_iterator( this, 0 );
+    return Bu::UtfString::const_iterator( this, 0 );
 }
 
 void Bu::UtfString::set( const Bu::String &sInput, Encoding eEnc )
 {
-        switch( eEnc )
-        {
-                case Utf8:
-                        setUtf8( sInput );
-                        break;
+    switch( eEnc )
+    {
+        case Utf8:
+            setUtf8( sInput );
+            break;
 
-                case Utf16:
-                        setUtf16( sInput );
-                        break;
+        case Utf16:
+            setUtf16( sInput );
+            break;
 
-                case Utf16be:
-                        setUtf16be( sInput );
-                        break;
+        case Utf16be:
+            setUtf16be( sInput );
+            break;
 
-                case Utf16le:
-                        setUtf16le( sInput );
-                        break;
+        case Utf16le:
+            setUtf16le( sInput );
+            break;
 
-                case Utf32:
-                        setUtf32( sInput );
-                        break;
+        case Utf32:
+            setUtf32( sInput );
+            break;
 
-                case Utf32be:
-                        setUtf32be( sInput );
-                        break;
+        case Utf32be:
+            setUtf32be( sInput );
+            break;
 
-                case Utf32le:
-                        setUtf32le( sInput );
-                        break;
+        case Utf32le:
+            setUtf32le( sInput );
+            break;
 
-                case Ucs2:
-                        throw Bu::ExceptionBase("Ucs2 not supported yet.");
-                        break;
+        case Ucs2:
+            throw Bu::ExceptionBase("Ucs2 not supported yet.");
+            break;
 
-                case Ucs4:
-                        throw Bu::ExceptionBase("Ucs4 not supported yet.");
-                        break;
+        case Ucs4:
+            throw Bu::ExceptionBase("Ucs4 not supported yet.");
+            break;
 
-                case GuessEncoding:
-                        throw Bu::ExceptionBase("Guessing mode not supported yet.");
-                        break;
-        }
+        case GuessEncoding:
+            throw Bu::ExceptionBase("Guessing mode not supported yet.");
+            break;
+    }
 }
 
 void Bu::UtfString::append( UtfChar ch )
 {
-        if( ch >= 0x10000 )
-        {
-                ch -= 0x10000;
-                append16( ((ch>>10)&0x3FF)| 0xD800u );
-                append16( (ch&0x3FF)| 0xDC00u );
-        }
-        else
-        {
-                append16( (uint16_t)(ch) );
-        }
+    if( ch >= 0x10000 )
+    {
+        ch -= 0x10000;
+        append16( ((ch>>10)&0x3FF)| 0xD800u );
+        append16( (ch&0x3FF)| 0xDC00u );
+    }
+    else
+    {
+        append16( (uint16_t)(ch) );
+    }
 }
 
 void Bu::UtfString::append( const UtfString &rSrc )
 {
-        aData.append( rSrc.aData );
-        iRawLen += rSrc.iRawLen;
-        iCharLen += rSrc.iCharLen;
+    aData.append( rSrc.aData );
+    iRawLen += rSrc.iRawLen;
+    iCharLen += rSrc.iCharLen;
 }
 
 void Bu::UtfString::setUtf8( const Bu::String &sInput )
 {
-        static uint8_t lmask[8] = {
-                0x00,
-                0x01,
-                0x03,
-                0x07,
-                0x0f,
-                0x1f,
-                0x3f,
-                0x7f
-        };
-        for( Bu::String::const_iterator i = sInput.begin(); i; i++ )
-        {
-                if( ((int)(uint8_t)*i)&0x80 )
-                {
-                        int iBytes = 1;
-                        for(; (((uint8_t)(*i))<<iBytes)&0x80; iBytes++ ) { }
-                        Bu::UtfChar uPt = ((*i) & lmask[7-iBytes])<<(6*(iBytes-1));
-                        for( iBytes--; iBytes >= 1; iBytes-- )
-                        {
-                                i++;
-                                uPt |= ((*i)&lmask[6])<<(6*(iBytes-1));
-                        }
-                        append( uPt );
-                }
-                else
-                {
-                        append( (Bu::UtfChar)(*i) );
-                }
-        }
+    static uint8_t lmask[8] = {
+        0x00,
+        0x01,
+        0x03,
+        0x07,
+        0x0f,
+        0x1f,
+        0x3f,
+        0x7f
+    };
+    for( Bu::String::const_iterator i = sInput.begin(); i; i++ )
+    {
+        if( ((int)(uint8_t)*i)&0x80 )
+        {
+            int iBytes = 1;
+            for(; (((uint8_t)(*i))<<iBytes)&0x80; iBytes++ ) { }
+            Bu::UtfChar uPt = ((*i) & lmask[7-iBytes])<<(6*(iBytes-1));
+            for( iBytes--; iBytes >= 1; iBytes-- )
+            {
+                i++;
+                uPt |= ((*i)&lmask[6])<<(6*(iBytes-1));
+            }
+            append( uPt );
+        }
+        else
+        {
+            append( (Bu::UtfChar)(*i) );
+        }
+    }
 }
 
 void Bu::UtfString::setUtf16( const Bu::String &sInput )
 {
-//      Bu::String::const_iterator i = sInput.begin();
-        if( (uint8_t)*sInput.begin() == 0xFF &&
-                (uint8_t)*(sInput.begin()+1) == 0xFE )
-        {
-                setUtf16le( sInput );
-                return;
-        }
-        setUtf16be( sInput );
+//  Bu::String::const_iterator i = sInput.begin();
+    if( (uint8_t)*sInput.begin() == 0xFF &&
+        (uint8_t)*(sInput.begin()+1) == 0xFE )
+    {
+        setUtf16le( sInput );
+        return;
+    }
+    setUtf16be( sInput );
 }
 
 void Bu::UtfString::setUtf16be( const Bu::String &sInput )
 {
-        Bu::String::const_iterator i = sInput.begin();
-        if( (uint8_t)*sInput.begin() == 0xFE &&
-                (uint8_t)*(sInput.begin()+1) == 0xFF )
-
-        {
-                i += 2;
-                sio << "Verified big endian." << sio.nl;
-        }
-        else
-        {
-                sio << "Assuming big endian." << sio.nl;
-        }
-        uint16_t hi, lo;
-        for( ; i; i++ )
-        {
-                hi = (((uint8_t)*i)<<8) | ((uint8_t)*(++i));
-                append16( hi );
-                if( (hi&0xD800u) == 0xD800u )
-                {
-                        lo = (((uint8_t)*(++i))<<8) | ((uint8_t)*(++i));
-                        append16( lo );
-                }
-        }
+    Bu::String::const_iterator i = sInput.begin();
+    if( (uint8_t)*sInput.begin() == 0xFE &&
+        (uint8_t)*(sInput.begin()+1) == 0xFF )
+
+    {
+        i += 2;
+        sio << "Verified big endian." << sio.nl;
+    }
+    else
+    {
+        sio << "Assuming big endian." << sio.nl;
+    }
+    uint16_t hi, lo;
+    for( ; i; i++ )
+    {
+        hi = (((uint8_t)*i)<<8) | ((uint8_t)*(++i));
+        append16( hi );
+        if( (hi&0xD800u) == 0xD800u )
+        {
+            lo = (((uint8_t)*(++i))<<8) | ((uint8_t)*(++i));
+            append16( lo );
+        }
+    }
 }
 
 void Bu::UtfString::setUtf16le( const Bu::String &sInput )
 {
-        Bu::String::const_iterator i = sInput.begin();
-        if( (uint8_t)*sInput.begin() == 0xFF &&
-                (uint8_t)*(sInput.begin()+1) == 0xFE )
-        {
-                i += 2;
-                sio << "Verified little endian." << sio.nl;
-        }
-        else
-        {
-                sio << "Assuming little endian." << sio.nl;
-        }
-        uint16_t hi, lo;
-        for( ; i; i++ )
-        {
-                hi = (((uint8_t)*i)) | ((uint8_t)*(++i)<<8);
-                append16( hi );
-                if( (hi&0xD800u) == 0xD800u )
-                {
-                        lo = (((uint8_t)*(++i))) | ((uint8_t)*(++i)<<8);
-                        append16( lo );
-                }
-        }
+    Bu::String::const_iterator i = sInput.begin();
+    if( (uint8_t)*sInput.begin() == 0xFF &&
+        (uint8_t)*(sInput.begin()+1) == 0xFE )
+    {
+        i += 2;
+        sio << "Verified little endian." << sio.nl;
+    }
+    else
+    {
+        sio << "Assuming little endian." << sio.nl;
+    }
+    uint16_t hi, lo;
+    for( ; i; i++ )
+    {
+        hi = (((uint8_t)*i)) | ((uint8_t)*(++i)<<8);
+        append16( hi );
+        if( (hi&0xD800u) == 0xD800u )
+        {
+            lo = (((uint8_t)*(++i))) | ((uint8_t)*(++i)<<8);
+            append16( lo );
+        }
+    }
 }
 
 void Bu::UtfString::setUtf32( const Bu::String &sInput )
 {
-        Bu::String::const_iterator i = sInput.begin();
-        if( (uint8_t)*i == 0x00 &&
-                (uint8_t)*(++i) == 0x00 &&
-                (uint8_t)*(++i) == 0xFF &&
-                (uint8_t)*(++i) == 0xFE )
-        {
-                setUtf32le( sInput );
-                return;
-        }
-        setUtf32be( sInput );
+    Bu::String::const_iterator i = sInput.begin();
+    if( (uint8_t)*i == 0x00 &&
+        (uint8_t)*(++i) == 0x00 &&
+        (uint8_t)*(++i) == 0xFF &&
+        (uint8_t)*(++i) == 0xFE )
+    {
+        setUtf32le( sInput );
+        return;
+    }
+    setUtf32be( sInput );
 }
 
 void Bu::UtfString::setUtf32be( const Bu::String &sInput )
 {
-        Bu::String::const_iterator i = sInput.begin();
-        if( (uint8_t)*i == 0x00 &&
-                (uint8_t)*(++i) == 0x00 &&
-                (uint8_t)*(++i) == 0xFE &&
-                (uint8_t)*(++i) == 0xFF )
-        {
-                i++;
-                sio << "Verified big endian." << sio.nl;
-        }
-        else
-        {
-                i = sInput.begin();
-                sio << "Assuming big endian." << sio.nl;
-        }
-        for( ; i; i++ )
-        {
-                append( (((uint8_t)*i)<<24) |
-                                (((uint8_t)*(++i))<<16) |
-                                (((uint8_t)*(++i))<<8) |
-                                ((uint8_t)*(++i))
-                          );
-        }
+    Bu::String::const_iterator i = sInput.begin();
+    if( (uint8_t)*i == 0x00 &&
+        (uint8_t)*(++i) == 0x00 &&
+        (uint8_t)*(++i) == 0xFE &&
+        (uint8_t)*(++i) == 0xFF )
+    {
+        i++;
+        sio << "Verified big endian." << sio.nl;
+    }
+    else
+    {
+        i = sInput.begin();
+        sio << "Assuming big endian." << sio.nl;
+    }
+    for( ; i; i++ )
+    {
+        append( (((uint8_t)*i)<<24) |
+                (((uint8_t)*(++i))<<16) |
+                (((uint8_t)*(++i))<<8) |
+                ((uint8_t)*(++i))
+              );
+    }
 }
 
 void Bu::UtfString::setUtf32le( const Bu::String &sInput )
 {
-        Bu::String::const_iterator i = sInput.begin();
-        if( (uint8_t)*i == 0x00 &&
-                (uint8_t)*(++i) == 0x00 &&
-                (uint8_t)*(++i) == 0xFF &&
-                (uint8_t)*(++i) == 0xFE )
-        {
-                i++;
-                sio << "Verified little endian." << sio.nl;
-        }
-        else
-        {
-                i = sInput.begin();
-                sio << "Assuming little endian." << sio.nl;
-        }
-        for( ; i; i++ )
-        {
-                append( ((uint8_t)*i) |
-                                (((uint8_t)*(++i))<<8) |
-                                (((uint8_t)*(++i))<<16) |
-                                (((uint8_t)*(++i))<<24)
-                          );
-        }
+    Bu::String::const_iterator i = sInput.begin();
+    if( (uint8_t)*i == 0x00 &&
+        (uint8_t)*(++i) == 0x00 &&
+        (uint8_t)*(++i) == 0xFF &&
+        (uint8_t)*(++i) == 0xFE )
+    {
+        i++;
+        sio << "Verified little endian." << sio.nl;
+    }
+    else
+    {
+        i = sInput.begin();
+        sio << "Assuming little endian." << sio.nl;
+    }
+    for( ; i; i++ )
+    {
+        append( ((uint8_t)*i) |
+                (((uint8_t)*(++i))<<8) |
+                (((uint8_t)*(++i))<<16) |
+                (((uint8_t)*(++i))<<24)
+              );
+    }
 }
 
 void Bu::UtfString::write( Bu::Stream &sOut, Encoding eEnc ) const
 {
-        switch( eEnc )
-        {
-                case Utf8:
-                        writeUtf8( sOut );
-                        break;
+    switch( eEnc )
+    {
+        case Utf8:
+            writeUtf8( sOut );
+            break;
 
-                case Utf16:
-//                      writeUtf16( sOut );
-//                      break;
+        case Utf16:
+//          writeUtf16( sOut );
+//          break;
 
-                case Utf16be:
-                        writeUtf16be( sOut );
-                        break;
+        case Utf16be:
+            writeUtf16be( sOut );
+            break;
 
-                case Utf16le:
-                        writeUtf16le( sOut );
-                        break;
+        case Utf16le:
+            writeUtf16le( sOut );
+            break;
 
-                case Utf32:
-//                      writeUtf32( sOut );
-//                      break;
+        case Utf32:
+//          writeUtf32( sOut );
+//          break;
 
-                case Utf32be:
-                        writeUtf32be( sOut );
-                        break;
+        case Utf32be:
+            writeUtf32be( sOut );
+            break;
 
-                case Utf32le:
-                        writeUtf32le( sOut );
-                        break;
+        case Utf32le:
+            writeUtf32le( sOut );
+            break;
 
-                case Ucs2:
-                        throw Bu::ExceptionBase("Ucs2 not supported yet.");
-                        break;
+        case Ucs2:
+            throw Bu::ExceptionBase("Ucs2 not supported yet.");
+            break;
 
-                case Ucs4:
-                        throw Bu::ExceptionBase("Ucs4 not supported yet.");
-                        break;
+        case Ucs4:
+            throw Bu::ExceptionBase("Ucs4 not supported yet.");
+            break;
 
-                case GuessEncoding:
-                        throw Bu::ExceptionBase(
-                                "GuessEncoding is incompatible with encoding.");
-                        break;
+        case GuessEncoding:
+            throw Bu::ExceptionBase(
+                "GuessEncoding is incompatible with encoding.");
+            break;
 
-        }
+    }
 }
 
 void Bu::UtfString::writeUtf8( Bu::Stream &sOut ) const
 {
-        int iPos = 0;
-        while( iPos < aData.getSize() )
-        {
-                uint8_t uByte;
-                Bu::UtfChar chr = nextChar( iPos );
-                if( chr >= 0x010000 )
-                {
-                        // Four bytes
-                        // 111 111111 111111 111111
-                        uByte = (chr>>18)|0xF0;
-                        sOut.write( &uByte, 1 );
-                        uByte = ((chr>>12)&0x3F)|0x80;
-                        sOut.write( &uByte, 1 );
-                        uByte = ((chr>>6)&0x3F)|0x80;
-                        sOut.write( &uByte, 1 );
-                        uByte = (chr&0x3F)|0x80;
-                        sOut.write( &uByte, 1 );
-                }
-                else if( chr >= 0x800 )
-                {
-                        // Three bytes
-                        // 1111 111111 111111
-                        uByte = (chr>>12)|0xE0;
-                        sOut.write( &uByte, 1 );
-                        uByte = ((chr>>6)&0x3F)|0x80;
-                        sOut.write( &uByte, 1 );
-                        uByte = (chr&0x3F)|0x80;
-                        sOut.write( &uByte, 1 );
-                }
-                else if( chr >= 0x80 )
-                {
-                        // Two bytes
-                        // 11111 111111
-                        uByte = (chr>>6)|0xC0;
-                        sOut.write( &uByte, 1 );
-                        uByte = (chr&0x3F)|0x80;
-                        sOut.write( &uByte, 1 );
-                }
-                else
-                {
-                        // One byte
-                        uByte = chr;
-                        sOut.write( &uByte, 1 );
-                }
-        }
+    int iPos = 0;
+    while( iPos < aData.getSize() )
+    {
+        uint8_t uByte;
+        Bu::UtfChar chr = nextChar( iPos );
+        if( chr >= 0x010000 )
+        {
+            // Four bytes
+            // 111 111111 111111 111111
+            uByte = (chr>>18)|0xF0;
+            sOut.write( &uByte, 1 );
+            uByte = ((chr>>12)&0x3F)|0x80;
+            sOut.write( &uByte, 1 );
+            uByte = ((chr>>6)&0x3F)|0x80;
+            sOut.write( &uByte, 1 );
+            uByte = (chr&0x3F)|0x80;
+            sOut.write( &uByte, 1 );
+        }
+        else if( chr >= 0x800 )
+        {
+            // Three bytes
+            // 1111 111111 111111
+            uByte = (chr>>12)|0xE0;
+            sOut.write( &uByte, 1 );
+            uByte = ((chr>>6)&0x3F)|0x80;
+            sOut.write( &uByte, 1 );
+            uByte = (chr&0x3F)|0x80;
+            sOut.write( &uByte, 1 );
+        }
+        else if( chr >= 0x80 )
+        {
+            // Two bytes
+            // 11111 111111
+            uByte = (chr>>6)|0xC0;
+            sOut.write( &uByte, 1 );
+            uByte = (chr&0x3F)|0x80;
+            sOut.write( &uByte, 1 );
+        }
+        else
+        {
+            // One byte
+            uByte = chr;
+            sOut.write( &uByte, 1 );
+        }
+    }
 }
 /*
 void Bu::UtfString::writeUtf16( Bu::Stream &sOut )
@@ -377,228 +377,228 @@ void Bu::UtfString::writeUtf16( Bu::Stream &sOut )
 void Bu::UtfString::writeUtf16be( Bu::Stream &sOut ) const
 {
 #if BYTE_ORDER == BIG_ENDIAN
-        uint16_t iTmp = 0xFEFF; // Byte Order Marker
-        sOut.write( &iTmp, 2 );
-        for( Array<uint16_t>::const_iterator i = aData.begin(); i; i++ )
-        {
-                iTmp = *i;
-                sOut.write( &iTmp, 2 );
-        }
+    uint16_t iTmp = 0xFEFF; // Byte Order Marker
+    sOut.write( &iTmp, 2 );
+    for( Array<uint16_t>::const_iterator i = aData.begin(); i; i++ )
+    {
+        iTmp = *i;
+        sOut.write( &iTmp, 2 );
+    }
 #else
-        uint16_t iTmp = 0xFEFF; // Byte Order Marker
-        iTmp = (iTmp>>8) | (iTmp<<8);
-        sOut.write( &iTmp, 2 );
-        for( Array<uint16_t>::const_iterator i = aData.begin(); i; i++ )
-        {
-                iTmp = *i;
-                iTmp = (iTmp>>8) | (iTmp<<8);
-                sOut.write( &iTmp, 2 );
-        }
+    uint16_t iTmp = 0xFEFF; // Byte Order Marker
+    iTmp = (iTmp>>8) | (iTmp<<8);
+    sOut.write( &iTmp, 2 );
+    for( Array<uint16_t>::const_iterator i = aData.begin(); i; i++ )
+    {
+        iTmp = *i;
+        iTmp = (iTmp>>8) | (iTmp<<8);
+        sOut.write( &iTmp, 2 );
+    }
 #endif
 }
 
 void Bu::UtfString::writeUtf16le( Bu::Stream &sOut ) const
 {
 #if BYTE_ORDER == LITTLE_ENDIAN
-        uint16_t iTmp = 0xFEFF; // Byte Order Marker
-        sOut.write( &iTmp, 2 );
-        for( Array<uint16_t>::const_iterator i = aData.begin(); i; i++ )
-        {
-                iTmp = *i;
-                sOut.write( &iTmp, 2 );
-        }
+    uint16_t iTmp = 0xFEFF; // Byte Order Marker
+    sOut.write( &iTmp, 2 );
+    for( Array<uint16_t>::const_iterator i = aData.begin(); i; i++ )
+    {
+        iTmp = *i;
+        sOut.write( &iTmp, 2 );
+    }
 #else
-        uint16_t iTmp = 0xFEFF; // Byte Order Marker
-        iTmp = (iTmp>>8) | (iTmp<<8);
-        sOut.write( &iTmp, 2 );
-        for( Array<uint16_t>::const_iterator i = aData.begin(); i; i++ )
-        {
-                iTmp = *i;
-                iTmp = (iTmp>>8) | (iTmp<<8);
-                sOut.write( &iTmp, 2 );
-        }
+    uint16_t iTmp = 0xFEFF; // Byte Order Marker
+    iTmp = (iTmp>>8) | (iTmp<<8);
+    sOut.write( &iTmp, 2 );
+    for( Array<uint16_t>::const_iterator i = aData.begin(); i; i++ )
+    {
+        iTmp = *i;
+        iTmp = (iTmp>>8) | (iTmp<<8);
+        sOut.write( &iTmp, 2 );
+    }
 #endif
 }
 
 void Bu::UtfString::writeUtf32be( Bu::Stream &sOut ) const
 {
 #if BYTE_ORDER == BIG_ENDIAN
-        uint32_t iTmp = 0xFEFF; // Byte Order Marker
-        sOut.write( &iTmp, 4 );
-        int i = 0;
-        while( i < aData.getSize() )
-        {
-                iTmp = nextChar( i );
-                sOut.write( &iTmp, 4 );
-        }
+    uint32_t iTmp = 0xFEFF; // Byte Order Marker
+    sOut.write( &iTmp, 4 );
+    int i = 0;
+    while( i < aData.getSize() )
+    {
+        iTmp = nextChar( i );
+        sOut.write( &iTmp, 4 );
+    }
 #else
-        uint32_t iTmp = 0xFEFF; // Byte Order Marker
-        iTmp = (iTmp>>24)|(iTmp<<24)|((iTmp&0xff0000)>>8)|((iTmp&0xff00)<<8);
-        sOut.write( &iTmp, 4 );
-        int i = 0;
-        while( i < aData.getSize() )
-        {
-                iTmp = nextChar( i );
-                iTmp = (iTmp>>24)|(iTmp<<24)|((iTmp&0xff0000)>>8)|((iTmp&0xff00)<<8);
-                sOut.write( &iTmp, 4 );
-        }
+    uint32_t iTmp = 0xFEFF; // Byte Order Marker
+    iTmp = (iTmp>>24)|(iTmp<<24)|((iTmp&0xff0000)>>8)|((iTmp&0xff00)<<8);
+    sOut.write( &iTmp, 4 );
+    int i = 0;
+    while( i < aData.getSize() )
+    {
+        iTmp = nextChar( i );
+        iTmp = (iTmp>>24)|(iTmp<<24)|((iTmp&0xff0000)>>8)|((iTmp&0xff00)<<8);
+        sOut.write( &iTmp, 4 );
+    }
 #endif
 }
 
 void Bu::UtfString::writeUtf32le( Bu::Stream &sOut ) const
 {
 #if BYTE_ORDER == LITTLE_ENDIAN
-        uint32_t iTmp = 0xFEFF; // Byte Order Marker
-        sOut.write( &iTmp, 4 );
-        int i = 0;
-        while( i < aData.getSize() )
-        {
-                iTmp = nextChar( i );
-                sOut.write( &iTmp, 4 );
-        }
+    uint32_t iTmp = 0xFEFF; // Byte Order Marker
+    sOut.write( &iTmp, 4 );
+    int i = 0;
+    while( i < aData.getSize() )
+    {
+        iTmp = nextChar( i );
+        sOut.write( &iTmp, 4 );
+    }
 #else
-        uint32_t iTmp = 0xFEFF; // Byte Order Marker
-        iTmp = (iTmp>>24)|(iTmp<<24)|((iTmp&0xff0000)>>8)|((iTmp&0xff00)<<8);
-        sOut.write( &iTmp, 4 );
-        int i = 0;
-        while( i < aData.getSize() )
-        {
-                iTmp = nextChar( i );
-                iTmp = (iTmp>>24)|(iTmp<<24)|((iTmp&0xff0000)>>8)|((iTmp&0xff00)<<8);
-                sOut.write( &iTmp, 4 );
-        }
+    uint32_t iTmp = 0xFEFF; // Byte Order Marker
+    iTmp = (iTmp>>24)|(iTmp<<24)|((iTmp&0xff0000)>>8)|((iTmp&0xff00)<<8);
+    sOut.write( &iTmp, 4 );
+    int i = 0;
+    while( i < aData.getSize() )
+    {
+        iTmp = nextChar( i );
+        iTmp = (iTmp>>24)|(iTmp<<24)|((iTmp&0xff0000)>>8)|((iTmp&0xff00)<<8);
+        sOut.write( &iTmp, 4 );
+    }
 #endif
 }
 
 Bu::UtfChar Bu::UtfString::get( int iIndex ) const
 {
-        return nextChar( iIndex );
+    return nextChar( iIndex );
 }
 
 Bu::UtfChar Bu::UtfString::nextChar( int &iIndex ) const
 {
-        Bu::UtfChar i = aData[iIndex++];
-        switch( i&0xFC00 )
-        {
-                case 0xD800:
-                        return (((i&0x3FF)<<10) | ((aData[iIndex++]&0x3FF)))+0x10000;
+    Bu::UtfChar i = aData[iIndex++];
+    switch( i&0xFC00 )
+    {
+        case 0xD800:
+            return (((i&0x3FF)<<10) | ((aData[iIndex++]&0x3FF)))+0x10000;
 
-                case 0xDC00:
-                        return (((aData[iIndex-2]&0x3FF)<<10) | ((i&0x3FF)))+0x10000;
+        case 0xDC00:
+            return (((aData[iIndex-2]&0x3FF)<<10) | ((i&0x3FF)))+0x10000;
 
-                default:
-                        return i;
-        }
+        default:
+            return i;
+    }
 }
 
 bool Bu::UtfString::operator==( const Bu::UtfString &rhs ) const
 {
-        return aData == rhs.aData;
+    return aData == rhs.aData;
 }
 
 Bu::UtfString &Bu::UtfString::operator+=( const Bu::UtfString &rhs )
 {
-        append( rhs );
-        return *this;
+    append( rhs );
+    return *this;
 }
 
 Bu::UtfString &Bu::UtfString::operator+=( const UtfChar &rhs )
 {
-        append( rhs );
-        return *this;
+    append( rhs );
+    return *this;
 }
 
 Bu::String Bu::UtfString::get( Encoding eEnc ) const
 {
-        Bu::MemBuf mb;
-        write( mb, eEnc );
-        return mb.getString();
+    Bu::MemBuf mb;
+    write( mb, eEnc );
+    return mb.getString();
 }
 
 void Bu::UtfString::debug() const
 {
-        sio << "Raw Utf16: ";
-        for( int i = 0; i < aData.getSize(); i++ )
-        {
-                if( i > 0 )
-                        sio << ", ";
-                sio << "0x" << Fmt::hex() << aData[i];
-        }
-        sio << sio.nl;
-        sio << "Code Points: ";
-        for( int i = 0; i < aData.getSize(); i++ )
-        {
-                if( i > 0 )
-                        sio << ", ";
-                sio << "0x" << Fmt::hex() << nextChar( i );
-        }
-        sio << sio.nl;
+    sio << "Raw Utf16: ";
+    for( int i = 0; i < aData.getSize(); i++ )
+    {
+        if( i > 0 )
+            sio << ", ";
+        sio << "0x" << Fmt::hex() << aData[i];
+    }
+    sio << sio.nl;
+    sio << "Code Points: ";
+    for( int i = 0; i < aData.getSize(); i++ )
+    {
+        if( i > 0 )
+            sio << ", ";
+        sio << "0x" << Fmt::hex() << nextChar( i );
+    }
+    sio << sio.nl;
 }
 /*
 void Bu::UtfString::debugUtf8( const Bu::String &sUtf8 )
 {
-        static uint8_t lmask[8] = {
-                0x00,
-                0x01,
-                0x03,
-                0x07,
-                0x0f,
-                0x1f,
-                0x3f,
-                0x7f
-        };
-        for( Bu::String::const_iterator i = sUtf8.begin(); i; i++ )
-        {
-                if( i != sUtf8.begin() )
-                        sio << ", ";
-                if( ((int)(uint8_t)*i)&0x80 )
-                {
-//                      sio << "Flag byte: " << Bu::Fmt().radix(2).width(8).fill('0')
-//                              << (int)(uint8_t)*i << sio.nl;
-                        int iBytes = 1;
-                        for(; (((uint8_t)(*i))<<iBytes)&0x80; iBytes++ ) { }
-//                      sio << "iBytes = " << iBytes << sio.nl;
-                        Bu::UtfChar uPt = ((*i) & lmask[7-iBytes])<<(6*(iBytes-1));
-//                      sio << "mask: " << Bu::Fmt().radix(2).width(8).fill('0')
-//                              << (int)lmask[7-iBytes] << sio.nl;
-                        for( iBytes--; iBytes >= 1; iBytes-- )
-                        {
-//                              sio << "iBytes = " << iBytes << ", shift = " << (6*(iBytes-1))
-//                                      << sio.nl;
-//                              sio << "next: " << Bu::Fmt().radix(2).width(8).fill('0')
-//                                      << (int)(uint8_t)*i << sio.nl
-//                                      << "mask: " << Bu::Fmt().radix(2).width(8).fill('0')
-//                                      << (int)lmask[6] << sio.nl;
-                                i++;
-                                uPt |= ((*i)&lmask[6])<<(6*(iBytes-1));
-                        }
-                        sio << uPt;
-//                      sio << " (" << Bu::Fmt( 8, 2 ).fill('0')
-//                              << uPt << ")";
-                }
-                else
-                {
-                        sio << (int)((uint8_t)*i);
-                }
-        }
-        sio << sio.nl;
+    static uint8_t lmask[8] = {
+        0x00,
+        0x01,
+        0x03,
+        0x07,
+        0x0f,
+        0x1f,
+        0x3f,
+        0x7f
+    };
+    for( Bu::String::const_iterator i = sUtf8.begin(); i; i++ )
+    {
+        if( i != sUtf8.begin() )
+            sio << ", ";
+        if( ((int)(uint8_t)*i)&0x80 )
+        {
+//          sio << "Flag byte: " << Bu::Fmt().radix(2).width(8).fill('0')
+//              << (int)(uint8_t)*i << sio.nl;
+            int iBytes = 1;
+            for(; (((uint8_t)(*i))<<iBytes)&0x80; iBytes++ ) { }
+//          sio << "iBytes = " << iBytes << sio.nl;
+            Bu::UtfChar uPt = ((*i) & lmask[7-iBytes])<<(6*(iBytes-1));
+//          sio << "mask: " << Bu::Fmt().radix(2).width(8).fill('0')
+//              << (int)lmask[7-iBytes] << sio.nl;
+            for( iBytes--; iBytes >= 1; iBytes-- )
+            {
+//              sio << "iBytes = " << iBytes << ", shift = " << (6*(iBytes-1))
+//                  << sio.nl;
+//              sio << "next: " << Bu::Fmt().radix(2).width(8).fill('0')
+//                  << (int)(uint8_t)*i << sio.nl
+//                  << "mask: " << Bu::Fmt().radix(2).width(8).fill('0')
+//                  << (int)lmask[6] << sio.nl;
+                i++;
+                uPt |= ((*i)&lmask[6])<<(6*(iBytes-1));
+            }
+            sio << uPt;
+//          sio << " (" << Bu::Fmt( 8, 2 ).fill('0')
+//              << uPt << ")";
+        }
+        else
+        {
+            sio << (int)((uint8_t)*i);
+        }
+    }
+    sio << sio.nl;
 }
 */
 
 template<> uint32_t Bu::__calcHashCode<Bu::UtfString>( const Bu::UtfString &k )
 {
-        uint32_t uCode = 0;
+    uint32_t uCode = 0;
 
-        for( Bu::UtfString::const_iterator i = k.begin(); i; i++ )
-        {
-                uCode = *i + (uCode<<6) + (uCode<<16) - uCode;
-        }
+    for( Bu::UtfString::const_iterator i = k.begin(); i; i++ )
+    {
+        uCode = *i + (uCode<<6) + (uCode<<16) - uCode;
+    }
 
-        return uCode;
+    return uCode;
 }
 
 template<> bool Bu::__cmpHashKeys<Bu::UtfString>(
-                const Bu::UtfString &a, const Bu::UtfString &b )
+        const Bu::UtfString &a, const Bu::UtfString &b )
 {
-        return a == b;
+    return a == b;
 }
diff --git a/src/unstable/utfstring.h b/src/unstable/utfstring.h
index 1bd4cce..560faae 100644
--- a/src/unstable/utfstring.h
+++ b/src/unstable/utfstring.h
@@ -13,247 +13,247 @@
 
 namespace Bu
 {
-        class String;
-        class Stream;
-
-        /**
-         * UtfChar isn't actually a character, unicode specifies "code points" not
-         * characters.  The main reason for this is that not all code points define
-         * usable characters.  Some control text directionality, some apply
-         * properties to other code points which are characters.  However, most of
-         * these distinctions are only important when implementing displays that
-         * comply with the Unicode standard fully.
-         */
-        typedef uint32_t UtfChar;
-
-        /**
-         * A unicode string.  This class represents a string of unicode code points.
-         * Every character in unicode can be represented with 21 bits, but we don't
-         * have a datatype that's 24 bits long, so we return all code points as a
-         * 32 bit unsigned value represented by Bu::UtfChar.  However, the UtfString
-         * class, for efficiency purposes doesn't store 32 bit values internally.
-         * It represents all code points in the native utf16 encodeng.  This means
-         * that it may be very difficult to quickly determine the length of a
-         * UtfString in code points.  Unlike many Unicode handling systems, this
-         * one actually works with complete code points.  When using this class you
-         * don't ever have to know about the inner workings of the different
-         * encoding schemes.  All of the data is dealt with as whole code points.
-         *
-         * As an aside, this means that when encoding a UtfString to a Utf16
-         * encoding that matches your archetecture this operation will be very
-         * fast since it will effectively be a raw dump of the internal data
-         * structures.  However, it is highly reccomended that you DO NOT use the
-         * little endian encodings if you can possibly avoid it.  They are not
-         * reccomended by the Unicode Consortium and are mainly supported as a
-         * means of communicating with other systems that encode their data
-         * incorrectly.  That said, whenever UtfString encodes the contained string
-         * it always includes a BOM at the begining (the byte order marker) so that
-         * proper byte order can be easily determined by the program reading the
-         * data.
-         *
-         *@todo Investigate http://www.unicode.org/reports/tr6/ for compression.
-         */
-        class UtfString
-        {
-        public:
-                enum Encoding
-                {
-                        Utf8,
-                        Utf16,
-                        Utf16be,
-                        Utf16le,
-                        Utf32,
-                        Utf32be,
-                        Utf32le,
-                        Ucs2,
-                        Ucs4,
-                        GuessEncoding
-                };
-
-                UtfString();
-                UtfString( const Bu::String &sInput, Encoding eEnc=Utf8 );
-                UtfString( const char *sInput, Encoding eEnc=Utf8 );
-                virtual ~UtfString();
-
-                class iterator
-                {
-                friend class UtfString;
-                private:
-                        iterator( UtfString *pSrc, int iCodePos ) :
-                                pSrc( pSrc ), iCodePos( iCodePos )
-                        {
-                        }
-
-                public:
-                        iterator() :
-                                pSrc( NULL ), iCodePos( 0 )
-                        {
-                        }
-
-                        UtfChar operator*()
-                        {
-                                if( !pSrc )
-                                        throw Bu::ExceptionBase("invalid UtfString::iterator dereferenced.");
-                                return pSrc->get( iCodePos );
-                        }
-
-                        iterator operator++()
-                        {
-                                pSrc->nextChar( iCodePos );
-                                return *this;
-                        }
-
-                        iterator operator++( int )
-                        {
-                                pSrc->nextChar( iCodePos );
-                                return *this;
-                        }
-
-                        operator bool() const
-                        {
-                                return iCodePos < pSrc->aData.getSize();
-                        }
-
-                private:
-                        UtfString *pSrc;
-                        int iCodePos;
-                };
-                
-                class const_iterator
-                {
-                friend class UtfString;
-                private:
-                        const_iterator( const UtfString *pSrc, int iCodePos ) :
-                                pSrc( pSrc ), iCodePos( iCodePos )
-                        {
-                        }
-
-                public:
-                        const_iterator() :
-                                pSrc( NULL ), iCodePos( 0 )
-                        {
-                        }
-
-                        UtfChar operator*()
-                        {
-                                if( !pSrc )
-                                        throw Bu::ExceptionBase("invalid UtfString::iterator dereferenced.");
-                                return pSrc->get( iCodePos );
-                        }
-
-                        const_iterator operator++()
-                        {
-                                pSrc->nextChar( iCodePos );
-                                return *this;
-                        }
-
-                        const_iterator operator++( int )
-                        {
-                                pSrc->nextChar( iCodePos );
-                                return *this;
-                        }
-
-                        operator bool() const
-                        {
-                                return iCodePos < pSrc->aData.getSize();
-                        }
-
-                private:
-                        const UtfString *pSrc;
-                        int iCodePos;
-                };
-
-                iterator begin();
-                const_iterator begin() const;
-
-                /**
-                 * Append a UtfChar (A unicode code point) to the string.  This can be
-                 * any valid code point, and is just the value of the code point, no
-                 * encoding necessary.
-                 */
-                void append( UtfChar ch );
-
-                void append( const UtfString &rSrc );
-
-                /**
-                 * Set the value of the entire string based on the given input and
-                 * encoding.  The default encoding is Utf8, which is compatible with
-                 * 7-bit ascii, so it's a great choice for setting UtfStrings from
-                 * string literals in code.
-                 */
-                void set( const Bu::String &sInput, Encoding eEnc=Utf8 );
-
-                /**
-                 * This encodes the UtfString in the given encoding and outputs it to
-                 * the provided stream.  all Utf16 and Utf32 encodings will have the
-                 * correct BOM (byte order marker) at the begining.
-                 */
-                void write( Bu::Stream &sOut, Encoding eEnc=Utf8 ) const;
-
-                /**
-                 * This encodes the UtfString in the given encoding and returns it as
-                 * a binary Bu::String.  Like write, this also includes the proper BOM
-                 * at the begining.
-                 */
-                Bu::String get( Encoding eEnc=Utf8 ) const;
-
-                void debug() const;
-
-                /**
-                 * This may or may not stick around, given an index, this returns a
-                 * codepoint, however there isn't necesarilly a 1:1 ratio between
-                 * indexes and code points.
-                 */
-                UtfChar get( int iIndex ) const;
-
-                /**
-                 * This is what to use if you want to iterate through a section of the
-                 * UtfString and you want to use a numerical index.  In most cases it
-                 * will be much easier to use an iterator, though.  Given an index this
-                 * will return the codepoint at that position and increment iIndex an
-                 * appropriate amount for it to point to the next code point.
-                 */
-                UtfChar nextChar( int &iIndex ) const;
-
-                bool operator==( const Bu::UtfString &rhs ) const;
-                UtfString &operator+=( const Bu::UtfString &rhs );
-                UtfString &operator+=( const UtfChar &rhs );
-
-        private:
-                void append16( uint16_t i ) { aData.append( i ); }
-
-                void setUtf8( const Bu::String &sInput );
-                void setUtf16( const Bu::String &sInput );
-                void setUtf16be( const Bu::String &sInput );
-                void setUtf16le( const Bu::String &sInput );
-                void setUtf32( const Bu::String &sInput );
-                void setUtf32be( const Bu::String &sInput );
-                void setUtf32le( const Bu::String &sInput );
-                
-                void writeUtf8( Bu::Stream &sOut ) const;
-                void writeUtf16be( Bu::Stream &sOut ) const;
-                void writeUtf16le( Bu::Stream &sOut ) const;
-                void writeUtf32be( Bu::Stream &sOut ) const;
-                void writeUtf32le( Bu::Stream &sOut ) const;
-
-        private:
-                Bu::Array<uint16_t> aData;
-                int iRawLen;
-                int iCharLen;
-        };
-
-        //
-        // Hash support
-        //
-        template<typename T>
-        uint32_t __calcHashCode( const T &k );
-
-        template<typename T>
-        bool __cmpHashKeys( const T &a, const T &b );
-
-        template<> uint32_t __calcHashCode<UtfString>( const UtfString &k );
-        template<> bool __cmpHashKeys<UtfString>(
-                const UtfString &a, const UtfString &b );
+    class String;
+    class Stream;
+
+    /**
+     * UtfChar isn't actually a character, unicode specifies "code points" not
+     * characters.  The main reason for this is that not all code points define
+     * usable characters.  Some control text directionality, some apply
+     * properties to other code points which are characters.  However, most of
+     * these distinctions are only important when implementing displays that
+     * comply with the Unicode standard fully.
+     */
+    typedef uint32_t UtfChar;
+
+    /**
+     * A unicode string.  This class represents a string of unicode code points.
+     * Every character in unicode can be represented with 21 bits, but we don't
+     * have a datatype that's 24 bits long, so we return all code points as a
+     * 32 bit unsigned value represented by Bu::UtfChar.  However, the UtfString
+     * class, for efficiency purposes doesn't store 32 bit values internally.
+     * It represents all code points in the native utf16 encodeng.  This means
+     * that it may be very difficult to quickly determine the length of a
+     * UtfString in code points.  Unlike many Unicode handling systems, this
+     * one actually works with complete code points.  When using this class you
+     * don't ever have to know about the inner workings of the different
+     * encoding schemes.  All of the data is dealt with as whole code points.
+     *
+     * As an aside, this means that when encoding a UtfString to a Utf16
+     * encoding that matches your archetecture this operation will be very
+     * fast since it will effectively be a raw dump of the internal data
+     * structures.  However, it is highly reccomended that you DO NOT use the
+     * little endian encodings if you can possibly avoid it.  They are not
+     * reccomended by the Unicode Consortium and are mainly supported as a
+     * means of communicating with other systems that encode their data
+     * incorrectly.  That said, whenever UtfString encodes the contained string
+     * it always includes a BOM at the begining (the byte order marker) so that
+     * proper byte order can be easily determined by the program reading the
+     * data.
+     *
+     *@todo Investigate http://www.unicode.org/reports/tr6/ for compression.
+     */
+    class UtfString
+    {
+    public:
+        enum Encoding
+        {
+            Utf8,
+            Utf16,
+            Utf16be,
+            Utf16le,
+            Utf32,
+            Utf32be,
+            Utf32le,
+            Ucs2,
+            Ucs4,
+            GuessEncoding
+        };
+
+        UtfString();
+        UtfString( const Bu::String &sInput, Encoding eEnc=Utf8 );
+        UtfString( const char *sInput, Encoding eEnc=Utf8 );
+        virtual ~UtfString();
+
+        class iterator
+        {
+        friend class UtfString;
+        private:
+            iterator( UtfString *pSrc, int iCodePos ) :
+                pSrc( pSrc ), iCodePos( iCodePos )
+            {
+            }
+
+        public:
+            iterator() :
+                pSrc( NULL ), iCodePos( 0 )
+            {
+            }
+
+            UtfChar operator*()
+            {
+                if( !pSrc )
+                    throw Bu::ExceptionBase("invalid UtfString::iterator dereferenced.");
+                return pSrc->get( iCodePos );
+            }
+
+            iterator operator++()
+            {
+                pSrc->nextChar( iCodePos );
+                return *this;
+            }
+
+            iterator operator++( int )
+            {
+                pSrc->nextChar( iCodePos );
+                return *this;
+            }
+
+            operator bool() const
+            {
+                return iCodePos < pSrc->aData.getSize();
+            }
+
+        private:
+            UtfString *pSrc;
+            int iCodePos;
+        };
+        
+        class const_iterator
+        {
+        friend class UtfString;
+        private:
+            const_iterator( const UtfString *pSrc, int iCodePos ) :
+                pSrc( pSrc ), iCodePos( iCodePos )
+            {
+            }
+
+        public:
+            const_iterator() :
+                pSrc( NULL ), iCodePos( 0 )
+            {
+            }
+
+            UtfChar operator*()
+            {
+                if( !pSrc )
+                    throw Bu::ExceptionBase("invalid UtfString::iterator dereferenced.");
+                return pSrc->get( iCodePos );
+            }
+
+            const_iterator operator++()
+            {
+                pSrc->nextChar( iCodePos );
+                return *this;
+            }
+
+            const_iterator operator++( int )
+            {
+                pSrc->nextChar( iCodePos );
+                return *this;
+            }
+
+            operator bool() const
+            {
+                return iCodePos < pSrc->aData.getSize();
+            }
+
+        private:
+            const UtfString *pSrc;
+            int iCodePos;
+        };
+
+        iterator begin();
+        const_iterator begin() const;
+
+        /**
+         * Append a UtfChar (A unicode code point) to the string.  This can be
+         * any valid code point, and is just the value of the code point, no
+         * encoding necessary.
+         */
+        void append( UtfChar ch );
+
+        void append( const UtfString &rSrc );
+
+        /**
+         * Set the value of the entire string based on the given input and
+         * encoding.  The default encoding is Utf8, which is compatible with
+         * 7-bit ascii, so it's a great choice for setting UtfStrings from
+         * string literals in code.
+         */
+        void set( const Bu::String &sInput, Encoding eEnc=Utf8 );
+
+        /**
+         * This encodes the UtfString in the given encoding and outputs it to
+         * the provided stream.  all Utf16 and Utf32 encodings will have the
+         * correct BOM (byte order marker) at the begining.
+         */
+        void write( Bu::Stream &sOut, Encoding eEnc=Utf8 ) const;
+
+        /**
+         * This encodes the UtfString in the given encoding and returns it as
+         * a binary Bu::String.  Like write, this also includes the proper BOM
+         * at the begining.
+         */
+        Bu::String get( Encoding eEnc=Utf8 ) const;
+
+        void debug() const;
+
+        /**
+         * This may or may not stick around, given an index, this returns a
+         * codepoint, however there isn't necesarilly a 1:1 ratio between
+         * indexes and code points.
+         */
+        UtfChar get( int iIndex ) const;
+
+        /**
+         * This is what to use if you want to iterate through a section of the
+         * UtfString and you want to use a numerical index.  In most cases it
+         * will be much easier to use an iterator, though.  Given an index this
+         * will return the codepoint at that position and increment iIndex an
+         * appropriate amount for it to point to the next code point.
+         */
+        UtfChar nextChar( int &iIndex ) const;
+
+        bool operator==( const Bu::UtfString &rhs ) const;
+        UtfString &operator+=( const Bu::UtfString &rhs );
+        UtfString &operator+=( const UtfChar &rhs );
+
+    private:
+        void append16( uint16_t i ) { aData.append( i ); }
+
+        void setUtf8( const Bu::String &sInput );
+        void setUtf16( const Bu::String &sInput );
+        void setUtf16be( const Bu::String &sInput );
+        void setUtf16le( const Bu::String &sInput );
+        void setUtf32( const Bu::String &sInput );
+        void setUtf32be( const Bu::String &sInput );
+        void setUtf32le( const Bu::String &sInput );
+        
+        void writeUtf8( Bu::Stream &sOut ) const;
+        void writeUtf16be( Bu::Stream &sOut ) const;
+        void writeUtf16le( Bu::Stream &sOut ) const;
+        void writeUtf32be( Bu::Stream &sOut ) const;
+        void writeUtf32le( Bu::Stream &sOut ) const;
+
+    private:
+        Bu::Array<uint16_t> aData;
+        int iRawLen;
+        int iCharLen;
+    };
+
+    //
+    // Hash support
+    //
+    template<typename T>
+    uint32_t __calcHashCode( const T &k );
+
+    template<typename T>
+    bool __cmpHashKeys( const T &a, const T &b );
+
+    template<> uint32_t __calcHashCode<UtfString>( const UtfString &k );
+    template<> bool __cmpHashKeys<UtfString>(
+        const UtfString &a, const UtfString &b );
 };
 
 #endif
diff --git a/src/unstable/uuid.cpp b/src/unstable/uuid.cpp
index aef8bc0..5400f8f 100644
--- a/src/unstable/uuid.cpp
+++ b/src/unstable/uuid.cpp
@@ -18,25 +18,25 @@
 
 Bu::Uuid::Uuid()
 {
-        clear();
+    clear();
 }
 
 Bu::Uuid::Uuid( const Uuid &src )
 {
-        memcpy( data, src.data, 16 );
+    memcpy( data, src.data, 16 );
 }
 
 Bu::Uuid::Uuid( const Bu::String &sSrc )
 {
-        if( sSrc.getSize() == 16 )
-        {
-                memcpy( data, sSrc.getStr(), 16 );
-        }
-        else if( sSrc.getSize() == 36 )
-        {
-                // Parse it
-                set( sSrc );
-        }
+    if( sSrc.getSize() == 16 )
+    {
+        memcpy( data, sSrc.getStr(), 16 );
+    }
+    else if( sSrc.getSize() == 36 )
+    {
+        // Parse it
+        set( sSrc );
+    }
 }
 
 Bu::Uuid::~Uuid()
@@ -45,130 +45,130 @@ Bu::Uuid::~Uuid()
 
 Bu::String Bu::Uuid::toRawString() const
 {
-        return Bu::String( (char *)data, 16 );
+    return Bu::String( (char *)data, 16 );
 }
 
 Bu::String Bu::Uuid::toString() const
 {
-        Bu::MemBuf mb;
-        Bu::Formatter f( mb );
+    Bu::MemBuf mb;
+    Bu::Formatter f( mb );
 
-        for( int j = 0; j < 16; j++ )
-        {
-                if( j == 4 || j == 6 || j == 8 || j == 10 )
-                        f << '-';
-                f << Bu::Fmt::hex(2).caps(false) << (unsigned int)data[j];
-        }
+    for( int j = 0; j < 16; j++ )
+    {
+        if( j == 4 || j == 6 || j == 8 || j == 10 )
+            f << '-';
+        f << Bu::Fmt::hex(2).caps(false) << (unsigned int)data[j];
+    }
 
-        return mb.getString();
+    return mb.getString();
 }
 
 Bu::String Bu::Uuid::toUrn() const
 {
-        return "urn:uuid:" + toString();
+    return "urn:uuid:" + toString();
 }
 
 int Bu::Uuid::getVersion()
 {
-        return (data[6]&((8|4|2|1)<<4))>>4;
+    return (data[6]&((8|4|2|1)<<4))>>4;
 }
 
 #define msb( i ) (1<<(7-i))
 
 void Bu::Uuid::clear()
 {
-        data[7] = msb(0);
+    data[7] = msb(0);
 }
 
 Bu::Uuid Bu::Uuid::generate( Bu::Uuid::Type eType )
 {
-        switch( eType )
-        {
-                case Version1:
-                case Version2:
-                case Version3:
-                case Version4:
-                case Version5:
-                default:
-                case System:
+    switch( eType )
+    {
+        case Version1:
+        case Version2:
+        case Version3:
+        case Version4:
+        case Version5:
+        default:
+        case System:
 #if defined(linux)
-                        Bu::File fIn( "/proc/sys/kernel/random/uuid", Bu::File::Read );
-                        char dat[36];
-                        fIn.read( dat, 36 );
-                        Uuid id;
-                        id.set( dat );
-                        return id;
+            Bu::File fIn( "/proc/sys/kernel/random/uuid", Bu::File::Read );
+            char dat[36];
+            fIn.read( dat, 36 );
+            Uuid id;
+            id.set( dat );
+            return id;
 #elif defined(WIN32)
-                        UUID uuid;
-                        UuidCreate( &uuid );
-                        Uuid id;
-                        id.data[0] = ((unsigned char *)&uuid.Data1)[3];
-                        id.data[1] = ((unsigned char *)&uuid.Data1)[2];
-                        id.data[2] = ((unsigned char *)&uuid.Data1)[1];
-                        id.data[3] = ((unsigned char *)&uuid.Data1)[0];
-                        id.data[4] = ((unsigned char *)&uuid.Data2)[1];
-                        id.data[5] = ((unsigned char *)&uuid.Data2)[0];
-                        id.data[6] = ((unsigned char *)&uuid.Data3)[1];
-                        id.data[7] = ((unsigned char *)&uuid.Data3)[0];
-                        memcpy( id.data+8, uuid.Data4, 8 );
-
-                        return id;
+            UUID uuid;
+            UuidCreate( &uuid );
+            Uuid id;
+            id.data[0] = ((unsigned char *)&uuid.Data1)[3];
+            id.data[1] = ((unsigned char *)&uuid.Data1)[2];
+            id.data[2] = ((unsigned char *)&uuid.Data1)[1];
+            id.data[3] = ((unsigned char *)&uuid.Data1)[0];
+            id.data[4] = ((unsigned char *)&uuid.Data2)[1];
+            id.data[5] = ((unsigned char *)&uuid.Data2)[0];
+            id.data[6] = ((unsigned char *)&uuid.Data3)[1];
+            id.data[7] = ((unsigned char *)&uuid.Data3)[0];
+            memcpy( id.data+8, uuid.Data4, 8 );
+
+            return id;
 #else
 # error We should be using one of the other fallbacks, but your platform is not supported yet.  Sorry.
 #endif
-        }
+    }
 }
 
 void Bu::Uuid::set( const Bu::String &sSrc )
 {
-        const char *dat = sSrc.getStr();
-        int iNibble = 0;
-        memset( data, 0, 16 );
-        for( int j = 0; j < 36; j++ )
-        {
-                if( dat[j] == '-' )
-                        continue;
-                unsigned char c = (dat[j]>='0'&&dat[j]<='9')?(dat[j]-'0'):(dat[j]-'a'+10);
-                data[iNibble/2] |= (iNibble%2==0)?(c<<4):(c);
-                iNibble++;
-        }
+    const char *dat = sSrc.getStr();
+    int iNibble = 0;
+    memset( data, 0, 16 );
+    for( int j = 0; j < 36; j++ )
+    {
+        if( dat[j] == '-' )
+            continue;
+        unsigned char c = (dat[j]>='0'&&dat[j]<='9')?(dat[j]-'0'):(dat[j]-'a'+10);
+        data[iNibble/2] |= (iNibble%2==0)?(c<<4):(c);
+        iNibble++;
+    }
 }
 
 bool Bu::Uuid::operator==( const Uuid &rhs ) const
 {
-        return memcmp( data, rhs.data, 16 ) == 0;
+    return memcmp( data, rhs.data, 16 ) == 0;
 }
 
 bool Bu::Uuid::operator!=( const Uuid &rhs ) const
 {
-        return !(*this == rhs);
+    return !(*this == rhs);
 }
 
 Bu::Uuid &Bu::Uuid::operator=( const Uuid &rhs )
 {
-        memcpy( data, rhs.data, 16 );
-        return *this;
+    memcpy( data, rhs.data, 16 );
+    return *this;
 }
 
 template<> uint32_t Bu::__calcHashCode<Bu::Uuid>( const Bu::Uuid &k )
 {
-        return __calcHashCode<String>( k.toRawString() );
+    return __calcHashCode<String>( k.toRawString() );
 }
 
 template<> bool Bu::__cmpHashKeys<Bu::Uuid>( const Bu::Uuid &a, const Bu::Uuid &b )
 {
-        return a == b;
+    return a == b;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, Uuid &u )
 {
-        ar.read( u.data, 16 );
-        return ar;
+    ar.read( u.data, 16 );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, const Uuid &u )
 {
-        ar.write( u.data, 16 );
-        return ar;
+    ar.write( u.data, 16 );
+    return ar;
 }
 
diff --git a/src/unstable/uuid.h b/src/unstable/uuid.h
index bb3d608..ecc142d 100644
--- a/src/unstable/uuid.h
+++ b/src/unstable/uuid.h
@@ -13,59 +13,59 @@
 
 namespace Bu
 {
-        class Uuid
-        {
-        friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Uuid &u );
-        friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Uuid &u );
-        public:
-                Uuid();
-                Uuid( const Uuid &src );
-                Uuid( const Bu::String &sSrc );
-                virtual ~Uuid();
+    class Uuid
+    {
+    friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Uuid &u );
+    friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Uuid &u );
+    public:
+        Uuid();
+        Uuid( const Uuid &src );
+        Uuid( const Bu::String &sSrc );
+        virtual ~Uuid();
 
-                Bu::String toRawString() const;
-                Bu::String toString() const;
-                Bu::String toUrn() const;
+        Bu::String toRawString() const;
+        Bu::String toString() const;
+        Bu::String toUrn() const;
 
-                enum Type
-                {
-                        System,
-                        Version1,
-                        Version2,
-                        Version3,
-                        Version4,
-                        Version5,
-                };
+        enum Type
+        {
+            System,
+            Version1,
+            Version2,
+            Version3,
+            Version4,
+            Version5,
+        };
 
-                int getVersion();
+        int getVersion();
 
-                static Uuid generate( Type eType = System );
-                DEPRECATED static Uuid gen() { return generate(); }
+        static Uuid generate( Type eType = System );
+        DEPRECATED static Uuid gen() { return generate(); }
 
-                void clear();
-                void set( const Bu::String &sSrc );
+        void clear();
+        void set( const Bu::String &sSrc );
 
-                bool operator==( const Uuid &rhs ) const;
-                bool operator!=( const Uuid &rhs ) const;
-                Uuid &operator=( const Bu::String &rhs ) { set( rhs ); return *this; }
-                Uuid &operator=( const Uuid &rhs );
+        bool operator==( const Uuid &rhs ) const;
+        bool operator!=( const Uuid &rhs ) const;
+        Uuid &operator=( const Bu::String &rhs ) { set( rhs ); return *this; }
+        Uuid &operator=( const Uuid &rhs );
 
-        private:
-                unsigned char data[16];
-        };
+    private:
+        unsigned char data[16];
+    };
 
-        template<typename T>
-        uint32_t __calcHashCode( const T &k );
+    template<typename T>
+    uint32_t __calcHashCode( const T &k );
 
-        template<typename T>
-        bool __cmpHashKeys( const T &a, const T &b );
+    template<typename T>
+    bool __cmpHashKeys( const T &a, const T &b );
 
-        template<> uint32_t __calcHashCode<Uuid>( const Uuid &k );
-        template<> bool __cmpHashKeys<Uuid>(
-                const Uuid &a, const Uuid &b );
+    template<> uint32_t __calcHashCode<Uuid>( const Uuid &k );
+    template<> bool __cmpHashKeys<Uuid>(
+        const Uuid &a, const Uuid &b );
 
-        Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Uuid &u );
-        Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Uuid &u );
+    Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Uuid &u );
+    Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Uuid &u );
 };
 
 #endif