6 files changed, 228 insertions, 8 deletions

diff --git a/autoconfig.cpp b/autoconfig.cpp
new file mode 100644
index 0000000..aa8b6a4
--- /dev/null
+++ b/autoconfig.cpp
@@ -0,0 +1,30 @@
+#include <stdint.h>
+#include <stdio.h>
+
+void detectEndianness()
+{
+        uint16_t x=0x0100;
+        fprintf( stderr,
+                "#define LITTLE_ENDIAN 0\n"
+                "#define BIG_ENDIAN 1\n"
+                "#define ENDIANNESS %d\n\n",
+                ((uint8_t *)&x)[0]
+                );
+        printf("Archetecture is: %s Endian\n", ((uint8_t *)&x)[0]?"Big":"Little" );
+}
+
+int main()
+{
+        fprintf( stderr,
+                "#ifndef BU_AUTO_CONFIG_H\n"
+                "#define BU_AUTO_CONFIG_H\n\n"
+                );
+
+        // huh, turns out #include <endian.h> covers this...
+//      detectEndianness();
+
+        fprintf( stderr, "#endif\n");
+
+        return 0;
+}
+
diff --git a/default.bld b/default.bld
index aa7f4cb..1aca56a 100644
--- a/default.bld
+++ b/default.bld
@@ -15,7 +15,8 @@ CXXFLAGS += "-ggdb -W -Wall -I.";
 
 action "default"
 {
-        build: [targets("header-links"), "libbu++.a", targets("tools")];
+        build: [targets("header-links"), "libbu++.a",
+                targets("tools")];
 }
 
 action "pkg"
@@ -25,14 +26,44 @@ action "pkg"
 
 action "all"
 {
-        build: [targets("header-links"), "libbu++.a", targets("tools"),
-                targets("tests")];
+        build: [targets("header-links"), "libbu++.a",
+                targets("tools"), targets("tests")];
 }
 
 action "unit"
 {
         build: targets("unit tests");
 }
+/*
+target "src/autoconfig.h"
+{
+        input "autoconfig";
+        display "autoconfig";
+        profile "build"
+        {
+                execute("./autoconfig 2>src/autoconfig.h");
+        }
+}
+
+target "bu/autoconfig.h"
+{
+        tag "header-links";
+        display "symlink";
+        input "src/autoconfig.h";
+        profile "build"
+        {
+                execute("echo ${INPUT}");
+                execute("echo ${OUTPUT}");
+                execute("mkdir -p $(dirname ${OUTPUT}); ln -s ../${INPUT} ${OUTPUT}");
+        }
+}
+
+target "autoconfig"
+{
+        rule "exe";
+        input "autoconfig.cpp";
+}
+*/
 
 target files("src/*.h").replace("src/", "bu/")
 {
diff --git a/src/config.h b/src/config.h
index 3046b59..ce954de 100644
--- a/src/config.h
+++ b/src/config.h
@@ -17,4 +17,7 @@
 
 #include "bu/extratypes.h"
 
+// Later if we need autoconfig stuff, here's where it'll go.
+// #include "bu/autoconfig.h"
+
 #endif
diff --git a/src/tests/utf.cpp b/src/tests/utf.cpp
index 59d49c6..9e075e2 100644
--- a/src/tests/utf.cpp
+++ b/src/tests/utf.cpp
@@ -16,7 +16,8 @@ int main( int argc, char *argv[] )
                         int iAmnt = fIn.read( buf, 4096 );
                         sUtf8.append( buf, iAmnt );
                 }
-                Bu::UtfString::debugUtf8( sUtf8 );
+                Bu::UtfString us( sUtf8, Bu::UtfString::Utf16 );
+                us.debug();
         }
 }
 
diff --git a/src/utfstring.cpp b/src/utfstring.cpp
index 0e2060b..bb0a011 100644
--- a/src/utfstring.cpp
+++ b/src/utfstring.cpp
@@ -9,17 +9,156 @@
 
 #include "bu/string.h"
 
