--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/beans/PropertyChangeEvent.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,37 @@
+module java.beans.PropertyChangeEvent;
+
+import java.lang.all;
+import java.util.EventObject;
+
+class PropertyChangeEvent : EventObject {
+    private String propertyName;
+    private Object oldValue;
+    private Object newValue;
+    private Object propagationId;
+
+    this( Object source, String propertyName, Object oldValue, Object newValue) {
+        super( source );
+        this.propertyName = propertyName;
+        this.oldValue = oldValue;
+        this.newValue = newValue;
+    }
+    Object getNewValue(){
+        return newValue;
+    }
+    Object getOldValue(){
+        return oldValue;
+    }
+    Object getPropagationId(){
+        return propagationId;
+    }
+    String getPropertyName(){
+        return propertyName;
+    }
+    void setPropagationId(Object propagationId){
+        this.propagationId = propagationId;
+    }
+    public override String toString() {
+        return this.classinfo.name ~ "[source=" ~ source.toString() ~ "]";
+    }
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/beans/PropertyChangeListener.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,9 @@
+module java.beans.PropertyChangeListener;
+
+import java.lang.all;
+import java.beans.PropertyChangeEvent;
+
+interface PropertyChangeListener {
+    void   propertyChange(PropertyChangeEvent evt);
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/beans/PropertyChangeSupport.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,67 @@
+module java.beans.PropertyChangeSupport;
+
+import java.lang.all;
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeEvent;
+
+version(Tango){
+    static import tango.core.Array;
+} else { // Phobos
+
+}
+class PropertyChangeSupport {
+    PropertyChangeListener[][ String ] listeners;
+    Object obj;
+    this(Object obj){
+        this.obj = obj;
+    }
+    void addPropertyChangeListener(PropertyChangeListener listener){
+        addPropertyChangeListener( "", listener );
+    }
+    void addPropertyChangeListener(String propertyName, PropertyChangeListener listener){
+        PropertyChangeListener[] list;
+        if( auto l = propertyName in listeners ){
+            list = *l;
+        }
+        list ~= listener;
+        listeners[ propertyName.dup ] = list;
+    }
+    void firePropertyChange(String propertyName, bool oldValue, bool newValue){
+        firePropertyChange( propertyName, Boolean.valueOf(oldValue), Boolean.valueOf(newValue) );
+    }
+    void firePropertyChange(String propertyName, int oldValue, int newValue){
+        firePropertyChange( propertyName, new Integer(oldValue), new Integer(newValue) );
+    }
+    void firePropertyChange(String propertyName, Object oldValue, Object newValue){
+        PropertyChangeListener[] list;
+        if( auto l = propertyName in listeners ){
+            list = *l;
+        }
+        auto evt = new PropertyChangeEvent( obj, propertyName, oldValue, newValue );
+        foreach( listener; list ){
+            if( listener ){
+                listener.propertyChange( evt );
+            }
+        }
+    }
+    void removePropertyChangeListener(PropertyChangeListener listener){
+        removePropertyChangeListener( "", listener );
+    }
+    void removePropertyChangeListener(String propertyName, PropertyChangeListener listener){
+        if( auto list = propertyName in listeners ){
+            version(Tango){
+                list.length = tango.core.Array.remove( *list, listener );
+            } else {
+                implMissing( __FILE__, __LINE__ );
+            }
+            if( list.length > 0 ){
+                listeners[ propertyName.dup ] = *list;
+            }
+            else{
+                listeners.remove( propertyName );
+            }
+        }
+    }
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/BufferedInputStream.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,107 @@
+/**
+ * Authors: Frank Benoit <keinfarbton@googlemail.com>
+ */
+module java.io.BufferedInputStream;
+
+import java.io.InputStream;
+import java.lang.all;
+
+public class BufferedInputStream : java.io.InputStream.InputStream {
+
+    alias java.io.InputStream.InputStream.read read;
+
+    private const int defaultSize = 8192;
+    protected byte[] buf;
+    protected int count = 0; /// The index one greater than the index of the last valid byte in the buffer.
+    protected int pos   = 0; /// The current position in the buffer.
+    protected int markpos = (-1);
+    protected int marklimit;
+    java.io.InputStream.InputStream istr;
+
+    public this ( java.io.InputStream.InputStream istr ){
+        this( istr, defaultSize );
+    }
+
+    public this ( java.io.InputStream.InputStream istr, int size ){
+        this.istr = istr;
+        if( size <= 0 ){
+            throw new IllegalArgumentException( "Buffer size <= 0" );
+        }
+        buf.length = size;
+    }
+
+    private InputStream getAndCheckIstr(){
+        InputStream res = istr;
+        if( res is null ){
+            throw new IOException( "Stream closed" );
+        }
+        return res;
+    }
+    private byte[] getAndCheckBuf(){
+        byte[] res = buf;
+        if( res is null ){
+            throw new IOException( "Stream closed" );
+        }
+        return res;
+    }
+    private void fill(){
+        assert( pos == count );
+        pos = 0;
+        count = 0;
+        count = getAndCheckIstr().read( buf );
+        if( count < 0 ){
+            count = 0;
+            istr = null;
+        }
+    }
+    public synchronized int read(){
+        if( pos >= count ){
+            fill();
+            if( pos >= count ){
+                return -1;
+            }
+        }
+        return getAndCheckBuf()[pos++] & 0xFF;
+    }
+
+    public synchronized int read( byte[] b, int off, int len ){
+        return super.read( b, off, len );
+    }
+
+    public synchronized long skip( long n ){
+        return this.istr.skip(n);
+    }
+
+    public synchronized int available(){
+        int istr_avail = 0;
+        if( istr !is null ){
+            istr_avail = istr.available();
+        }
+        return istr_avail + (count - pos);
+    }
+
+    public synchronized void mark( int readlimit ){
+        implMissing( __FILE__, __LINE__ );
+        this.istr.mark( readlimit );
+    }
+
+    public synchronized void reset(){
+        implMissing( __FILE__, __LINE__ );
+        this.istr.reset();
+    }
+
+    public bool markSupported(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public void close(){
+        if (this.istr !is null) {
+            this.istr.close();
+        }
+    }
+
+
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/BufferedReader.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,24 @@
+module java.io.BufferedReader;
+
+import java.lang.all;
+import java.io.Reader;
+
+class BufferedReader : Reader {
+    this(Reader reader){
+        implMissing(__FILE__,__LINE__);
+    }
+    public override int read(char[] cbuf, int off, int len){
+        implMissing(__FILE__,__LINE__);
+        return 0;
+    }
+    public override void  close(){
+        implMissing(__FILE__,__LINE__);
+    }
+    public String  readLine() {
+        implMissing(__FILE__,__LINE__);
+        return null;
+    }
+}
+
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/ByteArrayInputStream.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,70 @@
+/* language convertion www.dsource.org/project/tioport */
+module java.io.ByteArrayInputStream;
+
+import java.io.InputStream;
+
+public class ByteArrayInputStream : java.io.InputStream.InputStream {
+
+    alias java.io.InputStream.InputStream.read read;
+    alias java.io.InputStream.InputStream.skip skip;
+    alias java.io.InputStream.InputStream.available available;
+    alias java.io.InputStream.InputStream.close close;
+    alias java.io.InputStream.InputStream.mark mark;
+    alias java.io.InputStream.InputStream.reset reset;
+    alias java.io.InputStream.InputStream.markSupported markSupported;
+
+    protected byte[] buf;
+    protected int pos;
+    protected int fld_mark = 0;
+    //protected int count;
+    public this ( byte[] aBuf ){
+        this.buf = aBuf;
+    }
+
+    public this ( byte[] aBuf, int offset, int length_ESCAPE ){
+        this.buf = aBuf[ offset .. offset+length_ESCAPE ];
+    }
+
+    public synchronized int read(){
+        if( pos >= this.buf.length ){
+            return -1;
+        }
+        int result = this.buf[pos];
+        pos++;
+        return result & 0xFF;
+    }
+
+    public synchronized int read( byte[] b, int off, int len ){
+        return super.read( b, off, len );
+    }
+
+    public synchronized long skip( long n ){
+        pos += n;
+        return 0L;
+    }
+
+    public synchronized int available(){
+        if( pos >= this.buf.length ){
+            return 0;
+        }
+        return this.buf.length - pos;
+    }
+
+    public bool markSupported(){
+        return false;
+    }
+
+    public void mark( int readAheadLimit ){
+    }
+
+    public synchronized void reset(){
+        pos = 0;
+    }
+
+    public void close(){
+    }
+
+
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/ByteArrayOutputStream.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,105 @@
+/**
+ * Authors: Frank Benoit <keinfarbton@googlemail.com>
+ */
+module java.io.ByteArrayOutputStream;
+
+public import java.io.OutputStream;
+import java.lang.all;
+
+version(Tango){
+    import tango.io.device.Array;
+} else { // Phobos
+}
+
+public class ByteArrayOutputStream : java.io.OutputStream.OutputStream {
+
+    version(Tango){
+        protected Array buffer;
+    } else { // Phobos
+    }
+
+    public this (){
+        version(Tango){
+            buffer = new Array();
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+
+    public this ( int par_size ){
+        version(Tango){
+            buffer = new Array(par_size);
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+
+    public synchronized override void write( int b ){
+        version(Tango){
+            byte[1] a;
+            a[0] = b & 0xFF;
+            buffer.append(a);
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+
+    public synchronized override void write( byte[] b, int off, int len ){
+        version(Tango){
+            buffer.append( b[ off .. off + len ]);
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+
+    public synchronized override void write( byte[] b ){
+        version(Tango){
+            buffer.append( b );
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+
+    public synchronized void writeTo( java.io.OutputStream.OutputStream out_KEYWORDESCAPE ){
+        implMissing( __FILE__, __LINE__ );
+    }
+
+    public synchronized void reset(){
+        implMissing( __FILE__, __LINE__ );
+    }
+
+    public synchronized byte[] toByteArray(){
+        version(Tango){
+            return cast(byte[])buffer.slice();
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+            return null;
+        }
+    }
+
+    public int size(){
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+
+    public override String toString(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public String toString( String enc ){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public String toString( int hibyte ){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public  override void close(){
+        implMissing( __FILE__, __LINE__ );
+    }
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/File.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,263 @@
+/**
+ * Authors: Frank Benoit <keinfarbton@googlemail.com>
+ */
+module java.io.File;
+
+import java.lang.all;
+
+version(Tango){
+    static import tango.io.model.IFile;
+    static import tango.io.FilePath;
+    static import tango.io.Path;
+    static import tango.io.FileSystem;
+} else { // Phobos
+    static import std.file;
+    static import std.path;
+}
+
+public class File {
+
+    public static char separatorChar;
+    public static String separator;
+    public static char pathSeparatorChar;
+    public static String pathSeparator;
+
+    private String mFilePath;
+
+    static this(){
+        version(Tango){
+            separator = tango.io.model.IFile.FileConst.PathSeparatorString;
+            separatorChar = tango.io.model.IFile.FileConst.PathSeparatorChar;
+            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 = ':';
+            }
+        }
+    }
+
+    private static String toStd( String path ){
+        version(Tango){
+            return tango.io.Path.standard( path );
+        } else { // Phobos
+            return path;
+        }
+    }
+    private static String join( String path, String file ){
+        version(Tango){
+            return tango.io.Path.join( path, file );
+        } else { // Phobos
+            return std.path.join( path, file );
+        }
+    }
+
+    public this ( String pathname ){
+        mFilePath = toStd( pathname );
+    }
+
+    public this ( String parent, String child ){
+        mFilePath = join( toStd(parent), toStd(child) );
+    }
+
+    public this ( java.io.File.File parent, String child ){
+        mFilePath = join( parent.mFilePath, toStd(child) );
+    }
+
+    public int getPrefixLength(){
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+
+    public String getName(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public String getParent(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public java.io.File.File getParentFile(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public String getPath(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public bool isAbsolute(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public String getAbsolutePath(){
+        version(Tango){
+            return tango.io.FileSystem.FileSystem.toAbsolute( mFilePath );
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+            return "";
+        }
+    }
+
+    public java.io.File.File getAbsoluteFile(){
+        version(Tango){
+            return new File( getAbsolutePath() );
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+            return null;
+        }
+    }
+
+    public String getCanonicalPath(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public java.io.File.File getCanonicalFile(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public bool canRead(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public bool canWrite(){
+        version(Tango){
+            return tango.io.Path.isWritable(mFilePath);
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+            return false;
+        }
+    }
+
+    public bool exists(){
+        version(Tango){
+            return tango.io.Path.exists(mFilePath);
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+            return false;
+        }
+    }
+
+    public bool isDirectory(){
+        version(Tango){
+            return tango.io.Path.isFolder(mFilePath);
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+            return false;
+        }
+    }
+
+    public bool isFile(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public bool isHidden(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public long lastModified(){
+        implMissing( __FILE__, __LINE__ );
+        return 0L;
+    }
+
+    public long length(){
+        implMissing( __FILE__, __LINE__ );
+        return 0L;
+    }
+
+    public bool createNewFile(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public bool delete_KEYWORDESCAPE(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public void deleteOnExit(){
+        implMissing( __FILE__, __LINE__ );
+    }
+
+    public String[] list(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public java.io.File.File[] listFiles(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public bool mkdir(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public bool mkdirs(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public bool renameTo( java.io.File.File dest ){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public bool setLastModified( long time ){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public bool setReadOnly(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+    public static java.io.File.File[] listRoots(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    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( String prefix, String suffix ){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+    public int compareTo( java.io.File.File pathname ){
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+
+    public String toString(){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+
+
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/FileInputStream.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,97 @@
+/**
+ * Authors: Frank Benoit <keinfarbton@googlemail.com>
+ */
+module java.io.FileInputStream;
+
+import java.lang.all;
+import java.io.File;
+import java.io.InputStream;
+
+version(Tango){
+    import TangoFile = tango.io.device.File;
+} else { // Phobos
+}
+
+public class FileInputStream : java.io.InputStream.InputStream {
+
+    alias java.io.InputStream.InputStream.read read;
+
+    version(Tango){
+        private TangoFile.File conduit;
+    } else { // Phobos
+    }
+    private ubyte[] buffer;
+    private int buf_pos;
+    private int buf_size;
+    private const int BUFFER_SIZE = 0x10000;
+    private bool eof;
+
+    public this ( String name ){
+        version(Tango){
+            conduit = new TangoFile.File( name );
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+        buffer = new ubyte[]( BUFFER_SIZE );
+    }
+
+    public this ( java.io.File.File file ){
+        implMissing( __FILE__, __LINE__ );
+        version(Tango){
+            conduit = new TangoFile.File( file.getAbsolutePath(), TangoFile.File.ReadExisting );
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+        buffer = new ubyte[]( BUFFER_SIZE );
+    }
+
+    public override int read(){
+        version(Tango){
+            if( eof ){
+                return -1;
+            }
+            try{
+                if( buf_pos == buf_size ){
+                    buf_pos = 0;
+                    buf_size = conduit.input.read( buffer );
+                }
+                if( buf_size <= 0 ){
+                    eof = true;
+                    return -1;
+                }
+                assert( buf_pos < BUFFER_SIZE, Format( "{0} {1}", buf_pos, buf_size ) );
+                assert( buf_size <= BUFFER_SIZE );
+                int res = cast(int) buffer[ buf_pos ];
+                buf_pos++;
+                return res;
+            }
+            catch( IOException e ){
+                eof = true;
+                return -1;
+            }
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+            return 0;
+        }
+    }
+
+    public long skip( long n ){
+        implMissing( __FILE__, __LINE__ );
+        return 0L;
+    }
+
+    public int available(){
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+
+    public override void close(){
+        version(Tango){
+            conduit.close();
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/FileOutputStream.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,76 @@
+/**
+ * Authors: Frank Benoit <keinfarbton@googlemail.com>
+ */
+module java.io.FileOutputStream;
+
+public import java.io.File;
+public import java.io.OutputStream;
+
+import java.lang.all;
+
+version(Tango){
+    import TangoFile = tango.io.device.File;
+} else { // Phobos
+    static import std.file;
+    static import std.path;
+}
+
+public class FileOutputStream : java.io.OutputStream.OutputStream {
+
+    alias java.io.OutputStream.OutputStream.write write;
+    alias java.io.OutputStream.OutputStream.close close;
+    version(Tango){
+        TangoFile.File fc;
+    } else { // Phobos
+    }
+
+    public this ( String name ){
+        version(Tango){
+            fc = new TangoFile.File( name, TangoFile.File.WriteCreate );
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+
+    public this ( String name, bool append ){
+        version(Tango){
+            fc = new TangoFile.File( name, append ? TangoFile.File.WriteAppending : TangoFile.File.WriteCreate );
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+
+    public this ( java.io.File.File file ){
+        this( file.toString );
+    }
+
+    public this ( java.io.File.File file, bool append ){
+        this( file.toString, append );
+    }
+
+    public override void write( int b ){
+        ubyte[1] a;
+        a[0] = b & 0xFF;
+        version(Tango){
+            fc.write(a);
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+
+    public override void close(){
+        version(Tango){
+            fc.close();
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+
+    public void finalize(){
+        implMissing( __FILE__, __LINE__ );
+    }
+
+
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/InputStream.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,61 @@
+/**
+ * Authors: Frank Benoit <keinfarbton@googlemail.com>
+ */
+
+module java.io.InputStream;
+
+import java.lang.all;
+
+public abstract class InputStream {
+
+
+    public this (){
+    }
+
+    public abstract int read();
+
+    public int read( byte[] b ){
+        foreach( uint idx, inout byte val; b ){
+            int c = read();
+            if( c == -1 ){
+                return ( idx == 0 ) ? -1 : idx;
+            }
+            b[ idx] = cast(byte)( c & 0xFF );
+        }
+        return b.length;
+    }
+
+    public int read( byte[] b, int off, int len ){
+        return read( b[ off .. off+len ] );
+    }
+
+    public long skip( long n ){
+        implMissing( __FILE__, __LINE__ );
+        return 0L;
+    }
+
+    public int available(){
+        return 0;
+    }
+
+    public void close(){
+        implMissing( __FILE__, __LINE__ );
+    }
+
+    public synchronized void mark( int readlimit ){
+        implMissing( __FILE__, __LINE__ );
+    }
+
+    public synchronized void reset(){
+        implMissing( __FILE__, __LINE__ );
+    }
+
+    public bool markSupported(){
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+
+
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/OutputStream.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,32 @@
+/**
+ * Authors: Frank Benoit <keinfarbton@googlemail.com>
+ */
+module java.io.OutputStream;
+
+import java.lang.all;
+
+public abstract class OutputStream {
+
+    public this(){
+    }
+
+    public abstract void write( int b );
+
+    public void write( byte[] b ){
+        foreach( bv; b ){
+            write(bv);
+        }
+    }
+
+    public void write( byte[] b, int off, int len ){
+        write(b[off .. off+len]);
+    }
+
+    public void flush(){
+    }
+
+    public void close(){
+    }
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/PushbackReader.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,23 @@
+module java.io.PushbackReader;
+
+import java.lang.all;
+import java.io.Reader;
+
+class PushbackReader : Reader {
+
+    this( Reader reader ){
+        implMissing(__FILE__,__LINE__);
+    }
+    void unread( char c ){
+        implMissing(__FILE__,__LINE__);
+    }
+    int read(char[] cbuf, int off, int len){
+        implMissing(__FILE__,__LINE__);
+        return 0;
+    }
+    void  close(){
+        implMissing(__FILE__,__LINE__);
+    }
+
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/Reader.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,41 @@
+module java.io.Reader;
+
+import java.lang.util;
+
+class Reader{
+    protected Object   lock;
+    protected this(){
+        implMissing(__FILE__,__LINE__);
+    }
+    protected this(Object lock){
+        implMissing(__FILE__,__LINE__);
+    }
+    abstract  void  close();
+    void mark(int readAheadLimit){
+        implMissing(__FILE__,__LINE__);
+    }
+    bool markSupported(){
+        implMissing(__FILE__,__LINE__);
+        return false;
+    }
+    int read(){
+        implMissing(__FILE__,__LINE__);
+        return 0;
+    }
+    int read(char[] cbuf){
+        implMissing(__FILE__,__LINE__);
+        return 0;
+    }
+    abstract int read(char[] cbuf, int off, int len);
+    bool ready(){
+        implMissing(__FILE__,__LINE__);
+        return false;
+    }
+    void reset(){
+        implMissing(__FILE__,__LINE__);
+    }
+    long skip(long n){
+        implMissing(__FILE__,__LINE__);
+        return 0;
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/StringReader.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,20 @@
+module java.io.StringReader;
+
+import java.lang.all;
+import java.io.Reader;
+
+class StringReader : Reader {
+    String str;
+    this( String str ){
+        implMissing(__FILE__,__LINE__);
+        this.str = str;
+    }
+    public override int read(char[] cbuf, int off, int len){
+        cbuf[ off .. off+len ] = str[ 0 .. len ];
+        str = str[ len .. $ ];
+        return len;
+    }
+    public override void  close(){
+    }
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/StringWriter.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,9 @@
+module java.io.StringWriter;
+
+import java.lang.all;
+import java.io.Writer;
+
+class StringWriter : Writer {
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/io/Writer.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,5 @@
+module java.io.Writer;
+
+class Writer{
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/Boolean.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,54 @@
+module java.lang.Boolean;
+
+import java.lang.util;
+import java.lang.System;
+
+version(Tango){
+    static import tango.text.Ascii;
+} else { // Phobos
+    static import std.string;
+}
+class Boolean : ValueWrapperT!(bool) {
+    public static Boolean TRUE;
+    public static Boolean FALSE;
+
+    static this(){
+        TRUE  = new Boolean(true);
+        FALSE = new Boolean(false);
+    }
+    public this( bool v ){
+        super(v);
+    }
+
+    alias ValueWrapperT!(bool).opEquals opEquals;
+    public equals_t opEquals( int other ){
+        return value == ( other !is 0 );
+    }
+    public equals_t opEquals( Object other ){
+        if( auto o = cast(Boolean)other ){
+            return value == o.value;
+        }
+        return false;
+    }
+    public bool booleanValue(){
+        return value;
+    }
+    public static Boolean valueOf( String s ){
+        if( s == "yes" || s == "true" ){
+            return TRUE;
+        }
+        return FALSE;
+    }
+    public static Boolean valueOf( bool b ){
+        return b ? TRUE : FALSE;
+    }
+    public static bool getBoolean(String name){
+        version(Tango){
+            return tango.text.Ascii.icompare(System.getProperty(name, "false"), "true" ) is 0;
+        } else { // Phobos
+            return std.string.icmp(System.getProperty(name, "false"), "true" ) is 0;
+        }
+    }
+}
+
+alias Boolean    ValueWrapperBool;

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/Byte.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,38 @@
+module java.lang.Byte;
+
+import java.lang.util;
+import java.lang.exceptions;
+
+version(Tango){
+    static import tango.text.convert.Integer;
+} else { // Phobos
+}
+class Byte : ValueWrapperT!(byte) {
+    public static byte parseByte( String s ){
+        version(Tango){
+            try{
+                int res = tango.text.convert.Integer.parse( s );
+                if( res < byte.min || res > byte.max ){
+                    throw new NumberFormatException( "out of range" );
+                }
+                return res;
+            }
+            catch( IllegalArgumentException e ){
+                throw new NumberFormatException( e );
+            }
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__);
+            return 0;
+        }
+    }
+    this( byte value ){
+        super( value );
+    }
+
+    public static String toString( byte i ){
+        return String_valueOf(i);
+    }
+
+}
+alias Byte ValueWrapperByte;
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/Character.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,197 @@
+module java.lang.Character;
+
+import java.lang.exceptions;
+import java.lang.util;
+
+version(Tango){
+    static import tango.text.Unicode;
+} else { // Phobos
+    static import std.utf;
+    static import std.uni;
+    static import std.ctype;
+    static import std.string;
+}
+
+class Character {
+    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 );
+        } else { // Phobos
+            wchar[1] src;
+            src[0] = c;
+            auto darr = std.utf.toUTF32(src);
+        }
+        return toUpperCase( darr[0] );
+    }
+    public static dchar toUpperCase( dchar c ){
+        version(Tango){
+            dchar[1] src;
+            src[0] = c;
+            dchar[] r = tango.text.Unicode.toUpper( src );
+            return r[0];
+        } else { // Phobos
+            return std.uni.toUniUpper( c );
+        }
+    }
+    public static dchar toLowerCase( 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 );
+        } else { // Phobos
+            wchar[1] src;
+            src[0] = c;
+            auto darr = std.utf.toUTF32(src);
+        }
+        return toLowerCase( darr[0] );
+    }
+    public static dchar toLowerCase( dchar c ){
+        version(Tango){
+            dchar[1] src;
+            src[0] = c;
+            dchar[] r = tango.text.Unicode.toLower( src );
+            return r[0];
+        } else { // Phobos
+            return std.uni.toUniLower( c );
+        }
+    }
+    public static bool isWhitespace( dchar c ){
+        version(Tango){
+            return tango.text.Unicode.isWhitespace( c );
+        } else { // Phobos
+            return std.string.iswhite(c);
+        }
+    }
+    public static bool isDigit( dchar c ){
+        version(Tango){
+            return tango.text.Unicode.isDigit( c );
+        } else { // Phobos
+            return cast(bool)std.ctype.isdigit(c);
+        }
+    }
+    public static bool isLetter( dchar c ){
+        version(Tango){
+            return tango.text.Unicode.isLetter(c);
+        } else { // Phobos
+            return cast(bool)std.ctype.isalpha(c);
+        }
+    }
+    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);
+        }
+    }
+    public static bool isLetterOrDigit( dchar c ){
+        return isDigit(c) || isLetter(c);
+    }
+    public static bool isUnicodeIdentifierPart(char ch){
+        implMissing( __FILE__, __LINE__);
+        return false;
+    }
+    public static bool isUnicodeIdentifierStart(char ch){
+        implMissing( __FILE__, __LINE__);
+        return false;
+    }
+    public static bool isIdentifierIgnorable(char ch){
+        implMissing( __FILE__, __LINE__);
+        return false;
+    }
+    public static bool isJavaIdentifierPart(char ch){
+        implMissing( __FILE__, __LINE__);
+        return false;
+    }
+
+    this( char c ){
+        // must be correct for container storage
+        implMissing( __FILE__, __LINE__);
+    }
+}
+
+bool CharacterIsDefined( dchar ch ){
+    version(Tango){
+        return (ch in tango.text.UnicodeData.unicodeData) !is null;
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__);
+        return false;
+    }
+}
+
+dchar CharacterFirstToLower( String str ){
+    int consumed;
+    return CharacterFirstToLower( str, consumed );
+}
+
+dchar CharacterFirstToLower( String 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;
+    }
+}
+
+dchar CharacterToLower( dchar c ){
+    version(Tango){
+        dchar[] r = tango.text.Unicode.toLower( [c] );
+        return r[0];
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__);
+        return 0;
+    }
+}
+dchar CharacterToUpper( dchar c ){
+    version(Tango){
+        dchar[] r = tango.text.Unicode.toUpper( [c] );
+        return r[0];
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__);
+        return 0;
+    }
+}
+bool CharacterIsWhitespace( dchar c ){
+    version(Tango){
+        return tango.text.Unicode.isWhitespace( c );
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__);
+        return false;
+    }
+}
+bool CharacterIsDigit( dchar c ){
+    version(Tango){
+        return tango.text.Unicode.isDigit( c );
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__);
+        return false;
+    }
+}
+bool CharacterIsLetter( dchar c ){
+    version(Tango){
+        return tango.text.Unicode.isLetter( c );
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__);
+        return false;
+    }
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/Double.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,26 @@
+module java.lang.Double;
+
+import java.lang.util;
+
+class Double : ValueWrapperT!(double) {
+    public static double MAX_VALUE = double.max;
+    public static double MIN_VALUE = double.min;
+    this( double value ){
+        super(value);
+    }
+    this( String str ){
+        implMissing( __FILE__, __LINE__ );
+        super(0.0);
+    }
+    public double doubleValue(){
+        return value;
+    }
+    public static String toString( double value ){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+    public static double parseDouble(String s){
+        implMissing( __FILE__, __LINE__ );
+        return 0.0;
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/Float.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,43 @@
+module java.lang.Float;
+
+import java.lang.util;
+import java.lang.exceptions;
+
+class Float : ValueWrapperT!(float) {
+
+    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 MAX_VALUE = 3.4028235e+38f;
+    public static float MIN_VALUE = 1.4e-45f;
+    public static int SIZE = 32;
+
+    this( float value ){
+        super(value);
+    }
+    this( String str ){
+        implMissing( __FILE__, __LINE__ );
+        super(0.0);
+    }
+    public float floatValue(){
+        return value;
+    }
+    public static String toString( float value ){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+    public static float parseFloat( String s ){
+        version(Tango){
+            try{
+                return tango.text.convert.Float.toFloat( s );
+            }
+            catch( IllegalArgumentException e ){
+                throw new NumberFormatException( e );
+            }
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+            return 0.0f;
+        }
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/Integer.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,144 @@
+module java.lang.Integer;
+
+import java.lang.util;
+import java.lang.exceptions;
+
+version(Tango){
+} else { // Phobos
+}
+
+version(Tango){
+} else { // Phobos
+}
+
+
+class Integer : ValueWrapperT!(int) {
+
+    public static const int MIN_VALUE = 0x80000000;
+    public static const int MAX_VALUE = 0x7fffffff;
+    public static const int SIZE = 32;
+
+    public this ( int value ){
+        super( value );
+    }
+
+    public this ( String s ){
+        super(parseInt(s));
+    }
+
+    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;
+        }
+    }
+
+    public static String toHexString( int i ){
+        version(Tango){
+            return tango.text.convert.Integer.toString(i, "x" );
+        } else { // Phobos
+            return std.string.toString( cast(long)i, 16u );
+        }
+    }
+
+    public static String toOctalString( int i ){
+        version(Tango){
+            return tango.text.convert.Integer.toString(i, "o" );
+        } else { // Phobos
+            return std.string.toString( cast(long)i, 8u );
+        }
+    }
+
+    public static String toBinaryString( int i ){
+        version(Tango){
+            return tango.text.convert.Integer.toString(i, "b" );
+        } else { // Phobos
+            return std.string.toString( cast(long)i, 2u );
+        }
+    }
+
+    public static String toString( int i ){
+        version(Tango){
+            return tango.text.convert.Integer.toString(i);
+        } else { // Phobos
+            return std.string.toString( i );
+        }
+    }
+
+    public static int parseInt( String s, int radix ){
+        version(Tango){
+            try{
+                return tango.text.convert.Integer.toLong( s, radix );
+            }
+            catch( IllegalArgumentException e ){
+                throw new NumberFormatException( e );
+            }
+        } else { // Phobos
+            implMissing( __FILE__, __LINE__ );
+            return 0;
+        }
+    }
+
+    public static int parseInt( String s ){
+        return parseInt( s, 10 );
+    }
+
+    public static Integer valueOf( String s, int radix ){
+        return new Integer( parseInt( s, radix ));
+    }
+
+    public static Integer valueOf( String s ){
+        return valueOf( parseInt(s));
+    }
+
+    public static Integer valueOf( int i ){
+        return new Integer(i);
+    }
+
+    public byte byteValue(){
+        return cast(byte)value;
+    }
+
+    public short shortValue(){
+        return cast(short)value;
+    }
+
+    public int intValue(){
+        return value;
+    }
+
+    public long longValue(){
+        return cast(long)value;
+    }
+
+    public float floatValue(){
+        return cast(float)value;
+    }
+
+    public double doubleValue(){
+        return cast(double)value;
+    }
+
+    public override  hash_t toHash(){
+        return intValue();
+    }
+
+    public override String toString(){
+        version(Tango){
+            return tango.text.convert.Integer.toString( value );
+        } else { // Phobos
+            return std.string.toString(value);
+        }
+    }
+}
+alias Integer ValueWrapperInt;
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/Long.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,28 @@
+module java.lang.Long;
+
+import java.lang.util;
+
+class Long : ValueWrapperT!(long) {
+    public static const long MIN_VALUE = long.min;
+    public static const long MAX_VALUE = long.max;
+    this( long value ){
+        super(value);
+    }
+    this( String str ){
+        implMissing( __FILE__, __LINE__ );
+        super(0);
+    }
+    public long longValue(){
+        return value;
+    }
+    public static long parseLong(String s){
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+    public static String toString( double value ){
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+alias Long ValueWrapperLong;
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/Math.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,67 @@
+module java.lang.Math;
+
+version(Tango){
+    static import tango.math.Math;
+    alias tango.math.Math MathLib;
+} else {
+    static import std.math;
+    alias std.math MathLib;
+}
+
+class Math {
+
+    public const double PI = MathLib.PI;
+
+    static double abs(double a){ return a > 0 ? a : -a; }
+    static float  abs(float  a){ return a > 0 ? a : -a; }
+    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 int    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 int    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 double sin(double a)  { return MathLib.sin(a); }
+    static double cos(double a)  { return MathLib.cos(a); }
+
+    static long   round(double a) { return cast(long)MathLib.round(a); }
+    static int    round(float a)  { return cast(int)MathLib.round(a); }
+    static int    round(int a)  { return a; }
+    static double rint(double a) {
+        version(Tango) return MathLib.rndint(a);
+        else           return MathLib.rint(a);
+    }
+    static double ceil(double a) { return MathLib.ceil(a); }
+    static double floor(double a) { return MathLib.floor(a); }
+    static double sqrt(double a) { return MathLib.sqrt(a); }
+    static double atan2(double a, double b) { return MathLib.atan2(a,b); }
+    static double pow(double a, double b) { return MathLib.pow(a, b); }
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/Runnable.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,49 @@
+/**
+ * Authors: Frank Benoit <benoit@tionex.de>
+ */
+module java.lang.Runnable;
+
+version(Tango){
+    import tango.core.Tuple;
+    import tango.core.Traits;
+} else { // Phobos
+    static import std.traits;
+    static import std.typetuple;
+}
+
+public interface Runnable  {
+
+    public abstract void run();
+
+}
+
+class _DgRunnableT(Dg,T...) : Runnable {
+
+    version(Tango){
+        alias ParameterTupleOf!(Dg) DgArgs;
+        static assert( is(DgArgs == Tuple!(T)),
+                "Delegate args not correct: "~DgArgs.stringof~" vs "~T.stringof );
+    } else { // Phobos
+        alias std.traits.ParameterTypeTuple!(Dg) DgArgs;
+        static assert( is(DgArgs == std.typetuple.TypeTuple!(T)),
+                "Delegate args not correct: "~DgArgs.stringof~" vs "~T.stringof );
+    }
+
+    Dg dg;
+    T t;
+
+    private this( Dg dg, T t ){
+        this.dg = dg;
+        static if( T.length > 0 ){
+            this.t = t;
+        }
+    }
+
+    void run( ){
+        dg(t);
+    }
+}
+
+_DgRunnableT!(Dg,T) dgRunnable(Dg,T...)( Dg dg, T args ){
+    return new _DgRunnableT!(Dg,T)(dg,args);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/String.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,781 @@
+module java.lang.String;
+
+import java.lang.util;
+import java.lang.interfaces;
+import java.lang.exceptions;
+
+version(Tango){
+    static import tango.stdc.stringz;
+    static import tango.text.Util;
+    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.string;
+}
+
+version(Tango){
+    alias char[] String;
+    alias char[] CString;
+    alias wchar[] CString16;
+} else { // Phobos
+    alias string String;
+    alias wstring String16;
+    mixin("alias const(char)[] CString;");
+    mixin("alias const(wchar)[] CString16;");
+}
+
+int codepointIndexToIndex( String 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( String 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;
+}
+
+/++
++ Get that String, that contains the next codepoint of a String.
++/
+String firstCodePointStr( String 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( String str ){
+    int dummy;
+    return firstCodePoint( str, dummy );
+}
+dchar firstCodePoint( String 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
+        implMissing( __FILE__, __LINE__ );
+        return '\0';
+    }
+}
+dchar firstCodePoint( wchar[] 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
+        implMissing( __FILE__, __LINE__ );
+        return '\0';
+    }
+}
+
+String dcharToString( dchar key ){
+    version(Tango){
+        dchar[1] buf;
+        buf[0] = key;
+        return tango.text.convert.Utf.toString( buf );
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+int codepointCount( String 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
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+}
+
+//alias tango.text.convert.Utf.toString16 toString16;
+//alias tango.text.convert.Utf.toString toString;
+
+int toAbsoluteCodePointStartOffset( String 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( String str, int startIndex, int searchRelCp ){
+    return getAbsoluteCodePointOffset( str, startIndex, searchRelCp ) - startIndex;
+}
+int getAbsoluteCodePointOffset( String 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( wchar[] 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( String str, int startIndex, int searchRelCp ){
+    int dummy;
+    return getRelativeCodePoint( str, startIndex, dummy );
+}
+dchar getRelativeCodePoint( String str, int startIndex, int searchRelCp, out int relIndex ){
+    relIndex = getRelativeCodePointOffset( str, startIndex, searchRelCp );
+    int ignore;
+    return firstCodePoint( str[ startIndex+relIndex .. $ ], ignore );
+}
+
+int utf8AdjustOffset( String str, int offset ){
+    if( str.length <= offset || offset <= 0 ){
+        return offset;
+    }
+    while(( str[offset] & 0xC0 ) is 0x80 ){
+        offset--;
+    }
+    return offset;
+}
+int utf8OffsetIncr( String 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( String 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( String cont, int offset, int len ){
+    version(D_Version2){
+        return cont[ offset .. offset+len ].idup;
+    } else {
+        return cont[ offset .. offset+len ].dup;
+    }
+}
+
+String new_String( String cont ){
+    version(D_Version2){
+        return cont.idup;
+    } else {
+        return cont.dup;
+    }
+}
+
+String String_valueOf( bool v ){
+    return v ? "true" : "false";
+}
+
+String String_valueOf( byte v ){
+    version(Tango){
+        return tango.text.convert.Integer.toString(v);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+String String_valueOf( ubyte v ){
+    version(Tango){
+        return tango.text.convert.Integer.toString(v);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+String String_valueOf( short v ){
+    version(Tango){
+        return tango.text.convert.Integer.toString(v);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+String String_valueOf( int v ){
+    version(Tango){
+        return tango.text.convert.Integer.toString(v);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+String String_valueOf( uint v ){
+    version(Tango){
+        return tango.text.convert.Integer.toString(v);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+String String_valueOf( long v ){
+    version(Tango){
+        return tango.text.convert.Integer.toString(v);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+String String_valueOf( float v ){
+    version(Tango){
+        return tango.text.convert.Float.toString(v);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+String String_valueOf( double v ){
+    version(Tango){
+        return tango.text.convert.Float.toString(v);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+String String_valueOf( dchar v ){
+    return dcharToString(v);
+}
+
+String String_valueOf( char[] v ){
+    version(D_Version2){
+        return v.idup;
+    } else {
+        return v.dup;
+    }
+}
+
+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;
+    }
+}
+
+String String_valueOf( Object v ){
+    return v is null ? "null" : v.toString();
+}
+
+String String_valueOf( wchar[] wstr ){
+    version(Tango){
+        return tango.text.convert.Utf.toString(wstr);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+int length( String str ){
+    return str.length;
+}
+
+/// Extension to String
+public String toUpperCase( String str ){
+    version(Tango){
+        return tango.text.Unicode.toUpper( str );
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+/// Extension to String
+public String replaceFirst( String str, String regex, String replacement ){
+    implMissing(__FILE__,__LINE__);
+    return str;
+}
+
+/// Extension to String
+public int indexOf( String str, char searched ){
+    version(Tango){
+        int res = tango.text.Util.locate( str, searched );
+        if( res is str.length ) res = -1;
+        return res;
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+}
+
+/// Extension to String
+public int indexOf( String str, char searched, int startpos ){
+    version(Tango){
+        int res = tango.text.Util.locate( str, searched, startpos );
+        if( res is str.length ) res = -1;
+        return res;
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+}
+
+/// Extension to String
+public int indexOf(String str, String ch){
+    return indexOf( str, ch, 0 );
+}
+
+/// Extension to String
+public int indexOf(String str, String ch, int start){
+    version(Tango){
+        int res = tango.text.Util.locatePattern( str, ch, start );
+        if( res is str.length ) res = -1;
+        return res;
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+}
+
+/// Extension to String
+public int lastIndexOf(String str, char ch){
+    return lastIndexOf( str, ch, str.length );
+}
+
+/// Extension to String
+public int lastIndexOf(String 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
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+}
+
+/// Extension to String
+public int lastIndexOf(String str, String ch ){
+    return lastIndexOf( str, ch, str.length );
+}
+
+/// Extension to String
+public int lastIndexOf(String 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( String str, String regex, String replacement ){
+    implMissing(__FILE__,__LINE__);
+    return null;
+}
+
+/// Extension to String
+public String replace( String str, char from, char to ){
+    version(Tango){
+        return tango.text.Util.replace( str.dup, from, to );
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+/// Extension to String
+public String substring( String str, int start ){
+    return cast(String)str[ start .. $ ].dup;
+}
+
+/// Extension to String
+public String substring( String str, int start, int end ){
+    return cast(String)str[ start .. end ].dup;
+}
+
+/// Extension to String
+public wchar[] substring( wchar[] str, int start ){
+    return cast(wchar[])(str[ start .. $ ].dup);
+}
+
+/// Extension to String
+public wchar[] substring( wchar[] str, int start, int end ){
+    return str[ start .. end ].dup;
+}
+
+/// Extension to String
+public char charAt( String str, int pos ){
+    return str[ pos ];
+}
+
+/// Extension to String
+public dchar dcharAt( String 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 wchar[] toWCharArray( String str ){
+    version(Tango){
+        return tango.text.convert.Utf.toString16(str);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+/// Extension to String
+public char[] toCharArray( String str ){
+    return cast(char[])str;
+}
+
+/// Extension to String
+public bool endsWith( String src, String pattern ){
+    if( src.length < pattern.length ){
+        return false;
+    }
+    return src[ $-pattern.length .. $ ] == pattern;
+}
+
+/// Extension to String
+public bool equals( String src, String other ){
+    return src == other;
+}
+
+/// Extension to String
+public bool equalsIgnoreCase( String src, String other ){
+    version(Tango){
+        return tango.text.Unicode.toFold(src) == tango.text.Unicode.toFold(other);
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return false;
+    }
+}
+
+/// Extension to String
+public int compareToIgnoreCase( String src, String other ){
+    version(Tango){
+        return compareTo( tango.text.Unicode.toFold(src), tango.text.Unicode.toFold(other));
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return 0;
+    }
+}
+
+/// Extension to String
+public int compareTo( String src, String other ){
+    return typeid(String).compare( cast(void*)&src, cast(void*)&other );
+}
+
+/// Extension to String
+public bool startsWith( String src, String pattern ){
+    if( src.length < pattern.length ){
+        return false;
+    }
+    return src[ 0 .. pattern.length ] == pattern;
+}
+
+/// Extension to String
+public String toLowerCase( String src ){
+    version(Tango){
+        return tango.text.Unicode.toLower( src );
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+/// Extension to String
+public hash_t toHash( String src ){
+    return typeid(String).getHash(&src);
+}
+
+/// Extension to String
+public String trim( String str ){
+    version(Tango){
+        return tango.text.Util.trim( str ).dup;
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+/// Extension to String
+public String intern( String str ){
+    return str;
+}
+
+/++
+ + 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();
+    }
+    else{
+        static const char[] nullPtr = "\0";
+        return cast(char*)nullPtr.ptr;
+    }
+}
+
+version(Tango){
+    public alias tango.stdc.stringz.toStringz toStringz;
+    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( String s ){
+        implMissing(__FILE__,__LINE__);
+        return null;
+    }
+    public wchar* toString16z( String16 s ){
+        implMissing(__FILE__,__LINE__);
+        return null;
+    }
+    public char[] fromStringz( String s ){
+        implMissing(__FILE__,__LINE__);
+        return null;
+    }
+    public char[] fromString16z( String16 s ){
+        implMissing(__FILE__,__LINE__);
+        return null;
+    }
+}
+
+static String toHex(uint value, bool prefix = true, int radix = 8){
+    version(Tango){
+        return tango.text.convert.Integer.toString(
+                value,
+                radix is 10 ? "d" :
+                radix is  8 ? "o" :
+                radix is 16 ? "x" :
+                "d" );
+    } else { // Phobos
+        implMissing( __FILE__, __LINE__ );
+        return null;
+    }
+}
+
+/++
++ String in java is implementing the interface CharSequence
++/
+class StringCharSequence : CharSequence {
+    private String str;
+    this( String str ){
+        this.str = str;
+    }
+    char           charAt(int index){
+        return str[index];
+    }
+    int             length(){
+        return str.length;
+    }
+    CharSequence    subSequence(int start, int end){
+        return new StringCharSequence( str[ start .. end ]);
+    }
+    String          toString(){
+        return str;
+    }
+}
+
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/StringBuffer.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,233 @@
+module java.lang.StringBuffer;
+
+import java.lang.util;
+
+version(Tango){
+    static import tango.text.Text;
+    static import tango.text.convert.Utf;
+} else { // Phobos
+    static import std.uni;
+    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;
+    }
+
+    public this(){
+        version(Tango){
+            buf = new TBuf();
+        } else { // Phobos
+        }
+    }
+
+    public this( int cap ){
+        version(Tango){
+            buf = new TBuf(cap);
+        } else { // Phobos
+            buf.length = cap;
+        }
+    }
+
+    public this( String content ){
+        version(Tango){
+            buf = new TBuf( content );
+        } else { // Phobos
+            buf.length = content.length + STDINCR;
+            buf[ 0 .. content.length ] = content;
+            used = content.length;
+        }
+    }
+
+    char charAt(int index){
+        version(Tango){
+            return buf.slice()[ index ];
+        } else { // Phobos
+            return buf[ index ];
+        }
+    }
+
+    int length(){
+        version(Tango){
+            return buf.length();
+        } else { // Phobos
+            return used;
+        }
+    }
+
+    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 ] );
+        }
+    }
+
+    String toString(){
+        version(Tango){
+            return buf.slice();
+        } else { // Phobos
+            return cast(String)buf[ 0 .. used ];
+        }
+    }
+
+    StringBuffer append( String s ){
+        version(Tango){
+            buf.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;
+        }
+        return this;
+    }
+
+    StringBuffer append( String s, int offset, int len ){
+        return append( s[ offset .. offset+len ] );
+    }
+
+    StringBuffer append( StringBuffer other ){
+        return append( other.slice() );
+    }
+
+    StringBuffer append( Object obj ){
+        return append( obj.toString() );
+    }
+
+    StringBuffer append( char c ){
+        char[1] src;
+        src[0] = c;
+        return append( cast(String)src );
+    }
+
+    StringBuffer append( wchar c ){
+        wchar[1] src;
+        src[0] = c;
+        version(Tango){
+            char[2] trg;
+            auto arr = tango.text.convert.Utf.toString( src, trg );
+        } else { // Phobos
+            auto arr = std.utf.toUTF8( src );
+        }
+        return append( arr );
+    }
+
+    StringBuffer append( int i ){
+        return append( String_valueOf(i) );
+    }
+
+    StringBuffer append( long i ){
+        return append( String_valueOf(i) );
+    }
+
+    StringBuffer append( dchar c ){
+        dchar[1] src;
+        src[0] = c;
+        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, String str){
+        return replace( offset, offset, str );
+    }
+
+    StringBuffer insert(int offset, StringBuffer other){
+        return insert( offset, other.slice());
+    }
+
+    StringBuffer replace(int start, int end, String str) {
+        version(Tango){
+            buf.select(start, end-start);
+            buf.replace(str);
+            buf.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;
+                }
+                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;
+                }
+            }
+            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;
+        }
+        return this;
+    }
+
+    void setLength( int newLength ){
+        version(Tango){
+            buf.truncate( newLength );
+        } else { // Phobos
+            if( buf.length < newLength ){
+                buf.length = 2*newLength + STDINCR;
+            }
+            used = newLength;
+        }
+    }
+
+    String substring( int start, int end ){
+        version(Tango){
+            return buf.slice()[ start .. end ].dup;
+        } else { // Phobos
+            return buf[ start .. end ].idup;
+        }
+    }
+
+    void delete_( int start, int end ){
+        replace( start, end, "" );
+    }
+    String slice(){
+        version(Tango){
+            return buf.slice();
+        } else { // Phobos
+            return cast(String)buf[ 0 .. used ];
+        }
+    }
+    void truncate( int start ){
+        setLength( start );
+    }
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/System.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,220 @@
+/**
+ * Authors: Frank Benoit <keinfarbton@googlemail.com>
+ */
+module java.lang.System;
+
+import java.lang.util;
+import java.lang.exceptions;
+
+version(Tango){
+    static import tango.sys.Environment;
+    static import tango.core.Exception;
+    static import tango.io.model.IFile;
+    static import tango.time.Clock;
+    static import tango.stdc.stdlib;
+} else { // Phobos
+    static import std.c.stdlib;
+    static import std.date;
+    static import std.path;
+}
+
+template SimpleType(T) {
+    debug{
+        static void validCheck(uint SrcLen, uint DestLen, uint copyLen){
+            if(SrcLen < copyLen || DestLen < copyLen|| SrcLen < 0 || DestLen < 0){
+                //Util.trace("Error : SimpleType.arraycopy(), out of bounds.");
+                assert(0);
+            }
+        }
+    }
+
+    static void remove(inout T[] items, int index) {
+        if(items.length == 0)
+            return;
+
+        if(index < 0 || index >= items.length){
+            throw new ArrayIndexOutOfBoundsException(__FILE__, __LINE__);
+        }
+
+        T element = items[index];
+
+        int length = items.length;
+        if(length == 1){
+            items.length = 0;
+            return;// element;
+        }
+
+        if(index == 0)
+            items = items[1 .. $];
+        else if(index == length - 1)
+            items = items[0 .. index];
+        else
+            items = items[0 .. index] ~ items[index + 1 .. $];
+    }
+
+    static void insert(inout T[] items, T item, int index = -1) {
+        if(index == -1)
+            index = items.length;
+
+        if(index < 0 || index > items.length ){
+            throw new ArrayIndexOutOfBoundsException(__FILE__, __LINE__);
+        }
+
+        if(index == items.length){
+            items ~= item;
+        }else if(index == 0){
+            T[] newVect;
+            newVect ~= item;
+            items = newVect ~ items;
+        }else if(index < items.length ){
+            T[] arr1 = items[0 .. index];
+            T[] arr2 = items[index .. $];
+
+            // Important : if you write like the following commented,
+            // you get wrong data
+            // code:  T[] arr1 = items[0..index];
+            //        T[] arr2 = items[index..$];
+            //        items = arr1 ~ item;      // error, !!!
+            //        items ~= arr2;            // item replace the arrr2[0] here
+            items = arr1 ~ item ~ arr2;
+        }
+    }
+
+    static void arraycopy(T[] src, uint srcPos, T[] dest, uint destPos, uint len)
+    {
+        if(len == 0) return;
+
+        assert(src);
+        assert(dest);
+        debug{validCheck(src.length - srcPos, dest.length - destPos, len);}
+
+        if(src is dest){
+            if( destPos < srcPos ){
+                for(int i=0; i<len; ++i){
+                    dest[destPos+i] = src[srcPos+i];
+                }
+            }
+            else{
+                for(int i=len-1; i>=0; --i){
+                    dest[destPos+i] = src[srcPos+i];
+                }
+            }
+        }else{
+            dest[destPos..(len+destPos)] = src[srcPos..(len+srcPos)];
+        }
+    }
+}
+
+
+class System {
+
+    alias SimpleType!(int).arraycopy arraycopy;
+    alias SimpleType!(byte).arraycopy arraycopy;
+    alias SimpleType!(double).arraycopy arraycopy;
+    alias SimpleType!(float).arraycopy arraycopy;
+    alias SimpleType!(short).arraycopy arraycopy;
+    alias SimpleType!(long).arraycopy arraycopy;
+    alias SimpleType!(uint).arraycopy arraycopy;
+    alias SimpleType!(ushort).arraycopy arraycopy;
+    alias SimpleType!(ubyte).arraycopy arraycopy;
+    alias SimpleType!(ulong).arraycopy arraycopy;
+    alias SimpleType!(char).arraycopy arraycopy;
+    alias SimpleType!(wchar).arraycopy arraycopy;
+    alias SimpleType!(Object).arraycopy arraycopy;
+    alias SimpleType!(void*).arraycopy arraycopy;
+
+    alias SimpleType!(int[]).arraycopy arraycopy;
+    alias SimpleType!(byte[]).arraycopy arraycopy;
+    alias SimpleType!(double[]).arraycopy arraycopy;
+    alias SimpleType!(float[]).arraycopy arraycopy;
+    alias SimpleType!(short[]).arraycopy arraycopy;
+    alias SimpleType!(long[]).arraycopy arraycopy;
+    alias SimpleType!(uint[]).arraycopy arraycopy;
+    alias SimpleType!(ushort[]).arraycopy arraycopy;
+    alias SimpleType!(ubyte[]).arraycopy arraycopy;
+    alias SimpleType!(ulong[]).arraycopy arraycopy;
+    alias SimpleType!(String).arraycopy arraycopy;
+    alias SimpleType!(wchar[]).arraycopy arraycopy;
+    alias SimpleType!(Object[]).arraycopy arraycopy;
+    alias SimpleType!(void*[]).arraycopy arraycopy;
+    alias SimpleType!(void*[]).arraycopy arraycopy;
+
+    static long currentTimeMillis(){
+        version(Tango) return tango.time.Clock.Clock.now().ticks() / 10000;
+        else           return std.date.getUTCtime() / (std.date.TicksPerSecond/1000);
+    }
+
+    static void exit( int code ){
+        version(Tango) tango.stdc.stdlib.exit(code);
+        else           std.c.stdlib.exit(code);
+    }
+    public static int identityHashCode(Object x){
+        if( x is null ){
+            return 0;
+        }
+        return (*cast(Object *)&x).toHash();
+    }
+
+    public static String getProperty( String key, String defval ){
+        String res = getProperty(key);
+        if( res ){
+            return res;
+        }
+        return defval;
+    }
+    public static String getProperty( String key ){
+        /* Get values for local org.eclipse.swt specific keys */
+        String* p;
+        if (key[0..3] == "org.eclipse.swt") {
+            return ((p = key in localProperties) != null) ? *p : null;
+        /* else get values for global system keys (environment) */
+        } else {
+            switch( key ){
+                case "os.name": return "linux";
+                case "user.name": return "";
+                case "user.home": return "";
+                case "user.dir" : return "";
+                case "file.separator" : 
+                    version(Tango) return tango.io.model.IFile.FileConst.PathSeparatorString ;
+                    else           return std.path.sep;
+                default: return null;
+            }
+        }
+    }
+
+    public static void setProperty ( String key, String value ) {
+        /* set property for local org.eclipse.swt keys */
+        if (key[0..3] == "org.eclipse.swt") {
+            if (key !is null && value !is null)
+                localProperties[ key ] = value;
+        /* else set properties for global system keys (environment) */
+        } else {
+
+        }
+
+    }
+
+    static class Output {
+        public void println( String str ){
+            implMissing( __FILE__, __LINE__ );
+        }
+    }
+
+    private static Output err__;
+    public static Output err(){
+        if( err__ is null ){
+            err__ = new Output();
+        }
+        return err__;
+    }
+    private static Output out__;
+    public static Output out_(){
+        if( out__ is null ){
+            out__ = new Output();
+        }
+        return out__;
+    }
+
+    private static String[String] localProperties;
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/base/src/java/lang/Thread.d	Sat Mar 21 11:33:57 2009 +0100
@@ -0,0 +1,172 @@
+module java.lang.Thread;
+
+version(Tango){
+    static import tango.core.Thread;
+} else { // Phobos
+    static import core.thread;
+}
+import java.lang.util;
+import java.lang.Runnable;
+
+class Thread {
+
+    version(Tango){
+        alias tango.core.Thread.Thread TThread;
+    } else { // Phobos
+        alias core.thread.Thread TThread;
+    }
+    private TThread thread;
+    private Runnable runnable;
+
+    version(Tango){
+        private alias tango.core.Thread.ThreadLocal!(Thread) TTLS;
+        private static TTLS tls;
+    } else { // Phobos
+        mixin( "static __thread Thread tls;" );
+    }
+
+    public static const int MAX_PRIORITY  = 10;
+    public static const int MIN_PRIORITY  =  1;
+    public static const int NORM_PRIORITY =  5;
+
+    version(Tango){
+        private static TTLS getTls(){
+            if( tls is null ){
+                synchronized( Thread.classinfo ){
+                    if( tls is null ){
+                        tls = new TTLS();
+                    }
+                }
+            }
+            return tls;
+        }
+    }
+
+    public this(){
+        thread = new TThread(&internalRun);
+    }
+    public this( void delegate() dg ){
+        thread = new TThread(&internalRun);
+        runnable = dgRunnable( dg );
+    }
+    public this(Runnable runnable){
+        thread = new TThread(&internalRun);
+        this.runnable = runnable;
+    }
+    public this(Runnable runnable, String name){
+        thread = new TThread(&internalRun);
+        this.runnable = runnable;
+        thread.name = cast(char[])name;
+    }
+    public this(String name){
+        thread = new TThread(&internalRun);
+        thread.name = cast(char[])name;
+    }
+
+    public void start(){
+        thread.start();
+    }
+
+    public static Thread currentThread(){
+        version(Tango){
+            auto res = getTls().val();
+            if( res is null ){
+                // no synchronized needed
+                res = new Thread();
+                res.thread = tango.core.Thread.Thread.getThis();
+                getTls().val( res );
+            }
+            assert( res );
+            return res;
+        } else { // Phobos
+            auto res = tls;
+            if( res is null ){
+                // no synchronized needed
+                res = new Thread();
+                res.thread = TThread.getThis();
+                tls = res;
+            }
+            assert( res );
+            return res;
+        }
+    }
+    public int getPriority() {
+        return (thread.priority-TThread.PRIORITY_MIN) * (MAX_PRIORITY-MIN_PRIORITY) / (TThread.PRIORITY_MAX-TThread.PRIORITY_MIN) + MIN_PRIORITY;
+    }
+    public void setPriority( int newPriority ) {
+//         assert( MIN_PRIORITY < MAX_PRIORITY );
+//         assert( tango.core.Thread.Thread.PRIORITY_MIN < tango.core.Thread.Thread.PRIORITY_MAX );
+        auto scaledPrio = (newPriority-MIN_PRIORITY) * (TThread.PRIORITY_MAX-TThread.PRIORITY_MIN) / (MAX_PRIORITY-MIN_PRIORITY) +TThread.PRIORITY_MIN;
+        getDwtLogger().trace( __FILE__, __LINE__, "Thread.setPriority: scale ({} {} {}) -> ({} {} {})", MIN_PRIORITY, newPriority, MAX_PRIORITY, TThread.PRIORITY_MIN, scaledPrio, TThread.PRIORITY_MAX);
+//         thread.priority( scaledPrio );
+    }
+
+    private void internalRun(){
+        version(Tango){
+            // Store this thread object ref to the TLS
+            getTls().val( this );
+        } else { // Phobos
+            tls = this;
+        }
+        if( runnable !is null ){
+            runnable.run();
+        }
+        else {
+            run();
+        }
+    }
+
+    public bool isAlive(){
+        return thread.isRunning();
+    }
+
+    public bool isDaemon() {
+        return thread.isDaemon();
+    }
+
+    public void join(){
+        thread.join();
+    }
+
+    public void setDaemon(bool on) {
+        thread.isDaemon(on);
+    }
+
+    public void setName(String name){
+        thread.name = cast(char[])name;
+    }
+    public String getName(){
+        return cast(String)thread.name;
+    }
+
+    void interrupt() {
+        implMissing(__FILE__,__LINE__);
+    }
+
+    static bool interrupted() {
+        implMissing(__FILE__,__LINE__);
+        return false;
+    }
+
+    public void run(){
+        // default impl, do nothing
+    }
+    public static void sleep( int time ){
+        version(Tango){
+            TThread.sleep(time/1000.0);
+        } else { // Phobos
+            TThread.sleep(time*10_000);
+        }
+    }
+    public TThread nativeThread(){
+        assert(thread);
+        return thread;
+    }
+    public override String toString(){
+        return cast(String) "Thread "~cast(String)thread.name;
+    }
+    public static void yield(){
+        TThread.yield();
+    }
+}
+