This file is a list of known bugs, short-comings and oddities.  
Treat it as an TODO list.

* java.net.Socket:

     getSoTimeout() 
     setSoTimeout(int) 	are not implemented.

* Thread.interrupt() is not implemented properly.

* Add some architecture-specific stack pointer alignment macro.  Currently,
  alignment is sizeof (jlong); apparently, some architectures require more
  specific alignments.

* Kaffe fails to work for several people under SunOS 4.1.3.  The error
  message seems to be "Can not find native library in path".  This problem
  is unclear: either a problem in the kaffe script that use @libdir@ and set 
  LD_LIBRARY_PATH (less likely), or a problem in the dynamic linking 
  mechanisms on this system.  Check the mailing list archive for more info.

* Object serialization is broken.  Even simple tests fail.  Many run-time 
  classes do not properly serialize or deserialize.
  Class UIDs are not computed.

* Several classes do not have serialVersionUIDs hard-coded in them. This
  makes these classes not interoperable with Sun's classes.  Note, however,
  that simply putting in Sun's will not fix that: in order to allow 
  interoperability, we will need to implement Sun's specification for
  how classes are serialized.  As of 1.2, these specs are part of the
  JDK documentation.
  Note that some of our classes currently report Sun's serialVersionUIDs,
  even though they're incompatible.

* Object serialization is buggy.  For the JKernel, the system goes in an
  infinite loop.  When we use Sun's java.io.* classes, it will work fine,
  except that non-transient floating point fields are not properly saved
  and restored using defaultWriteObject and defaultReadObject.  Weird. More
  investigation is needed.  (This is why java.util.Hashtable manually
  saves and restores its loadFactor.)  This is valid as of Jul 23, 1998.

* Kaffe does not currently provide its own implementation of RMI.

* java.math.* is incomplete.  java.math.BigInteger is mostly written and
  relies on the GNU Multi-precision math package (GMP).  BigDecimal is
  completely incomplete (?) and will just throw exceptions when used.

* There is a problem with String.intern().  Specifically, if an interned string
  is scheduled for finalization, but is then reattached through the finalizer
  of a related object, and another string with the same value is interned, 
  then the second string will have a different interned value.  This means
  that calling a.intern() gives a different result depending on when
  it's called.  This seems like a very obscure problem.  It should be fixed
  once 1.2 references are implemented.

* Class.getFields() returns Fields in reverse order compared to Sun's jdk.
  Apparently, this causes some software such Cygnus's kawa to fail in 
  certain circumstances.  It seems like they should fix that.

* While Kaffe currently doesn't compile with other compilers than Cygnus
  cygwin32 gcc compiler, we do know that people are trying to compile it
  with compilers such as Visual C++.  Jongwon Kim <freefish@chollian.net>
  reports that FIELD_OFFSET in classMethod.h conflicts with winnt.h.

* kaffe.util.Timer has several problems.  Peter has a fix in the pipeline
  that will come in with the next awt release.

* JNI incompatibilities pointed out by Johannes Deisenhofer 
  <joe@dillingen.baynet.de>:

 - NewXXXArray() should return jXXXArray instead of jarray
   This is a problem in C++, since these types are not simply casted to jref

  Note kaffe's jni.h doesn't even define these array types as of yet.

* If a thread stops in a static initializer, then this will cause problems.

* The -mx and other options that take a numeric argument behave different
  than Sun's.  Kaffe wants a space, Sun doesn't.
  Example:	Kaffe:	-mx 32m  Sun:  -mx32m
  Pointed out by David Tucker <dbtucker@acm.jhu.edu> on Sat, 21 Nov 1998

* There is a problem with long remainders under FreeBSD.  The problems lies
  in FreeBSD's libc, and concerns versions up to and including 2.2.8 and 3.0.
  You will see wrong signs in the result.

* java.util.Random produces different results than Sun's.  While the basic
  algorithm is the same, Kaffe uses different multipliers and modulos.

