Known problems and things to fix:
=================================

java.io.File.list0 
	Your comments looked like you werent sure: this returns an array
	of file names of files in a directory, minus "." and "..".
	I'll include some code at the end that does this.

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/dirent.h>
#include <unistd.h>
#include <errno.h>

char *strdup();

#define BUFLEN 4096

struct ll_node {
    struct ll_node *next;
    char *data;
};

char **
foo(path)
char *path;
{
    char **res = 0;
    struct ll_node *head = 0, **tailp = &head, *node;
    struct stat stbuf;
    struct dirent *dep;
    char buf[BUFLEN], *next, *end, *data;
    int old_errno, fd, len, count = 0;

    /* if not readable or not a dir sun's implementation returns a null ref */
    if(stat(path, &stbuf) == -1 || !S_ISDIR(stbuf.st_mode))
        return res;
    fd = open(path, O_RDONLY);
    if(fd == -1)
        return res;
 
    /* to avoid reading the dir twice we store it in a linked list */
     while((len = getdents(fd, (struct dirent *)buf, BUFLEN)) > 0) {
        end = buf + len;
        for(next = buf; next < end;) {
            dep = (struct dirent *)next;
            next += dep->d_reclen;

            if(strcmp(dep->d_name, ".") == 0 ||
               strcmp(dep->d_name, "..") == 0)
                continue;


            node = (struct ll_node *)malloc(sizeof(*node));
            data = strdup(dep->d_name);
            if(!node || !data) {
                /* XXX should we bother freeing up the linked list? */
                close(fd);
                exit(1);
            }
            node->data = data;
            node->next = *tailp;
            *tailp = node;
            tailp = &node->next;
            count ++;
        }
    }
    if(len == -1) {
        old_errno = errno;
        close(fd);
        exit(1);
    }
    close(fd);

    /* we now have a list of entries - put them into a String[] */
    count = 0;
    for(; head; head = node) {
        node = head->next;

        printf("%s\n", head->data);
        count++;
        free(head->data);
        free(head);
    }

    return res;
}

java.lang.System.arraycopy 
	You got the semantics wrong:  You can copy
	arrays if their types are identical, *or*
	if they are reference objects with compatible
	types (ie. assign subtype to supertype):
	- If both are primitives of same type you can
	blindly copy
	- If both are references of the same type, you can
	blindly copy
	- If the src is a subclass of the dest you can
	blindly copy
	- If the src is a superclass of the dest you
	can copy an element at a time as long as
	each element of the src is the same type or a
	subclass type of the dest array element types.

java.lang.Throwable.fillInStackTrace
	your comments imply you're not sure what to fill in.
	this is basically just a string representing where
	in the program the exception was thrown.  ie:
	    "at cl.main(cl.java:11)"
	for an exception that was thrown in cl.main().
	If the call stack was nested deeper there would
	be several lines, one for each method on the call
	stack.

InetAddress 
	not sure if your threads package or model
	handles this, but the gethostby*() routines
	use a static buffer and arent thread safe.

socketAccept - you want to return the address and port of the remote
	as returned by accept() and the localport of the socket
	as returned by getsockname()

Fix Unicode! Currently Kaffe uses ASCII characters rather than Unicode
   characters.

Add support for thread sleeps and wait timeouts.

Finish native and net libraries.

Bytecode verification.

Add support for class loaders.

Add some form of regression test suite.

Add ?_QUICK options to interpreter.  Current some operations are very
slow without these shortcuts.