+#include <endian.h>
+
 Bu::UtfString::UtfString()
 {
 }
 
+Bu::UtfString::UtfString( const Bu::String &sInput, Encoding eEnc )
+{
+        set( sInput, eEnc );
+}
+
 Bu::UtfString::~UtfString()
 {
 }
 
+void Bu::UtfString::set( const Bu::String &sInput, Encoding eEnc )
+{
+        switch( eEnc )
+        {
+                case Utf8:
+                        setUtf8( sInput );
+                        break;
+
+                case Utf16:
+                case Utf16be:
+                        setUtf16( sInput );
+                        break;
+
+                case Utf16le:
+                        throw Bu::ExceptionBase("Utf16le not supported yet.");
+                        break;
+
+                case Utf32:
+                        throw Bu::ExceptionBase("Utf32 not supported yet.");
+                        break;
+
+                case Ucs16:
+                        throw Bu::ExceptionBase("Ucs16 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) );
+        }
+}
+
+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) );
+                }
+        }
+}
+
+void Bu::UtfString::setUtf16( const Bu::String &sInput )
+{
+        uint16_t hi, lo;
+        for( Bu::String::const_iterator i = sInput.begin(); 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 );
+                }
+        }
+}
+
 #include "bu/sio.h"
 using Bu::sio;
 
+Bu::UtfChar Bu::UtfString::get( int iIndex )
+{
+        Bu::UtfChar i = aData[iIndex];
+        switch( i&0xFC00 )
+        {
+                case 0xD800:
+                        sio << "(hi) ";
+                        return (((i&0x3FF)<<10) | ((aData[iIndex+1]&0x3FF)))+0x10000;
+
+                case 0xDC00:
+                        sio << "(lo) ";
+                        return 0;
+
+                default:
+                        sio << "(--) ";
+                        return i&0xFC00;
+        }
+}
+
+void Bu::UtfString::debug()
+{
+        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() << get( i );
+        }
+        sio << sio.nl;
+}
+/*
 void Bu::UtfString::debugUtf8( const Bu::String &sUtf8 )
 {
         static uint8_t lmask[8] = {
@@ -43,7 +182,7 @@ void Bu::UtfString::debugUtf8( const Bu::String &sUtf8 )
                         int iBytes = 1;
                         for(; (((uint8_t)(*i))<<iBytes)&0x80; iBytes++ ) { }
 //                      sio << "iBytes = " << iBytes << sio.nl;
-                        point uPt = ((*i) & lmask[7-iBytes])<<(6*(iBytes-1));
+                        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-- )
@@ -68,4 +207,4 @@ void Bu::UtfString::debugUtf8( const Bu::String &sUtf8 )
         }
         sio << sio.nl;
 }
-
+*/
diff --git a/src/utfstring.h b/src/utfstring.h
index 6f85e93..79ef62e 100644
--- a/src/utfstring.h
+++ b/src/utfstring.h
@@ -9,9 +9,12 @@
 #define BU_UTF_STRING_H
 
 #include <stdint.h>
+#include "bu/array.h"
 
 namespace Bu
 {
+        class String;
+
         /**
          * UtfChar isn't actually a character, unicode specifies "code points" not
          * characters.  The main reason for this is that not all code points define
@@ -40,10 +43,23 @@ namespace Bu
                 UtfString( const Bu::String &sInput, Encoding eEnc=Utf8 );
                 virtual ~UtfString();
 
-                static void debugUtf8( const Bu::String &sUtf8 );
+                void append( UtfChar ch );
+
+                void set( const Bu::String &sInput, Encoding eEnc=Utf8 );
+                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 debug();
+
+                UtfChar get( int iIndex );
+
+        private:
+                void append16( uint16_t i ) { aData.append( i ); }
 
         private:
-                uint16_t *pData;
+                Bu::Array<uint16_t> aData;
                 int iRawLen;
                 int iCharLen;
         };