--- a/base/src/java/io/ByteArrayOutputStream.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/io/ByteArrayOutputStream.d	Sat Jul 09 15:50:20 2011 +0300
@@ -9,6 +9,7 @@
 version(Tango){
     import tango.io.device.Array;
 } else { // Phobos
+    import std.outbuffer;
 }
 
 public class ByteArrayOutputStream : java.io.OutputStream.OutputStream {
@@ -16,13 +17,14 @@
     version(Tango){
         protected Array buffer;
     } else { // Phobos
+        protected OutBuffer buffer;
     }
 
     public this (){
         version(Tango){
             buffer = new Array(0);
         } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
+            buffer = new OutBuffer();
         }
     }
 
@@ -30,38 +32,38 @@
         version(Tango){
             buffer = new Array(par_size);
         } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
+            buffer = new OutBuffer();
+            buffer.reserve(par_size);
         }
     }
 
     public override void write( int b ){
         synchronized {
             version(Tango){
-                byte[1] a;
-                a[0] = b & 0xFF;
+                byte[1] a = b & 0xFF;
                 buffer.append(a);
             } else { // Phobos
-                implMissing( __FILE__, __LINE__ );
+                buffer.write(cast(ubyte)(b & 0xFF));
             }
         }
     }
 
-    public override void write( byte[] b, int off, int len ){
+    public override void write( in byte[] b, int off, int len ){
         synchronized {
             version(Tango){
-                buffer.append( b[ off .. off + len ]);
+                buffer.append( b[ off .. off + len ] );
             } else { // Phobos
-                implMissing( __FILE__, __LINE__ );
+                buffer.write( cast(ubyte[]) b[ off .. off + len ]);
             }
         }
     }
 
-    public override void write( byte[] b ){
+    public override void write( in byte[] b ){
         synchronized {
             version(Tango){
                 buffer.append( b );
             } else { // Phobos
-                implMissing( __FILE__, __LINE__ );
+                buffer.write( cast(ubyte[]) b );
             }
         }
     }
@@ -79,10 +81,9 @@
     public byte[] toByteArray(){
         synchronized {
             version(Tango){
-                return cast(byte[])buffer.slice();
+                return cast(byte[]) buffer.slice();
             } else { // Phobos
-                implMissing( __FILE__, __LINE__ );
-                return null;
+                return cast(byte[]) buffer.toBytes();
             }
         }
     }
@@ -107,7 +108,7 @@
         return null;
     }
 
-    public  override void close(){
+    public override void close(){
         implMissing( __FILE__, __LINE__ );
     }
 }

--- a/base/src/java/io/File.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/io/File.d	Sat Jul 09 15:50:20 2011 +0300
@@ -11,9 +11,14 @@
     static import tango.io.Path;
     static import tango.io.FileSystem;
     static import tango.sys.Environment;
+    static import tango.sys.Common;
+    static import tango.stdc.stringz; //for toStringz
+    version(Posix) static import tango.stdc.posix.unistd; //for access
 } else { // Phobos
     static import std.file;
     static import std.path;
+    static import std.string; //for toStringz
+    version(Posix) static import core.sys.posix.unistd; //for access
 }
 // Implement this more efficient by using FilePath in Tango 
 public class File {
@@ -32,46 +37,42 @@
             pathSeparator = tango.io.model.IFile.FileConst.SystemPathString;
             pathSeparatorChar = tango.io.model.IFile.FileConst.SystemPathChar;
         } else { // Phobos
-            version(Windows){
-                separator = "\\";
-                separatorChar = '\\';
-                pathSeparator = ";";
-                pathSeparatorChar = ';';
-            }
-            else{
-                separator = "/";
-                separatorChar = '/';
-                pathSeparator = ":";
-                pathSeparatorChar = ':';
-            }
+            separator = std.path.sep;
+            separatorChar = std.path.sep[0];
+            pathSeparator = std.path.pathsep;
+            pathSeparatorChar = std.path.pathsep[0];
         }
     }
 
-    private static String toStd( CString path ){
+    private static String toStd( String path ){
         version(Tango){
-            return tango.io.Path.standard( path._idup() );
+            return tango.io.Path.standard( path.dup );
         } else { // Phobos
-            return path._idup();
+            return path;
         }
     }
-    private static String join( CString path, CString file ){
+    private static String join( String path, String file ){
         version(Tango){
-            return tango.io.Path.join( path._idup(), file._idup() );
+            return tango.io.Path.join( toStd(path), toStd(file) );
         } else { // Phobos
-            return std.path.join( path._idup(), file._idup() );
+            return std.path.join( toStd(path), toStd(file) );
         }
     }
 
-    public this ( CString pathname ){
+    public this ( String pathname ){
         mFilePath = toStd( pathname );
     }
 
-    public this ( CString parent, CString child ){
-        mFilePath = join( toStd(parent), toStd(child) );
+    public this ( String parent, String child ){
+        mFilePath = join( parent, child );
     }
 
-    public this ( java.io.File.File parent, CString child ){
-        mFilePath = join( parent.mFilePath, toStd(child) );
+    public this ( java.io.File.File parent, String child ){
+        version(Tango){
+            mFilePath = tango.io.Path.join( parent.mFilePath, toStd(child) );
+        } else { // Phobos
+            mFilePath = std.path.join( parent.mFilePath, toStd(child) );
+        }
     }
 
     public int getPrefixLength(){
@@ -108,18 +109,12 @@
         version(Tango){
             return (new tango.io.FilePath.FilePath(mFilePath)).absolute(tango.sys.Environment.Environment.cwd).toString;
         } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
-            return "";
+            return std.path.rel2abs(mFilePath);
         }
     }
 
     public java.io.File.File getAbsoluteFile(){
-        version(Tango){
-            return new File( getAbsolutePath() );
-        } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
-            return null;
-        }
+        return new File( getAbsolutePath() );
     }
 
     public String getCanonicalPath(){
@@ -138,20 +133,27 @@
     }
 
     public bool canWrite(){
-        version(Tango){
-            return tango.io.Path.isWritable(mFilePath);
-        } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
-            return false;
-        }
+        version(Windows) { //Windows's ACL isn't supported
+            version(Tango) {
+                return tango.io.Path.isWritable(mFilePath);
+            } else { // Phobos
+                return !(std.file.getAttributes(mFilePath) & 1); //FILE_ATTRIBUTE_READONLY = 1
+            }
+        } else version(Posix) { //workaround Tango's bug (isWritable is always true)
+            version(Tango) {
+                return tango.stdc.posix.unistd.access (tango.stdc.stringz.toStringz(mFilePath), 2) is 0; //W_OK = 2
+            } else { // Phobos
+                return core.sys.posix.unistd.access (std.string.toStringz(mFilePath), 2) is 0; //W_OK = 2
+            }
+        } else
+            static assert(0);
     }
 
     public bool exists(){
         version(Tango){
             return tango.io.Path.exists(mFilePath);
         } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
-            return false;
+            return std.file.exists(mFilePath);
         }
     }
 
@@ -159,8 +161,7 @@
         version(Tango){
             return tango.io.Path.isFolder(mFilePath);
         } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
-            return false;
+            return std.file.isDir(mFilePath);
         }
     }
 
@@ -238,12 +239,12 @@
         return null;
     }
 
-    public static java.io.File.File createTempFile( CString prefix, CString suffix, java.io.File.File directory ){
+    public static java.io.File.File createTempFile( String prefix, String suffix, java.io.File.File directory ){
         implMissing( __FILE__, __LINE__ );
         return null;
     }
 
-    public static java.io.File.File createTempFile( CString prefix, CString suffix ){
+    public static java.io.File.File createTempFile( String prefix, String suffix ){
         implMissing( __FILE__, __LINE__ );
         return null;
     }

--- a/base/src/java/io/FileInputStream.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/io/FileInputStream.d	Sat Jul 09 15:50:20 2011 +0300
@@ -108,11 +108,7 @@
     }
 
     public override void close(){
-        version(Tango){
-            conduit.close();
-        } else { // Phobos
-            conduit.close();
-        }
+        conduit.close();
     }
 }
 

--- a/base/src/java/io/FileOutputStream.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/io/FileOutputStream.d	Sat Jul 09 15:50:20 2011 +0300
@@ -11,8 +11,7 @@
 version(Tango){
     import TangoFile = tango.io.device.File;
 } else { // Phobos
-    static import std.file;
-    static import std.path;
+    static import std.stream;
 }
 
 public class FileOutputStream : java.io.OutputStream.OutputStream {
@@ -20,15 +19,16 @@
     alias java.io.OutputStream.OutputStream.write write;
     alias java.io.OutputStream.OutputStream.close close;
     version(Tango){
-        TangoFile.File fc;
+        private TangoFile.File fc;
     } else { // Phobos
+        private std.stream.File fc;
     }
 
     public this ( String name ){
         version(Tango){
             fc = new TangoFile.File( name, TangoFile.File.WriteCreate );
         } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
+            fc = new std.stream.File( name, std.stream.FileMode.OutNew );
         }
     }
 
@@ -36,7 +36,7 @@
         version(Tango){
             fc = new TangoFile.File( name, append ? TangoFile.File.WriteAppending : TangoFile.File.WriteCreate );
         } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
+            fc = new std.stream.File( name, append ? std.stream.FileMode.Append : std.stream.FileMode.OutNew );
         }
     }
 
@@ -49,21 +49,16 @@
     }
 
     public override void write( int b ){
-        ubyte[1] a;
-        a[0] = b & 0xFF;
         version(Tango){
+            ubyte[1] a = b & 0xFF;
             fc.write(a);
         } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
+            fc.write(cast(byte)(b & 0xFF));
         }
     }
 
     public override void close(){
-        version(Tango){
-            fc.close();
-        } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
-        }
+        fc.close();
     }
 
     public void finalize(){

--- a/base/src/java/io/InputStream.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/io/InputStream.d	Sat Jul 09 15:50:20 2011 +0300
@@ -15,7 +15,7 @@
     public abstract int read();
 
     public int read( byte[] b ){
-        foreach( uint idx, inout byte val; b ){
+        foreach( uint idx, ref byte val; b ){
             int c = read();
             if( c == -1 ){
                 return ( idx == 0 ) ? -1 : idx;

--- a/base/src/java/io/OutputStream.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/io/OutputStream.d	Sat Jul 09 15:50:20 2011 +0300
@@ -12,13 +12,13 @@
 
     public abstract void write( int b );
 
-    public void write( byte[] b ){
+    public void write( in byte[] b ){
         foreach( bv; b ){
             write(bv);
         }
     }
 
-    public void write( byte[] b, int off, int len ){
+    public void write( in byte[] b, int off, int len ){
         write(b[off .. off+len]);
     }
 

--- a/base/src/java/lang/Byte.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/lang/Byte.d	Sat Jul 09 15:50:20 2011 +0300
@@ -4,10 +4,12 @@
 import java.lang.exceptions;
 import java.lang.Number;
 import java.lang.Class;
+import java.lang.String;
 
 version(Tango){
     static import tango.text.convert.Integer;
 } else { // Phobos
+    static import std.conv;
 }
 class Byte : Number {
     public static const byte MIN_VALUE = byte.min;
@@ -27,8 +29,12 @@
                 throw new NumberFormatException( e );
             }
         } else { // Phobos
-            implMissing( __FILE__, __LINE__);
-            return 0;
+            try{
+                return std.conv.to!(byte)(s);
+            }
+            catch( std.conv.ConvException e ){
+                throw new NumberFormatException( e );
+            }
         }
     }
     this( byte value ){

--- a/base/src/java/lang/Character.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/lang/Character.d	Sat Jul 09 15:50:20 2011 +0300
@@ -1,78 +1,68 @@
 module java.lang.Character;
 
+import java.lang.util;
 import java.lang.exceptions;
-import java.lang.util;
 import java.lang.Class;
+import java.lang.String;
 
 version(Tango){
     static import tango.text.Unicode;
-    static import tango.text.UnicodeData;
+    static import tango.text.UnicodeData; //for getUnicodeData
 } else { // Phobos
     static import std.utf;
+    static import std.conv;
     static import std.uni;
     static import std.ctype;
     static import std.string;
 }
 
 class Character {
+    public static const int MIN_RADIX = 2;
+    public static const int MAX_RADIX = 36;
     public static bool isUpperCase( dchar c ){
-        implMissing( __FILE__, __LINE__);
-        return false;
-    }
-    public static dchar toUpperCase( wchar c ){
         version(Tango){
-            wchar[1] src;
-            src[0] = c;
-            dchar[1] buf;
-            uint ate;
-            dchar[] darr = tango.text.convert.Utf.toString32( src, buf, &ate );
+            implMissingInTango( __FILE__, __LINE__);
+            return false;
         } else { // Phobos
-            wchar[1] src;
-            src[0] = c;
-            auto darr = std.utf.toUTF32(src);
+            return !!std.uni.isUniUpper(c);
         }
-        return toUpperCase( darr[0] );
-    }
-    public static String toString(char c){
-        implMissing(__FILE__, __LINE__ );
-        return null;
-    }
-    public static String toString(wchar c){
-        implMissing(__FILE__, __LINE__ );
-        return null;
-    }
-    public static String toString(dchar c){
-        implMissing(__FILE__, __LINE__ );
-        return null;
     }
     public static dchar toUpperCase( dchar c ){
         version(Tango){
-            dchar[1] src;
-            src[0] = c;
+            dchar[1] src = c;
             dchar[] r = tango.text.Unicode.toUpper( src );
             return r[0];
         } else { // Phobos
             return std.uni.toUniUpper( c );
         }
     }
-    public static dchar toLowerCase( wchar c ){
+    public static String toString( char c ){
+        version(Tango){
+            implMissingInTango(__FILE__, __LINE__ );
+            return null;
+        } else { // Phobos
+            return std.conv.to!(String)( c );
+        }
+    }
+    public static String toString( wchar c ){
         version(Tango){
-            wchar[1] src;
-            src[0] = c;
-            dchar[1] buf;
-            uint ate;
-            dchar[] darr = tango.text.convert.Utf.toString32( src, buf, &ate );
+            implMissingInTango(__FILE__, __LINE__ );
+            return null;
         } else { // Phobos
-            wchar[1] src;
-            src[0] = c;
-            auto darr = std.utf.toUTF32(src);
+            return std.conv.to!(String)( c );
         }
-        return toLowerCase( darr[0] );
+    }
+    public static String toString( dchar c ){
+        version(Tango){
+            implMissingInTango(__FILE__, __LINE__ );
+            return null;
+        } else { // Phobos
+            return std.conv.to!(String)( c );
+        }
     }
     public static dchar toLowerCase( dchar c ){
         version(Tango){
-            dchar[1] src;
-            src[0] = c;
+            dchar[1] src = c;
             dchar[] r = tango.text.Unicode.toLower( src );
             return r[0];
         } else { // Phobos
@@ -86,32 +76,26 @@
             return std.string.iswhite(c);
         }
     }
+    alias isWhitespace isWhiteSpace;
+    public static bool isSpace( dchar c ){
+        version(Tango){
+            return tango.text.Unicode.isSpace(c);
+        } else { // Phobos
+            return !!std.ctype.isspace(c);
+        }
+    }
     public static bool isDigit( dchar c ){
         version(Tango){
             return tango.text.Unicode.isDigit( c );
         } else { // Phobos
-            return std.string.isNumeric(c);
+            return !!std.ctype.isdigit(c);
         }
     }
     public static bool isLetter( dchar c ){
         version(Tango){
             return tango.text.Unicode.isLetter(c);
         } else { // Phobos
-            return std.uni.isUniAlpha(c) != 0;
-        }
-    }
-    public static bool isSpace( dchar c ){
-        version(Tango){
-            return tango.text.Unicode.isSpace(c);
-        } else { // Phobos
-            return cast(bool)std.ctype.isspace(c);
-        }
-    }
-    public static bool isWhiteSpace( dchar c ){
-        version(Tango){
-            return tango.text.Unicode.isWhitespace(c);
-        } else { // Phobos
-            return std.string.iswhite(c);
+            return !!std.uni.isUniAlpha(c);
         }
     }
     public static bool isLetterOrDigit( dchar c ){
@@ -155,66 +139,26 @@
 
 bool CharacterIsDefined( dchar ch ){
     version(Tango){
-    	return (ch in tango.text.UnicodeData.unicodeData) !is null;
+    	return tango.text.UnicodeData.getUnicodeData(ch) !is null;
     } else { // Phobos
-        implMissing( __FILE__, __LINE__);
-        return false;
-    }
-}
-
-dchar CharacterFirstToLower( CString str ){
-    int consumed;
-    return CharacterFirstToLower( str, consumed );
-}
-
-dchar CharacterFirstToLower( CString str, out int consumed ){
-    version(Tango){
-        dchar[1] buf;
-        buf[0] = firstCodePoint( str, consumed );
-        dchar[] r = tango.text.Unicode.toLower( buf );
-        return r[0];
-    } else { // Phobos
-        implMissing( __FILE__, __LINE__);
-        return 0;
+        return std.utf.isValidDchar(ch);
     }
 }
 
 dchar CharacterToLower( dchar c ){
-    version(Tango){
-        dchar[] r = tango.text.Unicode.toLower( [c] );
-        return r[0];
-    } else { // Phobos
-        return std.uni.toUniLower(c);
-    }
+    return Character.toLowerCase(c);
 }
 dchar CharacterToUpper( dchar c ){
-    version(Tango){
-        dchar[] r = tango.text.Unicode.toUpper( [c] );
-        return r[0];
-    } else { // Phobos
-        return std.uni.toUniUpper(c);
-    }
+    return Character.toUpperCase(c);
 }
 bool CharacterIsWhitespace( dchar c ){
-    version(Tango){
-        return tango.text.Unicode.isWhitespace( c );
-    } else { // Phobos
-        return std.string.iswhite(c);
-    }
+    return Character.isWhitespace(c);
 }
 bool CharacterIsDigit( dchar c ){
-    version(Tango){
-        return tango.text.Unicode.isDigit( c );
-    } else { // Phobos
-        return std.string.isNumeric(c);
-    }
+    return Character.isDigit(c);
 }
 bool CharacterIsLetter( dchar c ){
-    version(Tango){
-        return tango.text.Unicode.isLetter( c );
-    } else { // Phobos
-        return std.uni.isUniAlpha(c) != 0;
-    }
+    return Character.isLetter(c);
 }
 
 

--- a/base/src/java/lang/Double.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/lang/Double.d	Sat Jul 09 15:50:20 2011 +0300
@@ -1,8 +1,16 @@
 module java.lang.Double;
 
 import java.lang.util;
+import java.lang.exceptions;
 import java.lang.Number;
 import java.lang.Class;
+import java.lang.String;
+
+version(Tango){
+    static import tango.text.convert.Float;
+} else { // Phobos
+    static import std.conv;
+}
 
 class Double : Number {
     public static double POSITIVE_INFINITY = double.infinity;
@@ -15,16 +23,28 @@
         this.value = value;
     }
     this( String str ){
-        implMissing( __FILE__, __LINE__ );
         super();
+        this.value = parseDouble(str);
     }
     public static String toString( double value ){
-        implMissing( __FILE__, __LINE__ );
-        return null;
+        return String_valueOf(value);
     }
     public static double parseDouble(String s){
-        implMissing( __FILE__, __LINE__ );
-        return 0.0;
+        version(Tango){
+            try{
+                return tango.text.convert.Float.toFloat( s );
+            }
+            catch( IllegalArgumentException e ){
+                throw new NumberFormatException( e );
+            }
+        } else { // Phobos
+            try{
+                return std.conv.to!(double)(s);
+            }
+            catch( std.conv.ConvException e ){
+                throw new NumberFormatException( e );
+            }
+        }
     }
 
     private static Class TYPE_;

--- a/base/src/java/lang/Float.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/lang/Float.d	Sat Jul 09 15:50:20 2011 +0300
@@ -4,12 +4,19 @@
 import java.lang.exceptions;
 import java.lang.Number;
 import java.lang.Class;
+import java.lang.String;
+
+version(Tango){
+    static import tango.text.convert.Float;
+} else { // Phobos
+    static import std.conv;
+}
 
 class Float : Number {
 
-    public static float POSITIVE_INFINITY = (1.0f / 0.0f);
-    public static float NEGATIVE_INFINITY = ((-1.0f) / 0.0f);
-    public static float NaN = (0.0f / 0.0f);
+    public static float POSITIVE_INFINITY = float.infinity;
+    public static float NEGATIVE_INFINITY = -float.infinity;
+    public static float NaN = float.nan;
     public static float MAX_VALUE = 3.4028235e+38f;
     public static float MIN_VALUE = float.min; //1.4e-45f
     public static int SIZE = 32;
@@ -20,12 +27,11 @@
         this.value = value;
     }
     this( String str ){
-        implMissing( __FILE__, __LINE__ );
         super();
+        this.value = parseFloat(str);
     }
     public static String toString( float value ){
-        implMissing( __FILE__, __LINE__ );
-        return null;
+        return String_valueOf(value);
     }
     public static float parseFloat( String s ){
         version(Tango){
@@ -36,8 +42,12 @@
                 throw new NumberFormatException( e );
             }
         } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
-            return 0.0f;
+            try{
+                return std.conv.to!(float)(s);
+            }
+            catch( std.conv.ConvException e ){
+                throw new NumberFormatException( e );
+            }
         }
     }
 

--- a/base/src/java/lang/Integer.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/lang/Integer.d	Sat Jul 09 15:50:20 2011 +0300
@@ -4,18 +4,16 @@
 import java.lang.exceptions;
 import java.lang.Number;
 import java.lang.Class;
+import java.lang.Character;
 import java.lang.String;
 
 version(Tango){
+    static import tango.text.convert.Integer;
 } else { // Phobos
     static import std.conv;
     static import std.string;
 }
 
-version(Tango){
-} else { // Phobos
-}
-
 
 class Integer : Number {
 
@@ -39,64 +37,59 @@
     }
 
     public static String toString( int i, int radix ){
-        switch( radix ){
-            case 2:
-                return toBinaryString(i);
-            case 8:
-                return toOctalString(i);
-            case 10:
-                return toString(i);
-            case 16:
-                return toHexString(i);
-            default:
-                implMissing( __FILE__, __LINE__ );
-                return null;
+        if(radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
+            radix = 10;
+        version(Tango){
+            switch( radix ){
+                case 10:
+                    return tango.text.convert.Integer.toString(i);
+                case 16:
+                    return tango.text.convert.Integer.toString(i, "x" );
+                case 2:
+                    return tango.text.convert.Integer.toString(i, "b" );
+                case 8:
+                    return tango.text.convert.Integer.toString(i, "o" );
+                default:
+                    implMissingInTango( __FILE__, __LINE__ );
+                    return null;
+            }
+        } else { // Phobos
+            return std.conv.to!(String)(i, radix);
         }
     }
 
     public static String toHexString( int i ){
-        version(Tango){
-            return tango.text.convert.Integer.toString(i, "x" );
-        } else { // Phobos
-            return std.string.format("%x", i);
-        }
+        return toString(i, 16);
     }
 
     public static String toOctalString( int i ){
-        version(Tango){
-            return tango.text.convert.Integer.toString(i, "o" );
-        } else { // Phobos
-            return std.string.format("%o", i);
-        }
+        return toString(i, 8);
     }
 
     public static String toBinaryString( int i ){
-        version(Tango){
-            return tango.text.convert.Integer.toString(i, "b" );
-        } else { // Phobos
-            return std.string.format("%b", i);
-        }
+        return toString(i, 2);
     }
 
     public static String toString( int i ){
-        version(Tango){
-            return tango.text.convert.Integer.toString(i);
-        } else { // Phobos
-            return std.conv.to!(string)( i );
-        }
+        return String_valueOf(i);
     }
 
     public static int parseInt( String s, int radix ){
+        if(radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
+            throw new NumberFormatException("The radix is out of range");
         version(Tango){
             try{
-                return tango.text.convert.Integer.toLong( s, radix );
+                return tango.text.convert.Integer.toInt( s, radix );
             }
             catch( IllegalArgumentException e ){
                 throw new NumberFormatException( e );
             }
         } else { // Phobos
             try{
-            	return std.conv.parse!(int)( s, radix );
+                immutable res = std.conv.parse!(int)( s, radix );
+                if(s.length)
+                    throw new NumberFormatException("String has invalid characters: " ~ s);
+                return res;
             }
             catch( std.conv.ConvException e ){
                 throw new NumberFormatException( e );
@@ -113,7 +106,7 @@
     }
 
     public static Integer valueOf( String s ){
-        return valueOf( parseInt(s));
+        return valueOf(parseInt(s));
     }
 
     public static Integer valueOf( int i ){
@@ -149,11 +142,7 @@
     }
 
     public override String toString(){
-        version(Tango){
-            return tango.text.convert.Integer.toString( value );
-        } else { // Phobos
-            return std.conv.to!(string)(value);
-        }
+        return toString(value);
     }
 
     private static Class TYPE_;

--- a/base/src/java/lang/Long.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/lang/Long.d	Sat Jul 09 15:50:20 2011 +0300
@@ -3,7 +3,16 @@
 import java.lang.util;
 import java.lang.exceptions;
 import java.lang.Number;
+import java.lang.Character;
 import java.lang.Class;
+import java.lang.String;
+
+version(Tango){
+    static import tango.text.convert.Integer;
+} else { // Phobos
+    static import std.conv;
+    static import std.string;
+}
 
 class Long : Number {
     public static const long MIN_VALUE = long.min;
@@ -14,8 +23,8 @@
         this.value = value;
     }
     this( String str ){
-        implMissing( __FILE__, __LINE__ );
         super();
+        this.value = parseLong(str);
     }
     public byte byteValue(){
         return cast(byte)value;
@@ -44,6 +53,8 @@
         return parseLong( s, 10 );
     }
     public static long parseLong(String s, int radix){
+        if(radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
+            throw new NumberFormatException("The radix is out of range");
         version(Tango){
             try{
                 return tango.text.convert.Integer.toLong( s, radix );
@@ -52,13 +63,19 @@
                 throw new NumberFormatException( e );
             }
         } else { // Phobos
-            implMissing( __FILE__, __LINE__ );
-            return 0;
+            try{
+                immutable res = std.conv.parse!(long)( s, radix );
+                if(s.length)
+                    throw new NumberFormatException("String has invalid characters: " ~ s);
+                return res;
+            }
+            catch( std.conv.ConvException e ){
+                throw new NumberFormatException( e );
+            }
         }
     }
-    public static String toString( double value ){
-        implMissing( __FILE__, __LINE__ );
-        return null;
+    public static String toString( long i ){
+        return String_valueOf(i);
     }
     private static Class TYPE_;
     public static Class TYPE(){

--- a/base/src/java/lang/Math.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/lang/Math.d	Sat Jul 09 15:50:20 2011 +0300
@@ -17,34 +17,8 @@
     static int    abs(int    a){ return a > 0 ? a : -a; }
     static long   abs(long   a){ return a > 0 ? a : -a; }
 
-    static double min(double a, double b){ return a < b ? a : b; }
-    static double min(double a, int    b){ return a < b ? a : b; }
-    static float  min(float  a, float  b){ return a < b ? a : b; }
-    static float  min(float  a, int    b){ return a < b ? a : b; }
-    static float  min(int    a, float  b){ return a < b ? a : b; }
-    static int    min(byte   a, byte   b){ return a < b ? a : b; }
-    static int    min(byte   a, int    b){ return a < b ? a : b; }
-    static int    min(int    a, int    b){ return a < b ? a : b; }
-    static int    min(uint   a, int    b){ return a < b ? a : b; }
-    static int    min(int    a, uint   b){ return a < b ? a : b; }
-    static int    min(uint   a, uint   b){ return a < b ? a : b; }
-    static long   min(int    a, long   b){ return a < b ? a : b; }
-    static long   min(long   a, long   b){ return a < b ? a : b; }
-    static long   min(long   a, int    b){ return a < b ? a : b; }
-
-    static double max(double a, double b){ return a > b ? a : b; }
-    static double max(double a, int    b){ return a > b ? a : b; }
-    static float  max(float  a, float  b){ return a > b ? a : b; }
-    static float  max(float  a, int    b){ return a > b ? a : b; }
-    static float  max(int    a, float  b){ return a > b ? a : b; }
-    static int    max(byte   a, byte   b){ return a > b ? a : b; }
-    static int    max(int    a, int    b){ return a > b ? a : b; }
-    static int    max(uint   a, int    b){ return a > b ? a : b; }
-    static int    max(int    a, uint   b){ return a > b ? a : b; }
-    static int    max(uint   a, uint   b){ return a > b ? a : b; }
-    static long   max(int    a, long   b){ return a > b ? a : b; }
-    static long   max(long   a, long   b){ return a > b ? a : b; }
-    static long   max(long   a, int    b){ return a > b ? a : b; }
+    static typeof(T1.init < T2.init ? T1.init : T2.init) min(T1, T2)(T1 a, T2 b){ return a < b ? a : b; }
+    static typeof(T1.init > T2.init ? T1.init : T2.init) max(T1, T2)(T1 a, T2 b){ return a > b ? a : b; }
 
 
     static double sin(double a)  { return MathLib.sin(a); }

--- a/base/src/java/lang/Short.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/lang/Short.d	Sat Jul 09 15:50:20 2011 +0300
@@ -4,20 +4,22 @@
 import java.lang.exceptions;
 import java.lang.Number;
 import java.lang.Class;
+import java.lang.String;
 
 version(Tango){
     static import tango.text.convert.Integer;
 } else { // Phobos
+    static import std.conv;
 }
 class Short : Number {
     public static const short MIN_VALUE = short.min;
     public static const short MAX_VALUE = short.max;
     private short value;
-    public static byte parseShort( String s ){
+    public static short parseShort( String s ){
         version(Tango){
             try{
                 int res = tango.text.convert.Integer.parse( s );
-                if( res < byte.min || res > byte.max ){
+                if( res < short.min || res > short.max ){
                     throw new NumberFormatException( "out of range" );
                 }
                 return res;
@@ -26,8 +28,12 @@
                 throw new NumberFormatException( e );
             }
         } else { // Phobos
-            implMissing( __FILE__, __LINE__);
-            return 0;
+            try{
+                return std.conv.to!(short)(s);
+            }
+            catch( std.conv.ConvException e ){
+                throw new NumberFormatException( e );
+            }
         }
     }
     this( short value ){

--- a/base/src/java/lang/String.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/lang/String.d	Sat Jul 09 15:50:20 2011 +0300
@@ -11,379 +11,21 @@
     static import tango.text.Unicode;
     static import tango.text.convert.Utf;
 } else { // Phobos
-    static import core.exception;
-    static import std.uni;
-    static import std.utf;
     static import std.array;
     static import std.string;
     static import std.conv;
     static import std.exception;
 }
 
-version(Tango){
-    public alias char[] String;
-    public alias char[] CString;
-    public alias wchar[] String16;
-    public alias wchar[] CString16;
-    public alias char*   ICharPtr;
-    public alias char*   CCharPtr;
-    public alias wchar*  CWCharPtr;
-    public alias wchar*  IWCharPtr;
-} else { // Phobos
-    public alias string String;
-    public alias wstring String16;
-    mixin(
-        "public alias const(char)[]     CString;
-        public alias const(wchar)[]    CString16;
-        public alias immutable(char)*  ICharPtr;
-        public alias const(char)*      CCharPtr;
-        public alias const(wchar)*     CWCharPtr;
-        public alias immutable(wchar)* IWCharPtr;"
-    );
-}
-
-int codepointIndexToIndex( CString str, int cpIndex ){
-    int cps = cpIndex;
-    int res = 0;
-    while( cps > 0 ){
-        cps--;
-        if( str[res] < 0x80 ){
-            res+=1;
-        }
-        else if( str[res] < 0xE0 ){
-            res+=2;
-        }
-        else if( str[res] & 0xF0 ){
-            res+=3;
-        }
-        else{
-            res+=4;
-        }
-    }
-    return res;
-}
-
-/++
-+
-+/
-int indexToCodepointIndex( CString str, int index ){
-    if( index < 0 ) return index;
-    int i = 0;
-    int res = 0;
-    while( i < index ){
-        if( i >= str.length ){
-            break;
-        }
-        if( str[i] < 0x80 ){
-            i+=1;
-        }
-        else if( str[i] < 0xE0 ){
-            i+=2;
-        }
-        else if( str[i] & 0xF0 ){
-            i+=3;
-        }
-        else{
-            i+=4;
-        }
-        res++;
-    }
-    return res;
-}
+alias TryImmutable!(char)[]  String;
+alias TryImmutable!(wchar)[] String16;
 
-/++
-+ Get that String, that contains the next codepoint of a String.
-+/
-String firstCodePointStr( CString str, out int consumed ){
-    version(Tango){
-        dchar[1] buf;
-        uint ate;
-        dchar[] res = tango.text.convert.Utf.toString32( str, buf, &ate );
-        consumed = ate;
-        return str[ 0 .. ate ];
-    } else { // Phobos
-        implMissing( __FILE__, __LINE__ );
-        return null;
-    }
-}
-
-/++
-+ Get first codepoint of a String. If an offset is needed, simply use a slice:
-+ ---
-+ dchar res = str[ offset .. $ ].firstCodePoint();
-+ ---
-+/
-dchar firstCodePoint( CString str ){
-    int dummy;
-    return firstCodePoint( str, dummy );
-}
-dchar firstCodePoint( CString str, out int consumed ){
-    version(Tango){
-        dchar[1] buf;
-        uint ate;
-        dchar[] res = tango.text.convert.Utf.toString32( str, buf, &ate );
-        consumed = ate;
-        if( ate is 0 || res.length is 0 ){
-            getDwtLogger().trace( __FILE__, __LINE__, "str.length={} str={:X2}", str.length, cast(ubyte[])str );
-        }
-        assert( ate > 0 );
-        assert( res.length is 1 );
-        return res[0];
-    } else { // Phobos
-        size_t ate = 0;
-        auto res = std.utf.decode(str, ate);
-
-        if (ate == 0)
-            getDwtLogger().trace( __FILE__, __LINE__, "str.length={} str={:X2}", str.length, cast(ubyte[])str );
-
-        assert(ate > 0);
-        consumed = ate;
-
-        return res;
-    }
-}
-dchar firstCodePoint( CString16 str, out int consumed ){
-    version(Tango){
-        dchar[1] buf;
-        uint ate;
-        dchar[] res = tango.text.convert.Utf.toString32( str, buf, &ate );
-        consumed = ate;
-        if( ate is 0 || res.length is 0 ){
-            getDwtLogger().trace( __FILE__, __LINE__, "str.length={} str={:X2}", str.length, cast(ubyte[])str );
-        }
-        assert( ate > 0 );
-        assert( res.length is 1 );
-        return res[0];
-    } else { // Phobos
-        size_t ate = 0;
-        auto res = std.utf.decode(str, ate);
-
-        if (ate == 0)
-            getDwtLogger().trace( __FILE__, __LINE__, "str.length={} str={:X2}", str.length, cast(ubyte[])str );
-
-        assert(ate > 0);
-        consumed = ate;
-
-        return res;
-    }
-}
-
-String dcharToString( dchar key ){
-    version(Tango){
-        dchar[1] buf;
-        buf[0] = key;
-        return tango.text.convert.Utf.toString( buf );
-    } else { // Phobos
-        return std.conv.to!(string)(key);
-    }
-}
-
-int codepointCount( CString str ){
-    version(Tango){
-        scope dchar[] buf = new dchar[]( str.length );
-        uint ate;
-        dchar[] res = tango.text.convert.Utf.toString32( str, buf, &ate );
-        assert( ate is str.length );
-        return res.length;
-    } else { // Phobos
-        return std.utf.count(str);
-    }
+String new_String( String cont, int offset, int len ){
+    return _idup(cont[ offset .. offset+len ]);
 }
 
-//alias tango.text.convert.Utf.toString16 toString16;
-//alias tango.text.convert.Utf.toString toString;
-
-int toAbsoluteCodePointStartOffset( CString str, int index ){
-    //getDwtLogger().trace( __FILE__, __LINE__, "str={}, str.length={}, index={}", str, str.length, index );
-    //getDwtLogger().trace( __FILE__, __LINE__, Trace.memory( str );
-    if( str.length is index ){
-        return index;
-    }
-    if( ( str[index] & 0x80 ) is 0x00 ) {
-        return index;
-    }
-    else{
-        int steps = 0;
-        while(( str[index] & 0xC0 ) is 0x80 ){
-            index--;
-            steps++;
-            if( steps > 3 || index < 0 ){
-                break;
-            }
-        }
-        if((( str[index] & 0xE0 ) is 0xC0) && ( steps <= 1 )){
-            // ok
-        }
-        else if((( str[index] & 0xF0 ) is 0xE0) && ( steps <= 2 )){
-            // ok
-        }
-        else if((( str[index] & 0xF8 ) is 0xF0) && ( steps <= 3 )){
-            // ok
-        }
-        else{
-            throw new UnicodeException( "invalid utf8 input to toAbsoluteCodePointStartOffset", index );
-        }
-        return index;
-    }
-}
-int getRelativeCodePointOffset( CString str, int startIndex, int searchRelCp ){
-    return getAbsoluteCodePointOffset( str, startIndex, searchRelCp ) - startIndex;
-}
-int getAbsoluteCodePointOffset( CString str, int startIndex, int searchRelCp ){
-
-    //getDwtLogger().trace( __FILE__, __LINE__, "str={}, str.length={}, startIndex={}, searchRelCp={}", str, str.length, startIndex, searchRelCp );
-    //getDwtLogger().trace( __FILE__, __LINE__, Trace.memory( str );
-
-    int ignore;
-    int i = startIndex;
-    if( searchRelCp > 0 ){
-        while( searchRelCp !is 0 ){
-
-            if( ( i < str.length )
-                    && (( str[i] & 0x80 ) is 0x00 ))
-            {
-                i+=1;
-            }
-            else if( ( i+1 < str.length )
-                    && (( str[i+1] & 0xC0 ) is 0x80 )
-                    && (( str[i  ] & 0xE0 ) is 0xC0 ))
-            {
-                i+=2;
-            }
-            else if( ( i+2 < str.length )
-                    && (( str[i+2] & 0xC0 ) is 0x80 )
-                    && (( str[i+1] & 0xC0 ) is 0x80 )
-                    && (( str[i  ] & 0xF0 ) is 0xE0 ))
-            {
-                i+=3;
-            }
-            else if(( i+3 < str.length )
-                    && (( str[i+3] & 0xC0 ) is 0x80 )
-                    && (( str[i+2] & 0xC0 ) is 0x80 )
-                    && (( str[i+1] & 0xC0 ) is 0x80 )
-                    && (( str[i  ] & 0xF8 ) is 0xF0 ))
-            {
-                i+=4;
-            }
-            else{
-                getDwtLogger().trace( __FILE__, __LINE__, "getAbsoluteCodePointOffset invalid utf8 characters:  {:X2}", cast(ubyte[]) str );
-                throw new UnicodeException( "invalid utf8 input", i );
-            }
-            searchRelCp--;
-        }
-    }
-    else if( searchRelCp < 0 ){
-        while( searchRelCp !is 0 ){
-            do{
-                i--;
-                if( i < 0 ){
-                    return startIndex-1;
-                }
-            } while(( str[i] & 0xC0 ) is 0x80 );
-            searchRelCp++;
-        }
-    }
-    return i;
-}
-int getAbsoluteCodePointOffset( CString16 str, int startIndex, int searchRelCp ){
-    int ignore;
-    int i = startIndex;
-    if( searchRelCp > 0 ){
-        while( searchRelCp !is 0 ){
-
-            if( ( i < str.length )
-                    && ( str[i] & 0xD800 ) !is 0xD800 )
-            {
-                i+=1;
-            }
-            else if( ( i+1 < str.length )
-                    && (( str[i+1] & 0xDC00 ) is 0xDC00 )
-                    && (( str[i  ] & 0xDC00 ) is 0xD800 ))
-            {
-                i+=2;
-            }
-            else{
-                getDwtLogger().trace( __FILE__, __LINE__, "invalid utf16 characters:  {:X2}", cast(ubyte[]) str );
-                throw new UnicodeException( "invalid utf16 input", i );
-            }
-            searchRelCp--;
-        }
-    }
-    else if( searchRelCp < 0 ){
-        while( searchRelCp !is 0 ){
-            do{
-                i--;
-                if( i < 0 ){
-                    return startIndex-1;
-                    //getDwtLogger().trace( __FILE__, __LINE__, "dwthelper.utils getRelativeCodePointOffset {}: str={}, startIndex={}, searchRelCp={}", __LINE__, str, startIndex, searchRelCp );
-                    //tango.text.convert.Utf.onUnicodeError( "invalid utf16 input", i );
-                }
-            } while(( str[i] & 0xDC00 ) is 0xDC00 );
-            searchRelCp++;
-        }
-    }
-    return i;
-}
-dchar getRelativeCodePoint( CString str, int startIndex, int searchRelCp ){
-    int dummy;
-    return getRelativeCodePoint( str, startIndex, dummy );
-}
-dchar getRelativeCodePoint( CString str, int startIndex, int searchRelCp, out int relIndex ){
-    relIndex = getRelativeCodePointOffset( str, startIndex, searchRelCp );
-    int ignore;
-    return firstCodePoint( str[ startIndex+relIndex .. $ ], ignore );
-}
-
-int utf8AdjustOffset( CString str, int offset ){
-    if( str.length <= offset || offset <= 0 ){
-        return offset;
-    }
-    while(( str[offset] & 0xC0 ) is 0x80 ){
-        offset--;
-    }
-    return offset;
-}
-int utf8OffsetIncr( CString str, int offset ){
-    int res = offset +1;
-    if( str.length <= res || res <= 0 ){
-        return res;
-    }
-    int tries = 4;
-    while(( str[res] & 0xC0 ) is 0x80 ){
-        res++;
-        assert( tries-- > 0 );
-    }
-    return res;
-}
-int utf8OffsetDecr( CString str, int offset ){
-    int res = offset-1;
-    if( str.length <= res || res <= 0 ){
-        return res;
-    }
-    int tries = 4;
-    while(( str[res] & 0xC0 ) is 0x80 ){
-        res--;
-        assert( tries-- > 0 );
-    }
-    getDwtLogger().trace( __FILE__, __LINE__, "utf8OffsetDecr {}->{}", offset, res );
-    getDwtLogger().trace( __FILE__, __LINE__, "{}", str );
-    return res;
-}
-
-String new_String( CString cont, int offset, int len ){
-    version(D_Version2){
-        return cont[ offset .. offset+len ].idup;
-    } else {
-        return cont[ offset .. offset+len ].dup;
-    }
-}
-
-String new_String( CString cont ){
-    version(D_Version2){
-        return cont.idup;
-    } else {
-        return cont.dup;
-    }
+String new_String( String cont ){
+    return _idup(cont);
 }
 
 String String_valueOf( bool v ){
@@ -391,38 +33,19 @@
 }
 
 String String_valueOf( byte v ){
-    version(Tango){
-        return tango.text.convert.Integer.toString(v);
-    } else { // Phobos
-        implMissing( __FILE__, __LINE__ );
-        return null;
-    }
+    return String_valueOf( cast(long) v );
 }
 
 String String_valueOf( ubyte v ){
-    version(Tango){
-        return tango.text.convert.Integer.toString(v);
-    } else { // Phobos
-        implMissing( __FILE__, __LINE__ );
-        return null;
-    }
+    return String_valueOf( cast(uint) v );
 }
 
 String String_valueOf( short v ){
-    version(Tango){
-        return tango.text.convert.Integer.toString(v);
-    } else { // Phobos
-        implMissing( __FILE__, __LINE__ );
-        return null;
-    }
+    return String_valueOf( cast(long) v );
 }
 
 String String_valueOf( int v ){
-    version(Tango){
-        return tango.text.convert.Integer.toString(v);
-    } else { // Phobos
-        return std.conv.to!(String)(v);
-    }
+    return String_valueOf( cast(long) v );
 }
 
 String String_valueOf( uint v ){
@@ -458,30 +81,31 @@
 }
 
 String String_valueOf( dchar v ){
-    return dcharToString(v);
+    version(Tango){
+        dchar[1] buf = v;
+        return tango.text.convert.Utf.toString( buf );
+    } else { // Phobos
+        return std.conv.to!(String)(v);
+    }
+}
+
+String dcharToString( dchar v ){
+    return String_valueOf(v);
 }
 
 String String_valueOf( char[] v ){
-    version(D_Version2){
-        return v.idup;
-    } else {
-        return v.dup;
-    }
+    return _idup(v);
 }
 
 String String_valueOf( char[] v, int offset, int len ){
-    version(D_Version2){
-        return v[ offset .. offset+len ].idup;
-    } else {
-        return v[ offset .. offset+len ].dup;
-    }
+    return _idup(v[ offset .. offset+len ]);
 }
 
 String String_valueOf( Object v ){
     return v is null ? "null" : v.toString();
 }
 
-String String_valueOf( CString16 wstr ){
+String String_valueOf( in wchar[] wstr ){
     version(Tango){
         return tango.text.convert.Utf.toString(wstr);
     } else { // Phobos
@@ -489,152 +113,270 @@
     }
 }
 
-int length( CString str ){
+int length( String str ){
     return str.length;
 }
 
 /// Extension to String
-public String toUpperCase( CString str ){
+public String toUpperCase( String str ){
     version(Tango){
         return tango.text.Unicode.toUpper( str );
     } else { // Phobos
-        implMissing( __FILE__, __LINE__ );
-        return null;
+        return cast(String) std.string.toupper( str );
     }
 }
 
 /// Extension to String
-public String replaceFirst( CString str, CString regex, CString replacement ){
+public String replaceFirst( String str, String regex, String replacement ){
     implMissing(__FILE__,__LINE__);
     return null;
 }
 
+version(Tango) int tangoToJavaIdx(T)(int idx, T[] arr) {
+    return idx is arr.length ? -1 : idx;
+}
+
 /// Extension to String
-public int indexOf( CString str, char searched ){
+public int indexOf( in char[] str, char searched ){
     version(Tango){
-        int res = tango.text.Util.locate( str, searched );
-        if( res is str.length ) res = -1;
-        return res;
+        return tangoToJavaIdx(tango.text.Util.locate( str, searched ), str);
     } else { // Phobos
         return std.string.indexOf(str, searched);
     }
 }
 
 /// Extension to String
-public int indexOf( CString str, char searched, int startpos ){
+public int indexOf( in char[] str, char searched, int fromIndex ){
+    if(fromIndex >= str.length)
+        return -1;
     version(Tango){
-        int res = tango.text.Util.locate( str, searched, startpos );
-        if( res is str.length ) res = -1;
+        return tangoToJavaIdx(tango.text.Util.locate( str, searched, fromIndex ), str);
+    } else { // Phobos
+        int res = std.string.indexOf(str[fromIndex .. $], searched);
+        if (res !is -1) res += fromIndex;
         return res;
+    }
+}
+
+/// Extension to String
+public int indexOf(in char[] str, in char[] sub){
+    return indexOf( str, sub, 0 );
+}
+
+/// Extension to String
+public int indexOf(in char[] str, in char[] sub, int fromIndex){
+    if(fromIndex + sub.length > str.length)
+        return -1;
+    if(!sub.length)
+        return fromIndex;
+    version(Tango){
+        return tangoToJavaIdx(tango.text.Util.locatePattern( str, sub, fromIndex ), str);
     } else { // Phobos
-        int res = std.string.indexOf(str[startpos .. $], searched);
-        if (res !is -1) res += startpos;
+        int res = std.string.indexOf(str[fromIndex .. $], sub);
+        if (res !is -1) res += fromIndex;
         return res;
     }
 }
 
 /// Extension to String
-public int indexOf(CString str, String ch){
-    return indexOf( str, ch, 0 );
+public int lastIndexOf(in char[] str, char ch){
+    return lastIndexOf( str, ch, str.length - 1 );
 }
 
 /// Extension to String
-public int indexOf(CString str, String ch, int start){
+public int lastIndexOf(in char[] str, char ch, int fromIndex){
+    if(fromIndex >= str.length)
+        fromIndex = str.length - 1;
     version(Tango){
-        int res = tango.text.Util.locatePattern( str, ch, start );
-        if( res is str.length ) res = -1;
-        return res;
+        return tangoToJavaIdx(tango.text.Util.locatePrior( str, ch, fromIndex + 1 ), str);
     } else { // Phobos
-        return std.string.indexOf(str[start .. $], ch);
+        return std.string.lastIndexOf(str[0 .. fromIndex + 1], ch);
     }
 }
 
 /// Extension to String
-public int lastIndexOf(CString str, char ch){
-    return lastIndexOf( str, ch, str.length );
-}
-
-/// Extension to String
-public int lastIndexOf(CString str, char ch, int formIndex){
-    version(Tango){
-        int res = tango.text.Util.locatePrior( str, ch, formIndex );
-        if( res is str.length ) res = -1;
-        return res;
-    } else { // Phobos
-        return std.string.lastIndexOf(str[0 .. formIndex], ch);
-    }
+public int lastIndexOf(in char[] str, in char[] sub ){
+    return lastIndexOf( str, sub, str.length - sub.length );
 }
 
 /// Extension to String
-public int lastIndexOf(CString str, String ch ){
-    return lastIndexOf( str, ch, str.length );
+public int lastIndexOf(in char[] str, in char[] sub, int fromIndex){
+    int max = cast(int)str.length - cast(int)sub.length;
+    if(fromIndex > max)
+        fromIndex = max;
+    if(!sub.length)
+        return fromIndex;
+    version(Tango){
+        return tangoToJavaIdx(tango.text.Util.locatePatternPrior( str, sub, fromIndex + 1 ), str);
+    } else { // Phobos
+        size_t to = fromIndex + sub.length;
+        return std.string.lastIndexOf(str[0 .. to < $ ? to : $], sub);
+    }
+}
+
+unittest {
+    sizediff_t i;
+
+    i = lastIndexOf("", 'a');
+    assert(i == -1);
+    i = lastIndexOf("def", 'a');
+    assert(i == -1);
+    i = lastIndexOf("abba", 'a');
+    assert(i == 3);
+    i = lastIndexOf("abba", 'a', 0);
+    assert(i == 0);
+    i = lastIndexOf("abba", 'a', 1);
+    assert(i == 0);
+    i = lastIndexOf("abba", 'a', 2);
+    assert(i == 0);
+    i = lastIndexOf("abba", 'a', 3);
+    assert(i == 3);
+    i = lastIndexOf("abba", 'a', 4);
+    assert(i == 3);
+    i = lastIndexOf("abba", 'a', 10);
+    assert(i == 3);
+    i = lastIndexOf("def", 'f');
+    assert(i == 2);
+
+    i = lastIndexOf("", "a");
+    assert(i == -1);
+    i = lastIndexOf("", "");
+    assert(i == 0);
+    i = lastIndexOf("abcdefcdef", "c");
+    assert(i == 6);
+    i = lastIndexOf("abcdefcdef", "cd");
+    assert(i == 6);
+    i = lastIndexOf("abcdefcdef", "cd", 5);
+    assert(i == 2);
+    i = lastIndexOf("abcdefcdef", "cd", 6);
+    assert(i == 6);
+    i = lastIndexOf("abcdefcdef", "cd", 7);
+    assert(i == 6);
+    i = lastIndexOf("abcdefcdef", "cd", 10);
+    assert(i == 6);
+    i = lastIndexOf("abcdefcdef", "x");
+    assert(i == -1);
+    i = lastIndexOf("abcdefcdef", "xy");
+    assert(i == -1);
+    i = lastIndexOf("abcdefcdef", "");
+    assert(i == 10);
+    i = lastIndexOf("abcdefcdef", "", 9);
+    assert(i == 9);
+    i = lastIndexOf("abcabc", "abc");
+    assert(i == 3);
+    i = lastIndexOf("abcabc", "abc", 2);
+    assert(i == 0);
+    i = lastIndexOf("abcabc", "abc", 3);
+    assert(i == 3);
+    i = lastIndexOf("abcabc", "abc", 4);
+    assert(i == 3);
+
+
+
+    i = indexOf("", 'a');
+    assert(i == -1);
+    i = indexOf("def", 'a');
+    assert(i == -1);
+    i = indexOf("abba", 'a');
+    assert(i == 0);
+    i = indexOf("abba", 'a', 0);
+    assert(i == 0);
+    i = indexOf("abba", 'a', 1);
+    assert(i == 3);
+    i = indexOf("abba", 'a', 2);
+    assert(i == 3);
+    i = indexOf("abba", 'a', 3);
+    assert(i == 3);
+    i = indexOf("abba", 'a', 4);
+    assert(i == -1);
+    i = indexOf("abba", 'a', 10);
+    assert(i == -1);
+    i = indexOf("def", 'f');
+    assert(i == 2);
+
+    i = indexOf("", "a");
+    assert(i == -1);
+    i = indexOf("", "");
+    assert(i == 0);
+    i = indexOf("abcdefcdef", "c");
+    assert(i == 2);
+    i = indexOf("abcdefcdef", "cd");
+    assert(i == 2);
+    i = indexOf("abcdefcdef", "cd", 4);
+    assert(i == 6);
+    i = indexOf("abcdefcdef", "cd", 5);
+    assert(i == 6);
+    i = indexOf("abcdefcdef", "cd", 6);
+    assert(i == 6);
+    i = indexOf("abcdefcdef", "cd", 7);
+    assert(i == -1);
+    i = indexOf("abcdefcdef", "cd", 10);
+    assert(i == -1);
+    i = indexOf("abcdefcdef", "x");
+    assert(i == -1);
+    i = indexOf("abcdefcdef", "xy");
+    assert(i == -1);
+    i = indexOf("abcdefcdef", "");
+    assert(i == 0);
+    i = indexOf("abcabc", "abc");
+    assert(i == 0);
+    i = indexOf("abcabc", "abc", 2);
+    assert(i == 3);
+    i = indexOf("abcabc", "abc", 3);
+    assert(i == 3);
+    i = indexOf("abcabc", "abc", 4);
+    assert(i == -1);
 }
 
 /// Extension to String
-public int lastIndexOf(CString str, String ch, int start ){
-    version(Tango){
-        int res = tango.text.Util.locatePatternPrior( str, ch, start );
-        if( res is str.length ) res = -1;
-        return res;
-    } else { // Phobos
-        implMissing( __FILE__, __LINE__ );
-        return 0;
-    }
-}
-
-/// Extension to String
-public String replaceAll( CString str, String regex, String replacement ){
+public String replaceAll( String str, String regex, String replacement ){
     implMissing(__FILE__,__LINE__);
     return null;
 }
 
 /// Extension to String
-public String replace( CString str, char from, char to ){
+public String replace( String str, char from, char to ){
     version(Tango){
         return tango.text.Util.replace( str.dup, from, to );
     } else { // Phobos
-        auto res = std.array.replace(str, [from], [to]);
+        char[1] f = from, t = to;
+        auto res = std.array.replace(str, f[], t[]);
         return std.exception.assumeUnique(res);
     }
 }
 
 /// Extension to String
-public String substring( CString str, int start ){
-    return cast(String)str[ start .. $ ].dup;
+public String substring( String str, int start ){
+    return _idup(str[ start .. $ ]);
 }
 
 /// Extension to String
-public String substring( CString str, int start, int end ){
-    return cast(String)str[ start .. end ].dup;
+public String substring( String str, int start, int end ){
+    return _idup(str[ start .. end ]);
 }
 
 /// Extension to String
-public wchar[] substring( CString16 str, int start ){
-    return cast(wchar[])(str[ start .. $ ].dup);
+public wchar[] substring( String16 str, int start ){
+    return str[ start .. $ ].dup;
 }
 
 /// Extension to String
-public wchar[] substring( CString16 str, int start, int end ){
+public wchar[] substring( String16 str, int start, int end ){
     return str[ start .. end ].dup;
 }
 
 /// Extension to String
-public char charAt( CString str, int pos ){
+public char charAt( String str, int pos ){
     return str[ pos ];
 }
 
 /// Extension to String
-public dchar dcharAt( CString str, int pos ){
-    return str[ pos .. $ ].firstCodePoint();
-}
-
-/// Extension to String
 public void getChars( String src, int srcBegin, int srcEnd, char[] dst, int dstBegin){
     dst[ dstBegin .. dstBegin + srcEnd - srcBegin ] = src[ srcBegin .. srcEnd ];
 }
 
 /// Extension to String
-public String16 toWCharArray( CString str ){
+public String16 toWCharArray( in char[] str ){
     version(Tango){
         return tango.text.convert.Utf.toString16(str);
     } else { // Phobos
@@ -643,12 +385,12 @@
 }
 
 /// Extension to String
-public char[] toCharArray( CString str ){
+public char[] toCharArray( String str ){
     return cast(char[])str;
 }
 
 /// Extension to String
-public bool endsWith( CString src, CString pattern ){
+public bool endsWith( String src, String pattern ){
     if( src.length < pattern.length ){
         return false;
     }
@@ -656,37 +398,55 @@
 }
 
 /// Extension to String
-public bool equals( CString src, CString other ){
+public bool equals( in char[] src, in char[] other ){
     return src == other;
 }
 
 /// Extension to String
-public bool equalsIgnoreCase( CString src, CString other ){
-    version(Tango){
-        return tango.text.Unicode.toFold(src) == tango.text.Unicode.toFold(other);
+public bool equalsIgnoreCase( in char[] src, in char[] other ){
+    version(Tango) {
+        if(src.length != other.length)
+            return false;
+        String s1b = new char[ src.length * 2 ]; //*2, or Tango may reallocate buffers
+        String s2b = new char[ other.length * 2 ];
+        scope(exit) {
+            delete s1b;
+            delete s2b;
+        }
+        return tango.text.Unicode.toFold( src, s1b ) ==
+            tango.text.Unicode.toFold( other, s2b );
     } else { // Phobos
-        implMissing( __FILE__, __LINE__ );
-        return false;
+        return std.string.icmp(src, other) == 0;
     }
 }
 
 /// Extension to String
-public int compareToIgnoreCase( CString src, CString other ){
+public int compareToIgnoreCase( in char[] src, in char[] other ){
     version(Tango){
-        return compareTo( tango.text.Unicode.toFold(src), tango.text.Unicode.toFold(other));
+        String s1b = new char[ src.length * 2 ]; //*2, or Tango may reallocate buffers
+        String s2b = new char[ other.length * 2 ];
+        scope(exit) {
+            delete s1b;
+            delete s2b;
+        }
+        return compareTo( tango.text.Unicode.toFold(src, s1b),
+            tango.text.Unicode.toFold(other, s2b));
     } else { // Phobos
-        implMissing( __FILE__, __LINE__ );
-        return 0;
+        return std.string.icmp(src, other);
     }
 }
 
 /// Extension to String
-public int compareTo( CString src, CString other ){
-    return typeid(String).compare( cast(void*)&src, cast(void*)&other );
+public int compareTo( in char[] src, in char[] other ){
+    version(Tango){
+        return typeid(String).compare( cast(void*)&src, cast(void*)&other );
+    } else { // Phobos
+        return std.string.cmp(src, other);
+    }
 }
 
 /// Extension to String
-public bool startsWith( CString src, CString pattern ){
+public bool startsWith( String src, String pattern ){
     if( src.length < pattern.length ){
         return false;
     }
@@ -694,23 +454,22 @@
 }
 
 /// Extension to String
-public String toLowerCase( CString src ){
+public String toLowerCase( String src ){
     version(Tango){
         return tango.text.Unicode.toLower( src );
     } else { // Phobos
-        implMissing( __FILE__, __LINE__ );
-        return null;
+        return cast(String) std.string.tolower(src);
     }
 }
 
 /// Extension to String
-public hash_t toHash( CString src ){
+public hash_t toHash( String src ){
     return typeid(String).getHash(&src);
 }
 public alias toHash String_toHash;
 
 /// Extension to String
-public String trim( CString str ){
+public String trim( String str ){
     version(Tango){
         return tango.text.Util.trim( str ).dup;
     } else { // Phobos
@@ -719,22 +478,8 @@
 }
 
 /// Extension to String
-public String intern( CString str ){
-    return str._idup();
-}
-
-/++
- + This is like tango.stdc.stringz.toStringz, but in case of an empty input string,
- + this function returns a pointer to a null value instead of a null ptr.
- +/
-public char* toStringzValidPtr( CString src ){
-    if( src ){
-        return src.toStringz();
-    }
-    else{
-        static const char[] nullPtr = "\0";
-        return cast(char*)nullPtr.ptr;
-    }
+public String intern( String str ){
+    return _idup(str);
 }
 
 version(Tango){
@@ -742,60 +487,67 @@
     public alias tango.stdc.stringz.toString16z toString16z;
     public alias tango.stdc.stringz.fromStringz fromStringz;
     public alias tango.stdc.stringz.fromString16z fromString16z;
-} else { // Phobos
-    public char* toStringz( CString s ){
-        if (s.ptr) {
-            if (s.length == 0)
-                return "\0".dup.ptr;
-                
-            else
-                return (s ~ "\0").dup.ptr;
+
+    /++
+     + This is like tango.stdc.stringz.toStringz, but in case of an empty input string,
+     + this function returns a pointer to a null value instead of a null ptr.
+     +/
+    public char* toStringzValidPtr( String src ){
+        if( src ){
+            return src.toStringz();
         }
-        
-        return null;
-    }
-    public wchar* toString16z( CString16 s ){
-        if (s.ptr) {
-            if (s.length == 0)
-                return "\0"w.dup.ptr;
-                
-            else
-                return (s ~ "\0"w).dup.ptr;
+        else{
+            return "".ptr;
         }
-        
-        return null;
+    }
+} else { // Phobos
+    static import std.c.string;
+    
+    public char* toStringzValidPtr( in char[] s ) {
+        auto copy = new char[s.length + 1];
+        copy[0..s.length] = s;
+        copy[s.length] = 0;
+        return copy.ptr;
+    }
+    
+    public char* toStringz( in char[] s ) {
+        return s is null ? null : toStringzValidPtr(s);
+    }
+    
+    public char[] fromStringz( in char* s ){
+        return s ? s[0 .. std.c.string.strlen(s)].dup : cast(char[])null;
     }
-    public char[] fromStringz( CCharPtr s ){
-        size_t len;
-        
-        if (s)
-            while (*s++)
-                len++;
-                
-        return s[0 .. len].dup;
+    /*public string fromStringz( in char* s ){
+        return std.conv.to!(string)(s);
+    }*/
+    
+    private size_t w_strlen(in wchar* s) {
+        size_t res = 0;
+        while(*(s+res))
+            ++res;
+        return res;
     }
-    public wchar[] fromString16z( CWCharPtr s ){
-        size_t len;
-        
-        if (s)
-            while (*s++)
-                len++;
-                
-        return s[0 .. len].dup;
+    
+    public wchar* toString16z( in wchar[] s ){
+        if(s is null)
+            return null;
+        auto copy = new wchar[s.length + 1];
+        copy[0..s.length] = s;
+        copy[s.length] = 0;
+        return copy.ptr;
+    }
+    
+    //Copy of std.conv.toImpl(T, S)(S s) for C-style strings
+    public wstring fromString16z( in wchar* s ){
+        return s ? s[0 .. w_strlen(s)].idup : cast(wstring)null;
     }
 }
 
-static String toHex(uint value, bool prefix = true, int radix = 8){
+static String toHex(uint i){
     version(Tango){
-        return tango.text.convert.Integer.toString(
-                value,
-                radix is 10 ? "d" :
-                radix is  8 ? "o" :
-                radix is 16 ? "x" :
-                "d" );
+        return tango.text.convert.Integer.toString(i, "x");
     } else { // Phobos
-        implMissing( __FILE__, __LINE__ );
-        return null;
+        return std.conv.to!(String)(i, 16);
     }
 }
 
@@ -807,16 +559,16 @@
     this( String str ){
         this.str = str;
     }
-    char           charAt(int index){
+    char charAt(int index){
         return str[index];
     }
-    int             length(){
+    int length(){
         return str.length;
     }
-    CharSequence    subSequence(int start, int end){
+    CharSequence subSequence(int start, int end){
         return new StringCharSequence( str[ start .. end ]);
     }
-    String          toString(){
+    String toString(){
         return str;
     }
 }
@@ -831,5 +583,3 @@
     }
 
 }
-
-

--- a/base/src/java/lang/StringBuffer.d	Sun Apr 17 17:58:36 2011 +0200
+++ b/base/src/java/lang/StringBuffer.d	Sat Jul 09 15:50:20 2011 +0300
@@ -1,96 +1,85 @@
 module java.lang.StringBuffer;
 
 import java.lang.util;
+import java.lang.exceptions;
+import java.lang.String;
 
 version(Tango){
     static import tango.text.Text;
     static import tango.text.convert.Utf;
 } else { // Phobos
-    static import std.uni;
+    static import std.outbuffer;
     static import std.utf;
 }
 
 class StringBuffer : CharSequence {
     version(Tango){
         alias tango.text.Text.Text!(char) TBuf;
-        TBuf buf;
     } else { // Phobos
-        const int STDINCR = 128;
-        char[] buf;
-        int used;
+        alias std.outbuffer.OutBuffer TBuf;
     }
+    private TBuf buffer;
 
     public this(){
-        version(Tango){
-            buf = new TBuf();
-        } else { // Phobos
-        }
+        buffer = new TBuf();
     }
 
     public this( int cap ){
         version(Tango){
-            buf = new TBuf(cap);
+            buffer = new TBuf(cap);
         } else { // Phobos
-            buf.length = cap;
+            buffer = new TBuf();
+            buffer.reserve(cap);
         }
     }
 
-    public this( CString content ){
+    public this( String content ){
         version(Tango){
-            buf = new TBuf( content );
+            buffer = new TBuf( content );
         } else { // Phobos
-            buf.length = content.length + STDINCR;
-            buf[ 0 .. content.length ] = content;
-            used = content.length;
+            buffer = new TBuf();
+            append(content);
         }
     }
 
     char charAt(int index){
         version(Tango){
-            return buf.slice()[ index ];
+            return buffer.slice()[ index ];
         } else { // Phobos
-            return buf[ index ];
+            return buffer.toBytes()[ index ];
         }
     }
 
     int length(){
         version(Tango){
-            return buf.length();
+            return buffer.length();
         } else { // Phobos
-            return used;
+            return buffer.offset;
         }
     }
 
     CharSequence subSequence(int start, int end){
-        version(Tango){
-            return new StringBuffer( buf.slice()[ start .. end ] );
-        } else { // Phobos
-            return new StringBuffer( cast(String)buf[ start .. end ] );
-        }
+        return new StringCharSequence( substring(start, end) );
     }
 
     String toString(){
         version(Tango){
-            return buf.slice();
+            return buffer.slice().dup;
         } else { // Phobos
-            return cast(String)buf[ 0 .. used ];
+            return buffer.toString();
         }
     }
 
-    StringBuffer append( CString s ){
+    StringBuffer append( in char[] s ){
         version(Tango){
-            buf.append( s );
+            buffer.append( s );
         } else { // Phobos
-            if( buf.length < used + s.length ){
-                buf.length = used + s.length + STDINCR;
-            }
-            buf[ used .. used + s.length ] = s;
-            used += s.length;
+            buffer.write( s );
         }
         return this;
     }
 
-    StringBuffer append( CString s, int offset, int len ){
+    StringBuffer append( in char[] s, int offset, int len ){
         return append( s[ offset .. offset+len ] );
     }
 
@@ -103,21 +92,37 @@
     }
 
     StringBuffer append( char c ){
-        char[1] src;
-        src[0] = c;
-        return append( cast(String)src );
+        version(Tango){
+            char[1] src = c;
+            return append( src );
+        } else { // Phobos
+            buffer.write(c);
+            return this;
+        }
     }
 
     StringBuffer append( wchar c ){
-        wchar[1] src;
-        src[0] = c;
         version(Tango){
-            char[2] trg;
+            wchar[1] src = c;
+            char[1 * 2 + 3] trg; // or Tango will reallocate output to input.length * 2 + 3
             auto arr = tango.text.convert.Utf.toString( src, trg );
+            return append( arr );
         } else { // Phobos
-            auto arr = std.utf.toUTF8( src );
+            char[4] trg;
+            return append( trg[0 .. std.utf.encode(trg, c)] );
         }
-        return append( arr );
+    }
+
+    StringBuffer append( dchar c ){
+        version(Tango){
+            dchar[1] src = c;
+            char[1 * 2 + 4] trg; // or Tango will reallocate output to input.length * 2 + 4
+            auto arr = tango.text.convert.Utf.toString( src, trg );
+            return append( arr );
+        } else { // Phobos
+            char[4] trg;
+            return append( trg[0 .. std.utf.encode(trg, c)] );
+        }
     }
 
     StringBuffer append( bool i ){
@@ -132,103 +137,87 @@
         return append( String_valueOf(i) );
     }
 
-    StringBuffer append( dchar c ){
-        dchar[1] src;
-        src[0] = c;
+    StringBuffer replace(int start, int end, in char[] str) {
+        if(start < 0 || start > length() || start > end)
+            throw new StringIndexOutOfBoundsException("start is negative, greater than length(), or greater than end");
+        
         version(Tango){
-            char[4] trg;
-            auto arr = tango.text.convert.Utf.toString( src, trg );
-        } else { // Phobos
-            auto arr = std.utf.toUTF8( src );
-        }
-        return append( arr );
-    }
-
-
-    StringBuffer insert(int offset, int i){
-        return insert( offset, String_valueOf(i) );
-    }
-    StringBuffer insert(int offset, CString str){
-        return replace( offset, offset, str );
-    }
-
-    StringBuffer insert(int offset, StringBuffer other){
-        return insert( offset, other.slice());
-    }
-
-    StringBuffer replace(int start, int end, CString str) {
-        version(Tango){
-            buf.select(start, end-start);
-            buf.replace(str);
-            buf.select();
+            buffer.select(start, end-start);
+            buffer.replace(str);
+            buffer.select();
         } else { // Phobos
-            int incr = end - start - str.length;
-            if( incr > 0 ){
-                if( buf.length < used + incr ){
-                    char[] newbuf = new char[ 2*(used + incr) + STDINCR ];
-                    newbuf[ 0 .. start ] = buf[ 0 .. start ];
-                    newbuf[ start .. start + str.length ] = str;
-                    newbuf[ start + str.length .. used + str.length ] = buf[ end .. used ];
-                    buf = newbuf;
+            if(end >= length()) {
+                buffer.offset = start;
+                return append(str);
+            }
+            int strEnd = start + str.length, incr = strEnd - end;
+            
+            if( incr > 0 ) {
+                buffer.spread(end, incr);
+            }
+            else if( incr < 0 ) {
+                auto bytes = buffer.toBytes();
+                bytes[ start .. strEnd ] = cast(ubyte[])str;
+                foreach (i, b; bytes[ end .. $ ]) {
+                    bytes[strEnd + i] = bytes[end + i];
                 }
-                else{
-                    char* s = buf.ptr + start;
-                    char* t = buf.ptr + start + str.length;
-                    char* e = buf.ptr + start + str.length;
-                    while( s !is e ){
-                        *t = *s;
-                        s++; t++;
-                    }
-                    buf[ start .. start + str.length ] = str;
-                }
+                buffer.offset += incr;
             }
-            else if( incr == 0 ){
-                buf[ start .. end ] = str;
-            }
-            else{
-                buf[ start .. end ] = str;
-                char* s = buf.ptr + end;
-                char* t = buf.ptr + start + str.length;
-                char* e = buf.ptr + start + str.length;
-                while( s !is e ){
-                    *t = *s;
-                    s--; t--;
-                }
-            }
-            used += incr;
+            buffer.toBytes()[ start .. strEnd ] = cast(ubyte[])str;
         }
         return this;
     }
 
+    StringBuffer insert(int offset, in char[] str){
+        return replace( offset, offset, str );
+    }
+    
+    StringBuffer insert(int offset, int i){
+        return insert( offset, String_valueOf(i) );
+    }
+
+    StringBuffer insert(int offset, StringBuffer other){
+        return insert( offset, other.slice() );
+    }
+
     void setLength( int newLength ){
+        if(newLength < 0)
+            throw new IndexOutOfBoundsException("the newLength argument is negative");
+        
         version(Tango){
-            buf.truncate( newLength );
+            buffer.truncate( newLength );
         } else { // Phobos
-            if( buf.length < newLength ){
-                buf.length = 2*newLength + STDINCR;
-            }
-            used = newLength;
+            immutable d = newLength - length();
+            if( d > 0 )
+                buffer.reserve(d);
+            else
+                buffer.offset += d;
         }
     }
 
     String substring( int start, int end ){
+        if(start < 0 || end < 0 || end > length() || start > end)
+            throw new StringIndexOutOfBoundsException("start or end are negative, if end is greater than length(), or if start is greater than end");
+        
         version(Tango){
-            return buf.slice()[ start .. end ].dup;
+            return buffer.slice()[ start .. end ].dup;
         } else { // Phobos
-            return buf[ start .. end ].idup;
+            return (cast(char[]) buffer.toBytes()[ start .. end ]).idup;
         }
     }
 
     void delete_( int start, int end ){
         replace( start, end, "" );
     }
-    String slice(){
+    
+    TryConst!(char)[] slice(){
         version(Tango){
-            return buf.slice();
+            return buffer.slice();
         } else { // Phobos
-            return cast(String)buf[ 0 .. used ];
+            return cast(TryConst!(char)[]) buffer.toBytes();
         }
     }
+    
     void truncate( int start ){
         setLength( start );
     }