2005-08-02 Andrew John Hughes <gnu_andrew@member.fsf.org>

	* Merge of HEAD --> generics-branch for 2005/06/05 - 2005/07/31.

	See patch on classpath-patches@gnu.org for a full ChangeLog.

15 files changed, 1486 insertions, 69 deletions

diff --git a/doc/hacking.texinfo b/doc/hacking.texinfo
index 865cb53c8..e97116fd5 100644
--- a/doc/hacking.texinfo
+++ b/doc/hacking.texinfo
@@ -5,7 +5,7 @@
 @settitle GNU Classpath Hacker's Guide
 @c %**end of header
 
-@setchapternewpage none
+@setchapternewpage off
 
 @ifinfo
 This file contains important information you will need to know if you
@@ -419,10 +419,6 @@ libraries installed:
 creating graphical user interfaces.  It is used as the basis of the
 GNU desktop project GNOME.
 
-@item libart-lgpl 2.1+
-@uref{http://www.gnome.org/start/,libart} is a GNOME library of
-functions for 2D graphics.
-
 @item gdk-pixbuf
 @uref{http://www.gnome.org/start/,gdk-pixbuf} is a GNOME library for
 representing images.
@@ -462,12 +458,12 @@ java.lang.StrictMath.
 @chapter Programming Standards
 
 For C source code, follow the
-@uref{http://www.fsf.org/prep/standards_toc.html,GNU Coding Standards}.
+@uref{http://www.gnu.org/prep/standards/,GNU Coding Standards}.
 The standards also specify various things like the install directory
 structure.  These should be followed if possible.
 
 For Java source code, please follow the
-@uref{http://www.fsf.org/prep/standards_toc.html,GNU Coding
+@uref{http://www.gnu.org/prep/standards/,GNU Coding
 Standards}, as much as possible.  There are a number of exceptions to
 the GNU Coding Standards that we make for GNU Classpath as documented
 in this guide.  We will hopefully be providing developers with a code
@@ -488,7 +484,7 @@ guidelines more tailored to GNU Classpath as part of this document.
 
 Here is a list of some specific rules used when hacking on GNU
 Classpath java source code. We try to follow the standard
-@uref{http://www.gnu.org/prep/standards_23.html,GNU Coding Standards}
+@uref{http://www.gnu.org/prep/standards/,GNU Coding Standards}
 for that. There are lots of tools that can automatically generate it
 (although most tools assume C source, not java source code) and it
 seems as good a standard as any. There are a couple of exceptions and
diff --git a/doc/texinfo.tex b/doc/texinfo.tex
index b0a1cfc3e..ad9db2922 100644
--- a/doc/texinfo.tex
+++ b/doc/texinfo.tex
@@ -20,8 +20,8 @@
 %
 % You should have received a copy of the GNU General Public License
 % along with this texinfo.tex file; see the file COPYING.  If not, write
-% to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-% Boston, MA 02111-1307, USA.
+% to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+% Boston, MA 02110-1301, USA.
 %
 % In other words, you are welcome to use, share and improve this program.
 % You are forbidden to forbid anyone else to use, share and improve
diff --git a/doc/vmintegration.texinfo b/doc/vmintegration.texinfo
index c43133730..81e9920d6 100644
--- a/doc/vmintegration.texinfo
+++ b/doc/vmintegration.texinfo
@@ -5,7 +5,7 @@
 @settitle GNU Classpath VM Integration Guide
 @c %**end of header
 
-@setchapternewpage none
+@setchapternewpage off
 
 @ifinfo
 This file contains important information you will need to know if you
@@ -110,7 +110,7 @@ provides a Java 1.1 compatible environment.
 The Electrical File VM continues to be listed as a Mozilla project
 though development has been somewhat quiet.  A number of concepts from
 EF were expected at one point to be rolled into Japhar, but that
-development has not occured as of yet.
+development has not occurred as of yet.
 
 @item @uref{http://latte.snu.ac.kr/,LaTTe}
 This VM project so far supports only Sun UltraSparc processors using the
@@ -175,42 +175,881 @@ The initialization order is currently documented in the
 @comment node-name, next, previous, up
 @chapter Classpath Hooks
 
-Several core classes must be implemented by the VM for Classpath to
-work.  These classes are:
+The primary method of interaction between Classpath and the VM is via
+the helper classes, which are named after the relevant core library
+class, but include an additional `VM' prefix.  The library classes from
+Classpath call out to these to get certain VM-specific dirty work done.
+A reference copy of each VM class exists.  The majority consist of a
+series of static methods, some of which are simply declared
+@code{native}, and some which provide a default implementation.  VMs may
+either use these as is, or create their own local variations.  When
+using the default implementations, the VM is responsible for
+implementing any of the code marked as @code{native} which corresponds
+to functionality they wish their VM to provide.  When using their own
+versions of the classes, VM implementors may choose to change the mix of
+native and non-native methods from that below, so as to best suit their
+implementation.
+
+@menu
+* java.lang::
+* gnu.classpath::
+* java.util::
+* java.io::
+* java.security::
+* java.net::
+* java.nio::
+* java.nio.channels::
+* gnu.java.nio::
+* Classpath Callbacks::
+@end menu
+
+@node java.lang, gnu.classpath, Classpath Hooks, Classpath Hooks
+@comment  node-name,  next,  previous,  up
+
+@section @code{java.lang}
+
+@code{java.lang} is the core Java package, being imported automatically by all
+classes.  It includes basic classes as @code{Object} and @code{String}.
+A VM must implement at least some parts of this package in order to
+become operable.
+
+@menu
+* java.lang.VMClass::
+* java.lang.VMObject::
+* java.lang.VMClassLoader::
+* java.lang.VMSystem::
+* java.lang.VMThrowable::
+* java.lang.VMCompiler::
+* java.lang.VMDouble::
+* java.lang.VMFloat::
+* java.lang.VMProcess::
+* java.lang.VMRuntime::
+* java.lang.VMString::
+* java.lang.VMThread::
+@end menu
+
+@node java.lang.VMClass, java.lang.VMObject ,java.lang,java.lang
+@subsection @code{java.lang.VMClass}
+
+The core class, @code{java.lang.Class}, and the corresponding VM class,
+@code{java.lang.VMClass}, provide two main functions within GNU Classpath.
+
+@enumerate
+@item For basic VM operation, @code{java.lang.Class} provides the link between
+the Java-based representation of a class it embodies and the VM's own
+internal structure for a class.  @xref{VM Hooks}.
+
+@item As far as the user is concerned, the main function of
+@code{java.lang.Class} is as an entry point to the reflection
+facilities, and so it also provides this functionality, backed by the
+VM class.
+@end enumerate
+
+This VM class lists the following methods, organized by the version of the
+Java specification in which they occur.  All are @code{native}, unless
+otherwise specified, and pertain to reflection.  As a result, the VM only
+needs to implement these methods in order to provide reflection support,
+and then only to the degree required.
 
 @itemize @bullet
-@item java.lang.Class
-@item java.lang.Runtime
-@item java.lang.Thread
-@item java.lang.reflect.Constructor
-@item java.lang.reflect.Method
-@item java.lang.reflect.Field
+@item 1.0
+@itemize @bullet
+@item @code{isInterface(Class)} -- This is simply a property test, and matches
+the presence of an appropriate flag within the class file.
+@item @code{getName(Class)} -- Returns the fully-qualified name of the class.
+@item @code{getSuperclass(Class)} -- Returns a @code{Class} instance which
+represents the superclass.  Again, the class file contains an element directly
+relating to this.  @code{null} is returned for primitives, interfaces and
+@code{Object}.
+@item @code{getInterfaces(Class)} -- Same as the above, but the implemented
+or extended interfaces rather than the superclass.  An empty array should
+be returned, rather than @code{null}.
+@item @code{getDeclaredClasses(Class,boolean)} -- Returns the internal classes
+this instance declares directly.  The flag determines whether or not the
+VM should filter out non-public classes.
+@item @code{getDeclaredFields(Class,boolean)} -- The same for fields.
+@item @code{getDeclaredMethods(Class,boolean)} -- And for methods.
+@item @code{getDeclaredConstructors(Class,boolean)} -- And constructors.
+@item @code{getClassLoader(Class)} -- Returns the @code{ClassLoader} instance
+which is responsible for the specified class.
+@item @code{forName(String)} -- The VM should create a @code{Class} instance
+corresponding to the named class.  As noted in @ref{VM Hooks}, the internal
+content of the instance is the responsibility of the VM.
+@item @code{isArray(Class)} -- Another property test, corresponding to a
+class file flag.
+@item @code{initialize(Class)} -- The VM should initialize the class fully,
+if it has not already done so.
+@item @code{loadArrayClass(String,ClassLoader)} -- This is called if
+@code{forName} returns @code{null} and the string specifies an array class.
+The specified array class should be loaded with the supplied class loader.
+@item @code{throwException(Throwable)} -- The VM should throw the supplied
+checked exception, without declaring it.
+@end itemize
+@item 1.1
+@itemize @bullet
+@item @code{isInstance(Class,Object)} -- This is a reflection-based equivalent
+of the @code{instanceof} operator.
+@item @code{isAssignableFrom(Class,Class)} -- Mainly a shorthand for the above,
+removing the need to create an instance to test assignability.  
+@item @code{isPrimitive(Class)} -- Returns true if this class is simply
+a representation of one of the primitive types: @code{boolean}, @code{byte},
+@code{char}, @code{short}, @code{int}, @code{long}, @code{float},
+@code{double} and @code{void}.
+@item @code{getComponentType(Class)} -- Produces a @code{Class} instance which
+represents the type of the members of the array the class instance represents.
+Classes which don't represent an array type return @code{null}.
+@item @code{getModifiers(Class,boolean)} -- Returns an integer which encodes
+the class' modifiers, such as @code{public}.  Again, this relates to
+information stored in the class file.
+@item @code{getDeclaringClass(Class)} -- Returns the class that declared
+an inner or member class, or @code{null} if the instance refers to a top-level
+class.
+@end itemize
+@end itemize
+
+@node java.lang.VMObject, java.lang.VMClassLoader, java.lang.VMClass, java.lang
+@subsection @code{java.lang.VMObject}
+
+@code{VMObject} is the bridge between the low level @code{Object} facilities
+such as making a clone, getting the class of the object and the wait/notify
+semantics.  This is accomplished using the following @code{native}
+methods.
+
+@itemize @bullet
+@item @code{getClass(Object)} -- Returns the @code{Class} instance for the
+object.  @code{Class} objects are produced by the VM, as described in
+@ref{VM Hooks}.
+@item @code{clone(Cloneable)} -- The VM should produce a low-level clone of the
+specified object, creating a field-by-field shallow copy of the original.
+The only difference between the two is that the new object should still be
+@code{finalizable}, even if the original is not.
+@item @code{notify(Object)} -- The VM should choose one of the threads waiting
+for a lock on the specified object arbitrarily, and wake it.  If the current
+thread does not currently hold the lock on the object, then an
+@code{IllegalMonitorStateException} should be thrown.
+@item @code{notifyAll(Object)} -- Same as the above, but all threads are
+awakened.
+@item @code{wait(Object,long,int)} -- The VM should set the current thread
+into a waiting state, which persists until it receives a notify signal or the
+specified time (in milliseconds and nanoseconds) is exceeded.  The nanoseconds
+restriction may be ignored if such granularity is not available, and a
+@code{IllegalMonitorStateException} should be thrown if the current thread
+doesn't own the object.
+@end itemize
+
+@node java.lang.VMClassLoader, java.lang.VMSystem, java.lang.VMObject, java.lang
+@subsection @code{java.lang.VMClassLoader}
+@code{VMClassLoader} provides methods for defining and resolving core and
+primitive classes, as well as handling resources, packages and assertions.
+The class is a mixture of @code{native} methods and Java-based
+implementations, with some of the latter being @emph{stubs}.
+
+@itemize @bullet
+@item Native Methods
+@itemize @bullet
+@item @code{defineClass(ClassLoader,String,byte[],int,int,ProtectionDomain)}
+-- The VM should create a @code{Class} instance from the supplied byte array.
+@item @code{resolveClass(Class)} -- Resolve references to other classes in the
+supplied class.
+@item @code{loadClass(name,boolean)} -- Load a class using the bootstrap
+loader.
+@item @code{getPrimitiveClass(char)} -- The VM should provide a @code{Class}
+implementation for one of the primitive classes.  The supplied character
+matches the JNI code for the primitive class e.g. `B' for byte and
+`Z' for boolean.
+@end itemize
+@item Java Methods
+@itemize @bullet
+@item @code{getResource(String)} -- The default implementation calls
+@code{getResources} and returns the first element in the returned enumeration,
+or @code{null} if there are no elements.
+@item @code{getResources(String)} -- By default, this compiles a list of
+URLs via the boot class path.  Any matching files within a zip file are added,
+and directories on the boot class path are automatically converted to file
+URLs that refer to join the directory with the resource name (whether or not
+it actually exists).
+@item @code{getPackage(String)} -- Always returns null, which may be suitable
+if the VM does not wish to return a @code{Package} implementation. Otherwise,
+it may be necessary to make this a @code{native} method.
+@item @code{getPackages()} -- As with the last, a default stub implementation
+exists (returning an empty array) which may be replaced if support is
+required. 
+@item @code{defaultAssertionStatus()} -- A stub which can be implemented
+by VMs providing assertion support.  At present, it always returns @code{true}.
+@item @code{packageAssertionStatus()} -- Much the same status as the above.
+The method should return a map converting package names to boolean status
+values.  The stub implementation provides an empty map.
+@item @code{classAssertionStatus()} -- Same as the last, but for classes.
+@item @code{getSystemClassLoader()} -- The default calls @code{ClassLoader}
+to create a new auxillary class loader with a system and extension class
+loader.  The VM may wish to replace it if it wishes to supply its own custom
+system class loader.
+@end itemize
+@end itemize
+@node java.lang.VMSystem, java.lang.VMThrowable, java.lang.VMClassLoader, java.lang
+@subsection @code{java.lang.VMSystem}
+@code{VMSystem} handles the default I/O streams, provides access to the
+system clock and environment variables and provides methods for
+@code{System.arraycopy} and the @code{identityHashCode} of an
+@code{Object}.  It consists of @code{native} methods, but the default
+implementation also provides some helper methods to simplify stream
+creation.  
+
+@itemize @bullet
+@item Native Methods
+@itemize @bullet
+@item @code{arraycopy(Object,int,Object,int,int)} -- The VM should copy
+a specified number of array objects from one array to another, with 
+appropriate checks for compatible typing, available elements and space.
+The VM should be able to perform this more efficiently using native code
+and direct memory manipulation than would have been achieved by using Java.
+@item @code{identityHashCode(Object)} -- This is the hashcode for
+@code{Object}, which relates to the actual location of the object in memory.
+@item @code{setIn(InputStream)} -- Set the system input stream.
+@item @code{setOut(PrintStream)} -- Set the system output stream.
+@item @code{setErr(PrintStream)} -- Set the system error stream.
+@item @code{currentTimeMillis()} -- Gets the system time in milliseconds.
+@item @code{getenv(String)} -- Returns the value of the specified environment
+variable.
+@end itemize
+@item Java Methods
+@itemize @bullet
+@item @code{makeStandardInputStream()} -- Helps provide the functionality of
+@code{System.in} by wrapping the appropriate file descriptor in a buffered
+file input stream.  VMs may choose to create the stream from the descriptor
+differently rather than using this method.
+@item @code{makeStandardOutputStream()} -- Helps provide the functionality of
+@code{System.out} by wrapping the appropriate file descriptor in a buffered
+file output stream.  VMs may choose to create the stream from the descriptor
+differently rather than using this method.
+@item @code{makeStandardErrorStream()} -- Helps provide the functionality of
+@code{System.err} by wrapping the appropriate file descriptor in a buffered
+file output stream.  VMs may choose to create the stream from the descriptor
+differently rather than using this method.
+@end itemize
+@end itemize
+
+Classpath also provides native implementations of
+
+@itemize @bullet
+@item @code{setIn(InputStream)} 
+@item @code{setOut(PrintStream)} 
+@item @code{setErr(PrintStream)} 
+@item @code{currentTimeMillis()} 
+@item @code{getenv(String)}
+@end itemize
+
+making a VM implementation optional.
+
+@node java.lang.VMThrowable, java.lang.VMCompiler, java.lang.VMSystem, java.lang
+@subsection @code{java.lang.VMThrowable}
+@code{VMThrowable} is used to hold the VM state of a throwable, created either
+when a @code{Throwable} is created or the @code{fillInStackTrace()} method is
+called (i.e. when the actual stack trace is needed, as a lot of exceptions are
+never actually used).  The actual class has two @code{native} methods,
+one (@code{fillInStackTrace()}) being a method of the class used to obtain
+instances, and the other an instance method, @code{getStackTrace()}.
+@itemize @bullet
+@item @code{fillInStackTrace(Throwable)} -- The VM should return the current
+execution state of the @code{Throwable} in the form of a @code{VMThrowable}
+instance.  The VM may also return @code{null} if it does not support this
+functionality.
+@item @code{getStackTrace()} -- This is used to create a real
+@code{StackTraceElement} array for the exception, using the state data
+stored during creation of the instance.
+@end itemize
+
+@node java.lang.VMCompiler, java.lang.VMDouble, java.lang.VMThrowable, java.lang
+@subsection @code{java.lang.VMCompiler}
+
+@code{VMCompiler} provides an interface for VMs which wish to provide
+JIT compilation support.  The default implementation is simply a series
+of stubs. The property, @code{java.compiler}, should point to a library
+containing the function @code{java_lang_Compiler_start()} if such support
+is to be provided.
+
+@itemize @bullet
+@item @code{compileClass(Class)} -- Invoke the compiler to compile the specific
+class, returning @code{true} if successful.
+@item @code{compileClasses(String)} -- The compiler should compile the classes
+matching the specified string, again returning @code{true} on success.
+@item @code{command(Object)} -- The object represents a command given to the
+compiler, and is specific to the compiler implementation.
+@item @code{enable} -- Enable the operation of the compiler.
+@item @code{disable} -- Disable compiler operation.
+@end itemize
+
+@node java.lang.VMDouble, java.lang.VMFloat, java.lang.VMCompiler, java.lang
+@subsection @code{java.lang.VMDouble}
+
+@code{VMDouble} provides native support for the conversion and parsing
+of doubles.
+
+@itemize @bullet
+@item @code{doubleToLongBits(double)} -- Converts the double to the IEEE 754
+bit layout, collapsing NaNs to @code{0x7ff8000000000000L}.
+@item @code{doubleToRawLongBits(double)} -- Same as the above, but preserves
+NaNs.
+@item @code{longBitsToDouble(long)} -- This is the inverse of the last method,
+preserving NaNs so that the output of one can be fed into the other without
+data loss.
+@item @code{toString(double,boolean)} -- Converts the double to a string,
+giving a shorter value if the flag @code{isFloat} is @code{true}, indicating
+that the conversion was requested by @code{java.lang.Float} rather than
+@code{java.lang.Double}.
+@item @code{initIDs} -- Used by JNI-based solutions to initialize the cache
+of the static field IDs.  The default @code{VMDouble} implementation has a
+static initializer which loads the JNI library and calls this method.
+@item @code{parseDouble} -- Turn the string into a usable double value.
+@end itemize
+
+Classpath provides native implementations of all these, making VM
+implementation optional.
+
+@node java.lang.VMFloat, java.lang.VMProcess, java.lang.VMDouble, java.lang
+@subsection @code{java.lang.VMFloat}
+
+@code{VMFloat} provides native support for the conversion of floats.
+
+@itemize @bullet
+@item @code{floatToIntBits(float)} -- Converts the float to the IEEE 754
+bit layout, collapsing NaNs to @code{0x7fc00000}.
+@item @code{floatToRawIntBits(float)} -- Same as the above, but preserves
+NaNs.
+@item @code{intBitsToFloat(int)} -- This is the inverse of the last method,
+preserving NaNs so that the output of one can be fed into the other without
+data loss.
+@end itemize
+
+Classpath provides native implementations of all these, making VM
+implementation optional.
+
+@node java.lang.VMProcess, java.lang.VMRuntime, java.lang.VMFloat, java.lang
+@subsection @code{java.lang.VMProcess}
+
+@code{VMProcess} handles the execution of external processes.  In the
+default implementation, threads are spawned and reaped by @code{ProcessThread}.
+A constructor creates a new @code{VMProcess}, which extends rather than
+complements @code{Process}, using an array of arguments, an array of
+environment variables and a working directory.  The instance maintains
+system input, output and error streams linked to the external process.
+Three @code{native} methods are used, and implementations are provided
+for all three by Classpath, making VM implementation optional.  These use
+the POSIX functions, @code{fork()}, @code{waitpid()} and @code{kill()}.
+
+@itemize @bullet
+@item @code{nativeSpawn(String[],String[],File)} -- The VM should create a
+new process which uses the specified command-line arguments, environment
+variables and working directory.  Unlike the other two methods, this
+method is linked to an instance, and must call @code{setProcessInfo()} with
+the results before returning.
+@item @code{nativeReap()} -- This is called to perform a reap of any
+zombie processes, and should not block, instead returning a boolean as to
+whether reaping actually took place.
+@item @code{nativeKill(long)} -- The VM should terminate the specified PID.
+@end itemize
+
+@node java.lang.VMRuntime, java.lang.VMString, java.lang.VMProcess, java.lang
+@subsection @code{java.lang.VMRuntime}
+
+The @code{VMRuntime} class provides a series of native methods
+which divulge information about the runtime or invoke certain
+operations.  This includes retrieving the amount of available memory,
+and scheduling the garbage collector.  There are two exceptions: the
+@code{enableShutdownHooks} method, which allows the VM to put in its own
+shutdown hooks when @code{Runtime.addShutdownHook()} is first invoked,
+and @code{exec(String[],String[],File)} which spawns an external process.
+These are Java-based static methods instead.  The first is simply a stub by
+default, while the second simply links to the functionality of
+@code{VMProcess} (and should be changed if a different @code{Process}
+implementation is used).
+
+@itemize @bullet
+@item @code{availableProcessors()} -- Returns the number of processors 
+available to the VM.
+@item @code{freeMemory()} -- Returns the amount of memory the VM has available
+on the heap for allocating.
+@item @code{totalMemory()} -- Returns the size of the heap.
+@item @code{maxMemory()} -- Returns the maximum memory block the VM will
+attempt to allocate.  May be simply @code{Long.MAX_VALUE} (8 exabytes!)
+@item @code{gc()} -- Allows users to explicitly invoke the garbage collector.
+This is a suggestion to the VM, rather than a command, and the garbage
+collector should run anyway @emph{without} it being invoked.
+@item @code{runFinalization()} -- Like the above, but related to the
+finalilzation of objects rather than the garbage collector.
+@item @code{runFinalizationForExit()} -- Called immediately prior to VM
+shutdown in order to finalize all objects (including `live' ones)
+@item @code{traceInstructions(boolean)} -- This turns on and off the optional
+VM functionality of printing a trace of executed bytecode instructions.
+@item @code{traceMethodCalls(boolean)} -- This turns on and off the optional
+VM functionality of printing a trace of methods called.
+@item @code{runFinalizersOnExit(boolean)} -- A toggleable setting for
+running the finalization process at exit.
+@item @code{exit(int)} -- The VM should shutdown with the specified exit code.
+@item @code{nativeLoad(String,ClassLoader)} -- Attempts to load a file,
+returning an integer which is non-zero for success.  Nothing happens if the
+file has already been loaded.
+@item @code{mapLibraryName(String)} -- The VM should map the system-independent
+library name supplied to the platform-dependent equivalent (e.g. a @code{.so}
+or @code{.dll} file)
+@end itemize
+
+@node java.lang.VMString, java.lang.VMThread, java.lang.VMRuntime, java.lang
+@subsection @code{java.lang.VMString}
+@code{VMString} is responsible for handling interned strings.  If two strings
+are equal (using the @code{equals()} method), then the results of calling
+the @code{intern()} method on each of them makes them equal
+(using @code{==}).  Thus, the same string object is always returned by
+@code{intern} if the two strings are equal.  The default implementation
+is Java-based and implements @code{intern(String)} by maintaining a
+@code{WeakHashMap} which links the strings to their @code{WeakReference}.
+A new mapping is created for each new string being @code{intern}ed.  
+A VM may implement this differently by implementing this method,
+which is @code{static} and the only one in @code{VMString}.
+
+@node java.lang.VMThread,, java.lang.VMString, java.lang
+@subsection @code{java.lang.VMThread}
+
+@code{VMThread} provides the link between Java's threads and the platform
+threading support.  A @code{VMThread} is created via a private constructor
+and linked to a @code{Thread} instance.  This occurs when the @code{Thread}
+instance is started by the static @code{create(Thread,long)} method (the second
+argument requests a certain stack size, usually zero).  The thread itself is
+executed via the @code{run()} method, which handles any problems with the
+running of the thread and its eventual death.
+
+@code{VMThread} provides the following accessors and mutators for accessing
+the thread state via @code{VMThread},
+
+@itemize @bullet
+@item @code{getName()}
+@item @code{setName(String)}
+@item @code{getPriority()}
+@item @code{setPriotity(int)}
+@item @code{isDaemon()}
+@end itemize
+
+all of which refer to the @code{Thread} instance. @code{setPriority(int)} also
+calls the appropriate native method.  @code{stop(Throwable)} similarly wraps
+a native method, merely adding in a check for the state of the thread.
+
+The default implementation also provides Java-based implementations of
+@code{join(long,int)}, @code{sleep(long,int)} and
+@code{holdsLock(Object)}.  @code{join} and @code{sleep} simply wait for
+the appropriate amount of time, with @code{join} additionally waiting
+for the thread instance to become @code{null}.  @code{holdsLock} simply
+checks if an object is locked by the current thread by trying to invoke
+the @code{notify} method, and catching the failing exception if this is
+not the case.
+
+The remainder of the class is a series of @code{native} methods, some of
+which are mandatory for VM implementation and others which provide optional
+or deprecated functionality.
+
+@itemize @bullet
+@item Mandatory Instance Methods
+@itemize @bullet
+@item @code{start(long)} -- The VM should create the native thread and start
+it running using the @code{run} method of the @code{VMThread} instance on
+which this method is called.
+@item @code{interrupt()} -- The VM should interrupt the running thread and
+throw an appropriate exception.
+@item @code{isInterrupted()} -- Checks the interrupted state of the thread.
+@item @code{suspend()} -- The thread should be suspended until resumed.
+@item @code{resume()} -- The thread should be resumed from its suspended state.
+This pair of methods are deprecated, due to the possibility of a deadlock
+occuring when a thread with locks is suspended.
+@item @code{nativeSetPriority(int)} -- Called by @code{setPriority}
+to allow the setting to flow down to the native thread.
+@item @code{nativeStop(Throwable)} -- The VM should stop the thread abnormally
+and throw the specified exception.  This is clearly deprecated, due to the
+ambiguous state an abruptly-stopped thread may leave.
+@end itemize
+@item Mandatory Class Methods
+@itemize @bullet
+@item @code{currentThread()} -- Return a reference to the thread currently
+being executed.
+@item @code{yield()} -- The VM should allow some other thread to run.
+The current thread maintains its locks even though it stops executing for
+the time being.
+@item @code{interrupted()} -- A shortcut to obtaining the interrupted state
+of the current thread.
+@end itemize
+@item Other Methods
+@itemize @bullet
+@item @code{countStackFrames()} -- Returns a count of the number of stack
+frames in the thread.  This depends on the deprecated method @code{suspend()}
+having returned true, and is thus deprecated as a result.
+@end itemize
+@end itemize
+
+@node gnu.classpath, java.util, java.lang, Classpath Hooks
+@section @code{gnu.classpath}
+
+The @code{gnu.classpath} package provides Classpath-specific functionality,
+primarily relating to the features in @code{java.lang}.  At present, this
+includes the context of a class (the stack) and the system properties.
+
+@menu
+* gnu.classpath.VMStackWalker::
+* gnu.classpath.VMSystemProperties::
+@end menu
+
+@node gnu.classpath.VMStackWalker,gnu.classpath.VMSystemProperties,gnu.classpath,gnu.classpath
+@subsection @code{gnu.classpath.VMStackWalker}
+
+@code{VMStackWalker} provides access to the class context or stack.  The
+default implementation consists of a @code{native} @code{static} method,
+@code{getClassContext()}, which obtains the class context, and two helper
+methods which obtain the calling class (the 3rd element in the context array)
+and its class loader, respectively.
+
+@itemize @bullet
+@item @code{getClassContext()} -- The VM should return an array of
+@code{Class} objects, each of which relates to the method currently being
+executed at that point on the stack.  Thus, the first item (index 0) is the
+class that contains this method.
+@item @code{getCallingClass()} -- A Java-based helper method which returns
+the @code{Class} object which contains the method that called the method
+accessing @code{getCallingClass()}. 
+@item @code{getCallingClassLoader()} -- Like the last, but returning the class
+loader of the class.
+@end itemize
+
+@node gnu.classpath.VMSystemProperties,,gnu.classpath.VMStackWalker,gnu.classpath
+@subsection @code{gnu.classpath.VMSystemProperties}
+
+@code{VMSystemProperties} allows the VM to hook into the property creation
+process, both before and after the system properties are added by GNU
+Classpath.  The default implementation assumes that the VM will add its
+properties first, by making the pre-initialisation method @code{native},
+and that the Classpath properties may then be altered by a Java-based
+post-initialisation method.
+
+As these methods are called as part of the bootstrap process, caution should
+be used as to what classes are used, and properties should only be set
+using @code{Properties.setProperty()}.  Specifically, I/O classes should be
+avoided at this early stage.
+
+@itemize @bullet
+@item @code{preInit(Properties)} -- Allows the VM to add properties
+@emph{before} the Classpath properties are added. The default implementation
+includes a full list of properties that @emph{must} be added by the VM, but
+additional VM-specific ones may also be added.  
+@item @code{postInit(Properties)} -- Same as the last, but called after the
+Classpath properties have been added.  The main purpose of this is to allow
+the VM to alter the properties added by GNU Classpath to suit it.
+@end itemize
+
+@node java.util, java.io, gnu.classpath, Classpath Hooks
+@section java.util
+
+The @code{java.util} VM hooks provide links between the mix of functionality
+present in that package, which includes collections, date and time handling
+and parsing.  At present, there is only one hook, which connects GNU Classpath
+to the timezone information provided by the underlying platform.
+
+@menu
+* java.util.VMTimeZone::
+@end menu
+
+@node java.util.VMTimeZone,,java.util,java.util
+@subsection @code{java.util.VMTimeZone}
+
+@code{VMTimeZone} joins @code{TimeZone} to the platform timezone information
+via the static method, @code{getDefaultTimeZoneId()}.  The VM hook is
+expected to return a @code{TimeZone} instance that represents the current
+timezone in use by the platform.  The default implementation provides
+this functionality for POSIX or GNU-like systems, and VMs that want this
+functionality can keep this implementation and implement the native
+method, @code{getSystemTimeZoneId()}.  This method is only called when
+obtaining the timezone name from the @code{TZ} environment variable,
+@code{/etc/timezone} and @code{/etc/localtime} all fail.  This fallback
+mechanism also means that a system which doesn't provide the above three
+methods, but does provide a timezone in string form, can still use this
+implementation.
+
+@node java.io, java.security, java.util, Classpath Hooks
+@section java.io
+
+The @code{java.io} package is heavily reliant on access to the I/O facilities
+of the underlying platform.  As far as its VM hooks go, they provide two
+areas of functionality to GNU Classpath, these being
+
+@itemize @bullet
+@item File and directory queries and manipulation
+@item Serialization of objects
 @end itemize
 
-You also need to implement some helper classes in java.lang that classes
-from Classpath call out to to get certain VM-specific dirty work done:
+The first corresponds directly to most of the @code{File} class, while
+the latter underlies the functionality provided by the
+@code{ObjectInputStream} and @code{ObjectOutputStream}.  More low-level I/O
+is provided by @ref{java.nio}.
+
+@menu
+* java.io.VMFile::
+* java.io.VMObjectInputStream::
+* java.io.VMObjectStreamClass::
+@end menu
+
+@node java.io.VMFile,java.io.VMObjectInputStream,java.io,java.io
+@subsection @code{java.io.VMFile}
+
+@code{VMFile} allows GNU Classpath's @code{File} representations to
+probe and modify the file system using the native functions of the
+platform.  The default implementation (which consists of both a
+@code{VMFile} class and the native methods) is primarily UNIX-centric,
+working with POSIX functions and assuming case-sensitive filenames,
+without the restriction of the 8.3 format.  It consists mainly of
+@code{static} @code{native} methods, with a few Java helper methods.
+The native methods represent the file as a string containing its path,
+rather than using the object itself.
+
+@itemize @bullet
+@item Native Methods
+@itemize @bullet
+@item @code{lastModified(String)} -- The native method should return a
+@code{long} value that represents the last modified date of the file.
+@item @code{setReadOnly(String)} -- Sets the file's permissions to read only,
+in whichever way this is realised by the platform.
+@item @code{create(String)} -- Create the named file.
+@item @code{list(String)} -- The native method opens the named directory,
+reads the contents and returns them as a Java @code{String} array.
+@item @code{renameTo(String,String)} -- Renames the first file to the second.
+@item @code{length(String)} -- Returns a @code{long} value representing
+the file size.
+@item @code{exists(String)} -- Tests for the existence of the named file
+or directory.
+@item @code{delete(String)} -- Deletes the file or directory.
+@item @code{setLastModified(String,long)} -- Change the last modified time.
+@item @code{mkdir(String)} -- Creates the named directory.
+@item @code{isFile(String)} -- Tests that the named path references a file.
+@item @code{canWrite(String)} -- Tests that the file can be written to.
+This method is @code{synchronized}, so the object is locked during the check.
+@item @code{canRead(String)} -- Complement of the last method.
+@item @code{isDirectory(String)} -- Tests that the named path references
+a directory.
+@end itemize
+@item Java Helper Methods
+@itemize @bullet
+@item @code{canWriteDirectory(File)} -- Checks that the directory can be
+written to, by trying to create a temporary file in it.
+@item @code{listRoots()} -- Returns the root of a GNU filesystem i.e. `/'
+in an array.
+@item @code{isHidden(String)} -- Checks whether the file starts with `.',
+which is how files are hidden on UNIX-style systems.
+@item @code{getName(String)} -- Pulls the actual filename from the end of
+the path, by breaking off the characters after the last occurrence of the
+platform's file separator.
+@item @code{getCanonicalForm(String)} -- This converts a UNIX path to
+its canonical form by removing the `.' and `..' sections that occur within.
+@end itemize
+@end itemize
+
+@node java.io.VMObjectInputStream,java.io.VMObjectStreamClass,java.io.VMFile,java.io
+@subsection @code{java.io.VMObjectInputStream}
+
+This class consists of two methods which provide functionality used in
+deserializing an object.  @code{currentClassLoader()} provides the first
+user-defined class loader from the class context
+(@xref{gnu.classpath.VMStackWalker},) via a @code{PrivilegedAction}.
+@code{allocateObject(Class,Class,Constructor)} is a @code{native} method
+(a reference implementation is provided) which creates an object but
+calls the constructor of another class, which is a superclass of the
+object's class.
+
+@node java.io.VMObjectStreamClass,,java.io.VMObjectInputStream,java.io
+@subsection @code{java.io.VMObjectStreamClass}
+
+@code{VMObjectStreamClass} is a series of @code{static} @code{native}
+methods that provide some of the groundwork for @code{ObjectStreamClass}
+and @code{ObjectStreamField}.  @code{hasClassInitializer(Class)} works
+with the former, and checks for the presence of a static initializer.
+The remaining methods are of the form @code{setXXXNative(Field,Object,XXX)}
+and support @code{ObjectStreamField}.  One exists for each of the main types
+(boolean, float, double, long, int, short, char, byte and object) and is used
+to set the specified field in the supplied instance to the given value.
+
+A default implementation is provided for all of them, so a VM implementation
+is optional.
+
+@node java.security, java.net, java.io, Classpath Hooks
+@section java.security
+
+The @code{java.security} package provides support for Java's security
+architecture.  At present, @code{VMAccessController} represents the sole
+VM hook for this.
+
+@menu
+* java.security.VMAccessController::
+@end menu
+
+@node java.security.VMAccessController,,java.security,java.security
+@subsection @code{java.security.VMAccessController}
+
+The @code{AccessController} is used to perform privileged actions.  Its
+hook class, @code{VMAccessController}, maintains the
+@code{AccessControlContext} and the default implementation is purely
+Java-based.  The VM may choose to replace this with their own.
+The methods in the reference version are as follows:
+
+@itemize @bullet
+@item @code{pushContext(AccessControlContext)} -- Adds a new context to the
+stack for the current thread.  This is called before a privileged action
+takes place.
+@item @code{popContext()} -- Removes the top context from the stack.  This
+is performed after the privileged action takes place.
+@item @code{getContext()} -- Either derives a context based on the 
+@code{ProtectionDomain}s of the call stack (see the next method) or returns
+the top of the context stack.
+@item @code{getStack()} -- Provides access to the call stack as a pair of
+arrays of classes and method names.  The actual implementation returns
+an empty array, indicating that there are no permissions.
+@end itemize
+
+@node java.net, java.nio, java.security, Classpath Hooks
+@section java.net
+
+The @code{java.net} package is heavily reliant on access to the networking
+facilities of the underlying platform.  The VM hooks provide information
+about the available network interfaces, and access to lookup facilities
+for network addresses.
+
+@menu
+* java.net.VMInetAddress::
+* java.net.VMNetworkInterface::
+@end menu
+
+@node java.net.VMInetAddress,java.net.VMNetworkInterface,java.net,java.net
+@subsection @code{java.net.VMInetAddress}
+
+@code{VMInetAddress} is a series of @code{static} @code{native} methods
+which provide access to the platform's lookup facilities.  All the methods
+are implemented by GNU Classpath, making VM implementation optional, and
+are as follows:
 
 @itemize @bullet
-@item @code{java.lang.VMObject}
-is the bridge between the low level @code{Object} facilities such
-as making a clone, getting the class of the object and the wait/notify
-semantics.
-@item @code{java.lang.VMClassLoader}
-provides methods for defining and resolving core and primitive classes.
-@item @code{java.lang.VMSystem}
-is used to initialize the @code{System} properties, the @code{System.arraycopy}
-method and the @code{identityHashCode} of an @code{Object}.
-@item @code{java.lang.VMSecurityManager}
-provides the class context (stack trace) of the currently
-executing thread and a way to get the currently active @code{ClassLoader}.
-@item @code{java.lang.VMThrowable}
-used to hold the VM state of a throwable, created when a @code{Throwable} is
-created or the @code{fillInStacktrace()} method is called, when the actual stack
-trace is needed (a lot of exceptions are never actually used), the
-@code{getStackTrace()} method is used to create a real @code{StackTraceElement} array
-for the exception.
+@item @code{getLocalHostname()} -- Wraps the @code{gethostname} function, and
+falls back on `localhost'.
+@item @code{lookupInaddrAny()} -- Returns the value of @code{INADDR_ANY}.
+@item @code{getHostByAddr(byte[])} -- Looks up the hostname based on an IP
+address.
+@item @code{getHostByName(String)} -- The reverse of the last method, it
+returns the IP addresses which the given host name resolves to.
 @end itemize
 
+@node java.net.VMNetworkInterface,,java.net.VMInetAddress,java.net
+@subsection @code{java.net.VMNetworkInterface}
+
+@code{VMNetworkInterface} currently consists of a single @code{static}
+@code{native} method, @code{getInterfaces()}, which retrieves the
+network interfaces available on the underlying platform as a @code{Vector}.
+The current GNU Classpath implementation is a native stub.
+
+@node java.nio, java.nio.channels, java.net, Classpath Hooks
+@section java.nio
+
+The @code{java.nio} package is part of the New I/O framework added in
+Java 1.4.  This splits I/O into the concepts of @emph{buffers},
+@emph{charsets}, @emph{channels} and @emph{selectors}, and
+@code{java.nio} defines the buffer classes.  As far as native and VM
+code is concerned, the new package needs support for low-level efficient
+buffer operations.
+
+@menu
+* java.nio.VMDirectByteBuffer::
+@end menu
+
+@node java.nio.VMDirectByteBuffer,,java.nio,java.nio
+@subsection @code{java.nio.VMDirectByteBuffer}
+
+A @code{ByteBuffer} maintains a buffer of bytes, and allows it to be
+manipulated using primitive operations such as @code{get}, @code{put},
+@code{allocate} and @code{free}.  A direct buffer avoids intermediate
+copying, and uses native data which shouldn't be manipulated by a
+garbage collector.  The VM class consists of @code{static} @code{native}
+methods, all of which are given default implementations by GNU
+Classpath.
+
+@itemize @bullet
+@item @code{init()} -- Creates an instance of an appropriate
+@code{gnu.classpath.RawData} class.  This class is not garbage
+collected, is created natively and is used in the other methods to reference
+the buffered data.
+@item @code{allocate(int)} -- Allocates the memory for the buffer using
+@code{malloc} and returns a reference to the @code{RawData} class.
+@item @code{free(RawData)} -- Frees the memory used by the buffer.
+@item @code{get(RawData,int)}  -- Returns the data at the specified index.
+@item @code{get(RawData,int,byte[],int,int)} -- Copies a section of the
+data into a byte array using @code{memcpy}.
+@item @code{put(RawData,int,byte)} -- Puts the given data in the buffer
+at the specified index.
+@item @code{adjustAddress(RawData,int)} -- Adjusts the pointer into the buffer.
+@item @code{shiftDown(RawData,int,int,int)} -- Moves the content of the buffer
+at an offset down to a new offset using @code{memmove}.
+@end itemize
+ 
+@node java.nio.channels, gnu.java.nio, java.nio, Classpath Hooks
+@section java.nio.channels
+
+Channels provide the data for the buffers with the New I/O packages.
+For example, a channel may wrap a file or a socket.  The VM hooks,
+at the moment, simply allow the channels to be accessed by @code{java.io}
+streams.
+
+@menu
+* java.nio.channels.VMChannels::
+@end menu
+
+@node java.nio.channels.VMChannels,,java.nio.channels,java.nio.channels
+@subsection @code{java.nio.channels.VMChannels}
+
+@code{VMChannels} provides the methods that create the channels or
+streams.  The default implementation is in pure Java and simply wraps
+the channels in standard I/O classes from @code{java.io}.
+
+@itemize @bullet
+@item @code{createStream(Class,Channel)} -- Creates a @code{FileChannel}
+which wraps an instance of the specified stream class, created by reflection.
+This method is private, and is used by the other two.
+@item @code{newInputStream(ReadableByteChannel)} -- Wraps the channel
+in a @code{FileInputStream}.
+@item @code{newOutputStream(WritableByteChannel)} -- Wraps the channel
+in a @code{FileOutputStream}.
+@end itemize
+
+@node gnu.java.nio, Classpath Callbacks, java.nio.channels, Classpath Hooks
+@section gnu.java.nio
+
+The @code{gnu.java.nio} class provides Classpath implementations of the
+interfaces provided by @code{java.nio}.  The VM classes provide the native
+support necessary to implement @emph{pipes} and @emph{selectors}.
+
+@menu
+* gnu.java.nio.VMPipe::
+* gnu.java.nio.VMSelector::
+@end menu
+
+@node gnu.java.nio.VMPipe,gnu.java.nio.VMSelector,gnu.java.nio,gnu.java.nio
+@subsection @code{gnu.java.nio.VMPipe}
+
+@code{VMPipe} provides the native functionality for a uni-directional pipe
+between a source and a destination (sink) channel.  It consists of one 
+@code{static} @code{native} method, @code{init(PipeImpl,SelectorProvider)},
+the reference implementation of which is currently a native stub.  Ideally,
+this should initialise the pipe at the native level.
+
+@node gnu.java.nio.VMSelector,,gnu.java.nio.VMPipe,gnu.java.nio
+@subsection @code{gnu.java.nio.VMSelector}
+
+A @code{Selector} selects between multiple @code{SelectableChannel}s based
+on their readiness and a key set.  The VM hook for the Classpath implementation
+of this is @code{VMSelector}, and this allows the actual @code{select()}
+operation to be performed.  This is represented by the @code{static}
+@code{native} method, @code{select(int[],int[],int[],long)}, and a default
+implementation of this is provided.
+
+@node Classpath Callbacks, , gnu.java.nio, Classpath Hooks
 Some of the classes you implement for the VM will need to call back to
 package-private methods in Classpath:
 
@@ -221,10 +1060,8 @@ the group.
 
 @item @code{java.lang.ThreadGroup.removeThread(Thread)}
 Call this method from @code{Thread} when a @code{Thread} is stopped or destroyed.
-
 @end itemize
 
-
 @node VM Hooks, JNI Implementation, Classpath Hooks, Top
 @comment node-name, next, previous, up
 @chapter VM Hooks
@@ -234,22 +1071,51 @@ unfortunately are dependent on the internal structure of various
 classes.  This is a guide to all of the things the VM itself needs to
 know about classes.
 
+Some of the core classes, while being implemented by GNU Classpath,
+provide space for state (in the form of a @code{vmdata} object) to be
+stored by the VM, and can not be constructed normally.
+
+@itemize @bullet
+@item java.lang.Class
+@item java.lang.ClassLoader
+@end itemize
+
+The default implementations of some VM classes also follow this methodology,
+when it is intended that most VMs will keep the default.
+
+@itemize @bullet
+@item java.lang.VMThread
+@item java.lang.VMThrowable
+@end itemize
+
+Several core classes must be completely implemented by the VM for Classpath to
+work, although reference implementations are provided.  These classes are:
+
+@itemize @bullet
+@item java.lang.reflect.Constructor
+@item java.lang.reflect.Method
+@item java.lang.reflect.Field
+@end itemize
+
+The following issues are of note;
+
 @itemize @bullet
 @item @code{java.lang.Class} @*
-You, the VM, get to create this @code{Class}, so you may define the internal
-structure any way you wish.  You probably have code somewhere to
-translate your internal class structure into a @code{Class} object.  That is
-the only known place where this matters.  Some VMs do not create the
-@code{Class} object at the point where the class is defined; instead, they wait
-until a @code{Class} object is actually used.
+The GNU Classpath implementation of @code{java.lang.Class} provides an
+object for storing the internal state of the class maintained by the VM.
+This is the only known place where this matters.  The class is
+constructed with this data by the VM.  Some VMs do not create the
+@code{Class} object at the point where the class is defined; instead,
+they wait until a @code{Class} object is actually used.
 
 @item Array Classes @*
-When you are creating an array class, you should set the @code{ClassLoader} of
-the array class to the @code{ClassLoader} of its component type.  Whenever you
-add a class to a @code{ClassLoader}, you need to notify the @code{ClassLoader} and
-add the new @code{Class} to its internal cache of classes.  To do this, call
-@code{ClassLoader.addVMCreatedClass(Class)}.  @emph{Note: this is written in
-anticipation of 1.2 support and does not apply just yet.}
+When you are creating an array class, you should set the
+@code{ClassLoader} of the array class to the @code{ClassLoader} of its
+component type.  Whenever you add a class to a @code{ClassLoader}, you
+need to notify the @code{ClassLoader} and add the new @code{Class} to
+its internal cache of classes.  To do this, call
+@code{ClassLoader.addVMCreatedClass(Class)}.  @emph{Note: this is
+written in anticipation of 1.2 support and does not apply just yet.}
 
 @item Primordial Class Loader @*
 When the primordial class loader loads a class, it needs to tell
@@ -422,3 +1288,4 @@ to the value of the @code{LD_LIBRARY_PATH} environment if it exists on your plat
 @bye
 
 
+
diff --git a/doc/www.gnu.org/announce/20050630.wml b/doc/www.gnu.org/announce/20050630.wml
new file mode 100644
index 000000000..1784e2f11
--- /dev/null
+++ b/doc/www.gnu.org/announce/20050630.wml
@@ -0,0 +1,329 @@
+#!wml --include=..
+
+#use wml::std::page
+#use wml::std::lang
+#use wml::fmt::isolatin
+#use wml::std::case global=upper
+
+<lang:star:slice:>
+
+<set-var last-modified-author="prr">
+
+#include <include/macros.wml>
+
+<header title="GNU Classpath 0.16 Announcement (2005-04-29)"> 
+<pre>
+GNU Classpath 0.16 "Harmony!" released.
+
+We are pleased to announce a new developer snapshot of GNU Classpath.
+
+GNU Classpath, essential libraries for java, is a project to create free
+core class libraries for use with runtimes, compilers and tools for the
+java programming language.
+
+The GNU Classpath developer snapshot releases are not directly aimed
+at the end user but are meant to be integrated into larger development
+platforms. For example the GCC (gcj) and Kaffe projects will use the
+developer snapshots as a base for future versions.
+
+This is the first release of GNU Classpath since our Harmony
+collaboration with the Apache group.  Instructions for developers
+wanting to try out and help with the core library implementation can
+be found at: http://developer.classpath.org/
+
+New is our wiki with simple steps to setup a quick development
+environment.  For example developers using cygwin can find examples
+here: http://developer.classpath.org/mediation/ClasspathOnCygwin
+
+Some highlights of changes in this release (more extensive list below):
+
+AWT GtkScrollBar and GtkImage improvements. All image operations are
+now working correctly. Graphics2D has been upgraded to use Cairo
+0.5.x. Free Swing updates for 1.5 top-level compatibility. JTree
+interface completed. JFileChooser has been implemented. Completed
+implementations of BoxLayout, GrayFilter and SplitPane. Upgraded the
+Corba features to 1.3 and included new CORBA 2.3 features. Start of
+generic JDWP framework. And lots of bug fixes based on real world
+application usage.
+
+31 people actively contributed code to this release and made 389 CVS
+commits during the last two months of development. diffstat since 0.15:
+1248 files changed, 133649 insertions(+), 41802 deletions(-)
+
+More details about the various changes and contributions below.
+
+GNU Classpath 0.16 can be downloaded from
+ftp://ftp.gnu.org/pub/gnu/classpath/
+or one of the ftp.gnu.org mirrors
+http://www.gnu.org/order/ftp.html
+
+File: classpath-0.16.tar.gz
+MD5sum: 220a9c86719a2c6bd7ba9b9877495113
+SHA1sum: be6d30fbfe4d71015a455a367411a6d55df3484e
+
+This release depends on gtk+ 2.4 for AWT support. But gtk+ 2.6 or
+higher is recommended. Included, but not activated by default in this
+release is a Graphics2D implementation based on the Cairo Graphics
+framework (http://www.cairographics.org). Enabling this makes programs
+like JEdit start up on GNU Classpath based runtimes.  To enable this
+support install the cairo 0.5.x snapshot, configure GNU Classpath with
+--enable-gtk-cairo and make sure the system property
+gnu.java.awt.peer.gtk.Graphics=Graphics2D is set.
+
+This release was explicitly tested against the last Eclipse 3.1
+release (thanks to various eclipse hackers for the support).  For end
+user we do however recommend to use the GCJ4 packaged version of
+Eclipse 3.1 that have been prepared for the various distributions:
+
+Fedora Core
+ http://overholt.ca/wp/?p=27
+Debian GNU/Linux
+ http://gnu.wildebeest.org/diary-man-di/index.php?p=19
+Ubuntu
+ http://www.larvalstage.net/index.php?/archives/2-Introducing-Eclipse-3.1.html
+
+Not yet included is an implementation of Generic collection classes
+and classes for other 1.5 language extensions.  Work on this is being
+done on a special development branch that will be included in a future
+GNU Classpath release when free runtimes, compilers and tools have all
+been upgraded to support these new language features.
+
+One of the major focuses of the GNU Classpath project is expanding
+and using the Mauve test suite for Compatibility, Completeness and
+Correctness checking.  Various groups around GNU Classpath collaborate
+on the free software Mauve test suite which contains ~30.000 core
+library tests.  Mauve has various modules for testing core class
+library implementations, byte code verifiers, source to byte code and
+native code compiler tests.  Mauve also contains the Wonka visual test
+suite and the Jacks Compiler Killer Suite. This release passes 28801
+of the mauve core library tests.  See for more information:
+http://www.sourceware.org/mauve/
+
+Conformance reports for the included jaxp support can be found in the
+doc/README.jaxp file.
+
+The GNU Classpath developers site http://developer.classpath.org/
+provides detailed information on how to start with helping the GNU
+Classpath project and gives an overview of the core class library
+packages currently provided.  For each snapshot release generated
+documentation is provided through the GNU Classpath Tools gjdoc
+project. A documentation generation framework for java source files
+used by the GNU project. Full documentation on the currently
+implementated packages and classes can be found at:
+http://developer.classpath.org/doc/
+
+Here are answers to some questions you might have about this project and
+this release.
+
+1). Who should use this software?
+
+Although GNU Classpath is already capable of supporting many
+applications written in the java programming language, this is a
+development release. As such, there are still some unfinished
+components, and some problems are to be expected. You should install it
+if you are interested in GNU Classpath development or reporting bugs.
+We appreciate both.
+
+For end users we recommend to use one of the development environments
+based on GNU Classpath which combine the core libraries with compilers
+and other tools needed for creating applications and libraries.
+
+    * GCC with GCJ  (http://gcc.gnu.org/java/)
+    * Kaffe         (http://www.kaffe.org/)
+
+Both projects have CVS versions which track GNU Classpath closely.
+
+2). What is required to build/install/run?
+
+GNU Classpath requires a working GNU build environment and a byte code
+compiler such as jikes, gcj or kjc. When creating native code you will
+also need a working C compiler and up to date Gnome development
+libraries (gtk+, libart and gdk-pixbuf). More information on the
+precise version numbers for the tools and libraries can be found in
+the INSTALL file.
+
+You will also need a runtime environment.  Most active GNU Classpath
+hackers use JamVM (http://jamvm.sourceforge.net/) and the gcj or Jikes
+bytecode compiler (http://www.jikes.org) for quick development.  But
+other environments can certainly be used to hack on the GNU Classpath
+core libraries.
+
+For other environments that might need modified version of the current
+release see the README file.  A complete list of virtual machines and
+compilers known to be based on GNU Classpath can be found at our
+website: http://www.gnu.org/software/classpath/stories.html
+
+Note that these are just byte code execution compilers and/or
+runtimes. For development of programs written in the java programming
+language you will also need compilers and other tools for creating
+libraries and/or executables (see question 1).
+
+3). What platforms are supported?
+
+GNU/Linux and FreeBSD on x86 and powerpc are regularly tested by the
+developers.  Since 0.12 there is also support for cygwin.  We plan to
+eventually support many others.  Many more architectures and platforms
+are supported.  Check the actual runtime you use together with GNU
+Classpath for detailed information on the supported platforms.
+
+4). Where do I go for more information?
+
+The project home page with information on our mailing list can be
+found at http://www.gnu.org/software/classpath/
+
+The GNU Classpath developer recently held a conference during Fosdem.
+This was a standing room event and provided lot of communication between
+the GNU Classpath, Kaffe, GCJ, IKVM, Apache, java-gnome and Cacao hackers
+and users. The presentations of this event have been publised and should
+give a good overview of the current status and future plans of the project:
+http://www.gnu.org/software/classpath/events/escape_fosdem05.html
+
+Developers wanting to help out with the project will find more
+information and tools on http://developer.classpath.org/
+
+5). How do I extend the functionality of the core classes?
+
+Besides combining GNU Classpath with the runtimes and compilers above
+you might want to add support for additional encryption libraries and
+algorithms as provided by GNU Crypto
+(http://www.gnu.org/software/gnu-crypto/).  And for additional
+extension libraries (mail, activation, infobus, servlet, etc.) check
+out GNU ClasspathX (http://www.gnu.org/software/classpathx).
+
+Additional network protocol support is provided by a sub-project
+called GNU Classpath Inetlib, an extension library to provide extra
+network protocol support (ftp, finger, gopher) for GNU Classpath, but
+it can also standalone to ease adding http, imap, pop3 and smtp client
+support to applictions. Also distributed from
+<ftp://ftp.gnu.org/gnu/classpath/>
+
+The following projects extend the functionality of GNU Classpath
+with additional algorithms, new core packages and tools.
+All are released under GPL compatible licenses:
+
+* Jessie: A free implementation of the JSSE. Secure Sockets Extension.
+  http://www.nongnu.org/jessie/
+* Tritonus: A implementation of the javax.sound API.
+  http://www.tritonus.org/
+* gcjwebplugin: A plugin for the execution of applets in web browsers.
+  http://www.nongnu.org/gcjwebplugin/
+
+Note that the above libraries might already have been included in the
+various platforms that also integrate GNU Classpath like done by the
+Kaffe project.
+
+6). What is new in this release?
+
+New in release 0.16 (Jun 30, 2005)
+(See the ChangeLog file for a full list of changes.)
+
+* Better GTK scrollbar peer implementation when using GTK >= 2.6.
+* GdkGraphics2D has been updated to use Cairo 0.5.x APIs.
+* BufferedImage and GtkImage rewrites. All image drawing operations
+  should now work correctly (flipping requires gtk+ >= 2.6)
+* Future Graphics2D, Image and Text work is documented at:
+  http://developer.classpath.org/mediation/ClasspathGraphicsImagesText
+* Free Swing Top-Level Compatibility. JFrame, JDialog, JApplet,
+  JInternalFrame, and JWindow are now 1.5 compatible in the sense that you
+  can call add() and setLayout() directly on them, which will have the same
+  effect as calling getContentPane().add() and getContentPane().setLayout().
+* The JTree interface has been completed. JTrees now recognizes mouse clicks
+  and selections work, but the visual implementation is not yet complete.
+  Work on expansion and collapsing of the tree nodes is being implemented.
+* BoxLayout works properly now.
+* Fixed GrayFilter to actually work.
+* Metal SplitPane implemented.
+* Lots of free swing text and editor stuff work now.
+
+* When gtk+ 2.6 or higher is installed the default log handler will produce
+  stack traces whenever a WARNING, CRITICAL or ERROR message is produced.
+
+* The CORBA implementation is now a working prototype that should support
+  features up till 1.3 inclusive.
+  We would invite groups writing CORBA dependent applications to
+  try Classpath implementation, reporting any possible bugs.
+
+  The CORBA prototype is interoperable with Sun's implementation v 1.4,
+  transferring object references, primitive types, narrow and wide
+  strings, arrays, structures, trees, abstract interfaces and
+  value types (feature of CORBA 2.3) between these two platforms.
+  The remote exceptions are transferred and handled correctly.
+  The stringified object references (IORs) from various sources are
+  parsed as required.
+  The transient (for current session) and permanent (till jre restart)
+  redirections work.
+  Both Little and Big Endian encoded messages are accepted.
+  The implementation is verified using tests from the former cost.omg.org.
+  The current release includes working examples (see the examples directory),
+  demonstrating the client-server communication, using either CORBA Request
+  or IDL-based  stub (usually generated by a IDL to java compiler).
+  These examples also show how to use the Classpath CORBA naming service.
+  The IDL to java compiler is not yet written, but as our library must be
+  compatible, it naturally accepts the output of other idlj implementations.
+
+* New --with-vm-classes configure option, and new 'build' setting
+  for --with-glibj. (Only for integrators.)
+
+Runtime interface changes:
+
+* Start of a generic JDWP framework in gnu/classpath/jdwp.
+  This is unfinished, but feedback (at classpath@gnu.org) from runtime
+  hackers is greatly appreciated. Although most of the work is currently
+  being done around gcj/gij we want this framework to be as VM neutral as
+  possible. Early design is described in:
+  http://gcc.gnu.org/ml/java/2005-05/msg00260.html
+* Native method VMClass.getModifiers() now takes an additional
+  boolean parameter.
+* Deprecated native method VMClassLoader.defineClass(ClassLoader,
+  String, byte[], int, int) has been replaced by
+  VMClassLoader.defineClass(ClassLoader, String, byte[], int, int,
+  ProtectionDomain)
+* VMClassLoader.loadClass(String name, boolean resolve) is now native,
+  replacing the former version which just returned null.
+* Deprecated native method VMClassLoader.getPrimitiveClass(String) has
+  been replaced by new native method VMClassLoader.getPrimitiveClass(char).
+* Previously empty implementations of methods VMThread.countStackFrames(),
+  VMThrowable.fillInStackTrace(), and VMThrowable.getStackTrace() have
+  been removed; these methods are now native methods.
+* Fields "exceptionTypes" and "parameterTypes" have been removed from
+  Contructor.java and getExceptionTypes() and getParameterTypes() are
+  now native methods.
+
+The following people helped with this release:
+
+Andreas Jaeger (mprec updates)
+Andreas Tobler (Darwin support)
+Andrew John Hughes (Locale and net fixes, URI RFC2986 updates)
+Andrew Overholt (File locking)
+Anthony Balkissoon (JList, Free Swing 1.5 updates  and mouse event fixes)
+Archie Cobbs (VM interface updates)
+Audrius Meskauskas (Corba and HTML work)
+Bryce McKinlay (RMI work)
+Chris Burdess (XML work)
+Christian Thalinger (fdlibm updates)
+Dalibor Topic (SHA1PRNG and GdkPixbugDecoder updates)
+David Daney (BitSet bugfixes)
+David Gilbert (Lots and lots of documentation and awt/swing fixes)
+Gary Benson (MessageFormat fixes)
+Goffredo Baroncelli (HTTPURLConnection fixes)
+Jan Roehrich (JTree fixes)
+Jeroen Frijters (ClassLoader and nio cleanups)
+Ka-Hing Cheung (TreePath and TreeSelection fixes)
+Kalle Olavi Niemitalo (Build fixes)
+Keith Seitz (JDWP work)
+Kim Ho (JFileChooser implementation)
+Lillian Angel (JTree implementation and lots of bug fixes)
+Mark Wielaard (build fixes, GdkPixpufDecoder fixes and packaging)
+Michael Koch (Locale updates, bug and build fixes)
+Olga Rodimina (MenuSelectionManager)
+Robert Schuster (charset and awt fixes)
+Roman Kennke (BoxLayout, GrayFilter and SplitPane, plus bugfixes all over)
+Sven de Marothy (GtkImage rewrite, 2D, awt, free swing and date/time fixes)
+Thomas Fitzsimmons (Lot of upgrades to the gtk+ AWT and cairo 2D support)
+Tom Tromey (libgcj merging, build infrastructure and bug fixes)
+Ziga Mahkovec (Graphics2D upgraded to cairo 0.5 and new regex features)
+
+We would also like to thank the numerous bug reporters and testers!
+</pre>
+
+<footer>
diff --git a/doc/www.gnu.org/announce/20050715.wml b/doc/www.gnu.org/announce/20050715.wml
new file mode 100644
index 000000000..8f40c58a8
--- /dev/null
+++ b/doc/www.gnu.org/announce/20050715.wml
@@ -0,0 +1,132 @@
+#!wml --include=..
+
+#use wml::std::page
+#use wml::std::lang
+#use wml::fmt::isolatin
+#use wml::std::case global=upper
+
+<lang:star:slice:>
+
+<set-var last-modified-author="prr">
+
+#include <include/macros.wml>
+
+<header title="GNU Classpatchy 0.17 Announcement (2005-07-15)"> 
+<pre>
+GNU Classpatchy 0.17 released.
+
+We are pleased to announce a new developer snapshot of GNU Classpath.
+
+GNU Classpath, essential libraries for java, is a project to create free
+core class libraries for use with runtimes, compilers and tools for the
+java programming language.
+
+The GNU Classpath developer snapshot releases are not directly aimed
+at the end user but are meant to be integrated into larger development
+platforms. For example the GCC (gcj) and Kaffe projects will use the
+developer snapshots as a base for future versions.
+
+This is mainly a bug fix release for issues found with eclipse 3.1 and
+Free Swing applications just after our 0.16 release. But it also
+includes some exciting new features.
+
+Some highlights of changes in this release (more extensive list below):
+
+XML DOM, XPATH and XSL fixes. Free Swing is much more responsive.
+JInternalFram, JTree, JMenu, JTable, JButton and JFileChooser fixes.
+FileChannel lock and force implementations added. The logging
+FileHandler now rotates files. Clean locking and namespace for gtkpeer
+library. System call interrupts and timeouts are now handled correctly
+for net and nio. Corba bug fixes. Lots of documentation updates. The
+VM Integration Guide now comes with a full section on the VM/Classpath
+hooks. GNU Classpath Examples now includes a Tree World demo.
+
+21 people actively contributed code to this release and made 171 CVS
+commits during the two weeks of development. diffstat since 0.16:
+3638 files changed, 25798 insertions(+), 15596 deletions(-)
+
+More details about the various changes and contributions below.
+
+This release passes 29508 out of 30320 Mauve core library tests.
+Conformance reports for the included jaxp support can be found in the
+doc/README.jaxp file.
+
+GNU Classpath 0.17 can be downloaded from
+ftp://ftp.gnu.org/pub/gnu/classpath/
+or one of the ftp.gnu.org mirrors
+http://www.gnu.org/order/ftp.html
+
+File: classpath-0.17.tar.gz
+MD5sum: eb620987422878e05ea889d5e7496c63
+SHA1sum: 3b47cb37c91803fbc9d0426d97e1faa6a993615a
+
+The GNU Classpath developers site http://developer.classpath.org/
+provides detailed information on how to start with helping the GNU
+Classpath project and gives an overview of the core class library
+packages currently provided.  For each snapshot release generated
+documentation is provided through the GNU Classpath Tools gjdoc
+project. A documentation generation framework for java source files
+used by the GNU project. Full documentation on the currently
+implementated packages and classes can be found at:
+http://developer.classpath.org/doc/
+
+New in release 0.17 (Jul 15, 2005)
+(See the ChangeLog file for a full list of changes.)
+
+* gnu.xml fix for nodes created outside a namespace context.
+* Add support for output indenting and cdata-section-elements output
+  instruction in xml.transform.
+* xml.xpath corrections for cases where elements/attributes might have
+  been created in non-namespace-aware mode. Corrections to handling of
+  XSL variables and minor conformance updates.
+* DefaultMutableTreeNode preorder, postorder, depthFirst and breadthFirst
+  traversal enumerations implemented.
+* JInternalFrame colors and titlebar draw properly.
+* JTree is working up to par (icons, selection and keyboard traversal).
+* JMenus were made more compatible in visual and programmatic behavior.
+* JTable changeSelection and multiple selections implemented.
+* JButton and JToggleButton change states work properly now.
+* JFileChooser fixes.
+* revalidate and repaint fixes which make Free Swing much more responsive.
+* Correctly handle system call interrupts and timeouts in native nio
+  and net functions.
+* MetalIconFactory implemented.
+* Handle image loading errors correctly for gdkpixbuf and MediaTracker.
+* Added Tree World to GNU Classpath examples Free Swing demo.
+* FileChannel.lock() and FileChannel.force() implemented.
+* java.util.logging.FileHandler now rotates files.
+* Better handle GDK lock. Properly prefix gtkpeer native functions (cp_gtk).
+* Corba bug fixes and documentation updates.
+* Updated gcj build infrastructure.
+* Documentation fixes all over the place.
+  See http://developer.classpath.org/doc/
+* VM Integration Guide updates with a full section on VM/Classpath hooks.
+
+The following people helped with this release:
+
+Aaron Luchko (JDWP updates and documentation fixes)
+Andrew John Hughes (VMIntegration guide update)
+Anthony Balkissoon (Lots of Free Swing updates)
+Archie Cobbs (build and URLClassLoader updates)
+Audrius Meskauskas (Corba and text and html parser fixes)
+Casey Marshall (FileChannel lock, SystemLogger and FileHandler rotate impl.)
+Chris Burdess (Lots of gnu.xml and http protocol fixes)
+Dalibor Topic (Better DEBUG support)
+Daniel Bonniot (Serialization fixes)
+David Gilbert (Lots of documentation and MetalIconFactory implementation)
+Guilhem Lavaux (Logger bug fixes)
+Jeroen Frijters (Serialization fixes)
+Lillian Angel (Lots of Free Swing updates)
+Mark Wielaard (System call interrupts, timeouts and packaging)
+Robert Schuster (TreeNode enumerations and ActionCommand and various fixes)
+Roman Kennke (Lots of Free Swing updates)
+Sven de Marothy (GtkImage fixes)
+Thomas Fitzsimmons (gtk peer updates and restructuring)
+Simon Kitching (String cleanups and optimization suggestions)
+Tom Tromey (gcj build update)
+Ziga Mahkovec (build fixes)
+
+We would also like to thank the numerous bug reporters and testers!
+</pre>
+
+<footer>
diff --git a/doc/www.gnu.org/cp-tools/texidoclet.html b/doc/www.gnu.org/cp-tools/texidoclet.html
index 5f772d251..b203029b1 100644
--- a/doc/www.gnu.org/cp-tools/texidoclet.html
+++ b/doc/www.gnu.org/cp-tools/texidoclet.html
@@ -584,14 +584,14 @@ Please send comments on these web pages to
 send other questions to
 <A HREF="mailto:gnu@gnu.org"><EM>gnu@gnu.org</EM></A>.
 <P>
-Copyright (C) 1999 Free Software Foundation, Inc.,
-59 Temple Place - Suite 330, Boston, MA 02111, USA
+Copyright (C) 1999, 2005 Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 <P>
 Verbatim copying and distribution of this entire article is
 permitted in any medium, provided this notice is preserved.<P>
 Updated:
 
-$Date: 2005-03-13 14:38:24 $ by $Author: gnu_andrew $
+$Date: 2005-08-02 20:12:07 $ by $Author: gnu_andrew $
 <HR>
 </BODY>
 </HTML>
diff --git a/doc/www.gnu.org/docs/Makefile b/doc/www.gnu.org/docs/Makefile
index 30f86d208..1b7f8ca67 100644
--- a/doc/www.gnu.org/docs/Makefile
+++ b/doc/www.gnu.org/docs/Makefile
@@ -13,7 +13,7 @@ WML_SRC = $(patsubst ../../%, %, $(TEXI_SRC:.texinfo=.html)) $(wildcard *.wml)
 WML_OBJS = $(patsubst %.wml,%.html,$(WML_SRC))
 
 %.html : %.texinfo
-	texi2html -monolithic $<
+	texi2html -monolithic --ifinfo --ifhtml $<
 #	texi2html -monolithic $<;
 #	cp $< $@
 #	echo '#!wml --include=..' > $@
diff --git a/doc/www.gnu.org/downloads/downloads.wml b/doc/www.gnu.org/downloads/downloads.wml
index 342162bf2..48bbe5ea2 100644
--- a/doc/www.gnu.org/downloads/downloads.wml
+++ b/doc/www.gnu.org/downloads/downloads.wml
@@ -77,10 +77,10 @@ sub mylink {
 <download-block>
 
 <download
-	date="29 April 2005"
-	version="0.15"
-	url="ftp://ftp.gnu.org/gnu/classpath/classpath-0.15.tar.gz"
-	notes="http://www.gnu.org/software/classpath/announce/20050429.html"
+	date="15 July 2005"
+	version="0.17"
+	url="ftp://ftp.gnu.org/gnu/classpath/classpath-0.17.tar.gz"
+	notes="http://www.gnu.org/software/classpath/announce/20050715.html"
 >
 
 <!-- download
@@ -100,6 +100,18 @@ sub mylink {
 
 <download-block>
 <download
+	date="30 June 2005"
+	version="0.16"
+	url="ftp://ftp.gnu.org/gnu/classpath/classpath-0.16.tar.gz"
+	notes="http://www.gnu.org/software/classpath/announce/20050630.html"
+>
+<download
+	date="29 April 2005"
+	version="0.15"
+	url="ftp://ftp.gnu.org/gnu/classpath/classpath-0.15.tar.gz"
+	notes="http://www.gnu.org/software/classpath/announce/20050429.html"
+>
+<download
 	date="26 February 2005"
 	version="0.14"
 	url="ftp://ftp.gnu.org/gnu/classpath/classpath-0.14.tar.gz"
diff --git a/doc/www.gnu.org/events/events.wml b/doc/www.gnu.org/events/events.wml
index fcb3de901..decbb9689 100644
--- a/doc/www.gnu.org/events/events.wml
+++ b/doc/www.gnu.org/events/events.wml
@@ -9,17 +9,58 @@
 <boxitem>
 <strong>Upcoming Events:</strong><br>
 <ul>
-none
+[1-5 Aug 2005] <a href="http://conferences.oreillynet.com/os2005/">OSCON</a>, Portland, Oregon - USA
+<ul>
+<li><a href="http://conferences.oreillynet.com/cs/os2005/view/e_sess/6730">The State of Free JVMs</a>
+Tom Tromey</li>
 </ul>
 </boxitem>
 
 <boxitem>
 <strong>Past Events:</strong><br>
 <ul>
+
+<li>
+[29-31 May 2005] <a href="http://2005.guadec.org/">Guadec</a>, Stuttgart - Germany
+<ul>
+<li><a href="http://2005.guadec.org/schedule/gnometalks.html#eclipseyou">The Eclipse IDE and you</a>
+Ben Konrath and Andrew Overholt
+(<a href="http://overholt.ca/eclipse/GUADEC2005-EclipseIDE.pdf">slides</a>)</li>
+<li><a href="http://2005.guadec.org/schedule/gnometalks.html#javagnome">Eclipse, Java-GNOME, and GCJ</a>
+Andrew Cowie and Ben Konrath</li>
+</ul>
+<p>
+<li>
+[1-4 Jun. 2005] <a href="http://fisl.softwarelivre.org/6.0/">6th International Free Software Forum</a> (fisl), Porto Alegre/RS, Brazil
+<ul>
+<li><a href="http://fisl.softwarelivre.org/papers/pub/programacao/360">Encontro Javali: Escape the Java Trap: GNU Classpath and Kaffe</a>
+Dalibor Topic and Mark Wielaard
+(<a href="http://www.klomp.org/mark/classpath/GNUClasspathKaffe/">slides</a>)</li>
+</ul>
+<p>
+<li>
+[22-25 Jun 2005] <a href="http://www.linuxtag.org/">LinuxTag</a>, Karlsruhe - Germany
+<ul>
+<li><a href="http://www.linuxtag.org/vcc/details.pl?id=162">GNU Classpath</a>
+Robert Schuster (in German)
+(<a href="http://www.inf.fu-berlin.de/%7Erschuste/GNUClasspath-LinuxTag2005-English.pdf">slides</a>)</li>
+<li><a href="http://www.linuxtag.org/vcc/details.pl?id=166">GCJ and Classpath: A Free Implementation of the Java programming language</a>
+Andrew Haley (in English)
+(<a href="http://people.redhat.com/~aph/linuxtag.tar.gz">slides</a>)</li>
+</ul>
+<p>
 <li>[26+27 Feb. 2004] FOSDEM'05 in Brussels, Belgium. [<createlink name="Escape The Java Trap!" url="events/escape_fosdem05.html">]
-<li>[14+15 Oct. 2003] Linux Kongress '03 in Saarbr&uuml;cken, Germany.
+<p>
 <li>[21+22 Feb. 2004] FOSDEM'04 in Brussels, Belgium. [<createlink name="report" url="events/fosdem04.html">]
+<p>
 <li>[14+15 Oct. 2003] Linux Kongress '03 in Saarbr&uuml;cken, Germany.
+<ul>
+<li>Hacking on the VM Interface: GNU Classpath workshop, Mark Wielaard
+(<a href="http://www.klomp.org/mark/classpath/slides/gnu_classpath_workshop.html">slides</a>).
+<li>Agile2D: implementing Graphics2D over OpenGL, Jean-Daniel Fekete
+(<a href="http://www.klomp.org/mark/classpath/Agile2D.pdf">slides</a>).
+</ul>
+
 </ul>
 <br><br><br>
 </boxitem>
diff --git a/doc/www.gnu.org/faq/faq.wml b/doc/www.gnu.org/faq/faq.wml
index dc747cdca..67ae91ff8 100644
--- a/doc/www.gnu.org/faq/faq.wml
+++ b/doc/www.gnu.org/faq/faq.wml
@@ -304,6 +304,28 @@ be a bit picky about getting signatures from all contributors. Please do
 not see this as a personal offence.
 
 <p>Giving the copyright to the FSF also gives us a clear paper trail where changes come from, which confirms our clean-room status.
+</p>
+
+<p>
+The assignment contract commits the foundation to setting distribution terms
+that permit free redistribution.
+</p>
+
+<p>
+The assignment contract we normally use has a clause that permits you to
+use your code in proprietary programs, on 30 days' notice.
+(The 30 days' notice is there because, through a legal technicality,
+it would improve our position in a suit against a hoarder.)
+Although we believe that proprietary software is wrong, we include this
+clause because it would serve no purpose to ask you to promise not to do
+it. You're giving us a gift in the first place.
+</p>
+
+<p>
+You don't need to invoke this clause in order to distribute
+copies as free software under the GNU GPL, since everyone is
+allowed to do that.
+</p>
 
 <p>See also <a href="http://www.gnu.org/licenses/why-assign.html">http://www.gnu.org/licenses/why-assign.html</a>.
 </p>
@@ -339,7 +361,6 @@ For building the Java bytecode (.class files), one of these compilers are requir
 For building the JNI native libraries, the following are required unless --disable-gtk-peer is used as an argument to configure.
 <ul>
 <li><createlink name="GTK+ 2" url="http://www.gtk.org/">
-<li>libart-gpl
 <li>gdk-pixbuf
 </ul>
 
diff --git a/doc/www.gnu.org/home.wml b/doc/www.gnu.org/home.wml
index d5d1c872a..1d59593b8 100644
--- a/doc/www.gnu.org/home.wml
+++ b/doc/www.gnu.org/home.wml
@@ -53,7 +53,7 @@ Current snapshot releases have implementations for the following
 packages (and some subpackages) <code>java.applet, java.awt,
 java.beans, java.io, java.lang, java.math, java.net, java.rmi,
 java.security, java.sql, java.text, java.util, java.util.jar,
-java.util.zip</code>. Not all classes and methods are implemented yet,
+java.util.zip, org.omg</code>. Not all classes and methods are implemented yet,
 but most are. many of the implemented classes are already up to the
 1.2 API spec. Some are already compliant with the 1.3 and 1.4 API
 specification (there are preliminary implementations of
diff --git a/doc/www.gnu.org/include/macros.wml b/doc/www.gnu.org/include/macros.wml
index 5043ddac4..53f6f20fc 100644
--- a/doc/www.gnu.org/include/macros.wml
+++ b/doc/www.gnu.org/include/macros.wml
@@ -153,13 +153,13 @@ send other questions to
 <A HREF="mailto:gnu@gnu.org"><EM>gnu@gnu.org</EM></A>.
 <P>
 Copyright (C) 1999-2003 Free Software Foundation, Inc.,
-59 Temple Place - Suite 330, Boston, MA  02111,  USA
+51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 <P>
 Verbatim copying and distribution of this entire article is
 permitted in any medium, provided this notice is preserved.<P>
 Updated:
 </en>
-$Date: 2005-01-15 17:01:38 $ $Author: gnu_andrew $
+$Date: 2005-08-02 20:12:07 $ $Author: gnu_andrew $
 <!--
 <preserve info>
 <set-var info=<get-file-properties <__file__>>>
diff --git a/doc/www.gnu.org/newsitems.txt b/doc/www.gnu.org/newsitems.txt
index a1f8e7454..815a60ff7 100644
--- a/doc/www.gnu.org/newsitems.txt
+++ b/doc/www.gnu.org/newsitems.txt
@@ -1,3 +1,13 @@
+<newsitem date="15 Jul 2005">
+<createlink name="GNU Classpath 0.17"
+            url="announce/20050715.html">
+</newsitem>
+
+<newsitem date="30 Jun 2005">
+<createlink name="GNU Classpath 0.16"
+            url="announce/20050630.html">
+</newsitem>
+
 <newsitem date="29 Apr 2005">
 <createlink name="GNU Classpath 0.15"
             url="announce/20050429.html">
diff --git a/doc/www.gnu.org/savannah.css b/doc/www.gnu.org/savannah.css
index 217ff04db..5ec8f09c9 100644
--- a/doc/www.gnu.org/savannah.css
+++ b/doc/www.gnu.org/savannah.css
@@ -18,7 +18,7 @@
  *
  * you should have received a copy of the gnu general public license
  * along with this program; if not, write to the free software
- * foundation, inc., 59 temple place - suite 330, boston, ma  02111-1307, usa.
+ * foundation, inc., 59 temple place - suite 330, boston, ma  02110-1301, usa.
  *
  * $id: savannah.css,v 1.33 2002/10/29 10:53:12 yeupou exp $
  *
diff --git a/doc/www.gnu.org/stories.wml b/doc/www.gnu.org/stories.wml
index 19a92b365..c01ac1937 100644
--- a/doc/www.gnu.org/stories.wml
+++ b/doc/www.gnu.org/stories.wml
@@ -114,6 +114,15 @@ understand, and has many robustness features that have been the object
 of careful design.
 </project>
 
+<project url="http://www.cacaojvm.org/" name="CACAO">
+CACAO is a research Java Virtual Machine developed at the Vienna
+University of Technology. It has a compile-only approach, which means
+there is no interpreter at all but a JIT compiler ported to different
+architectures, like Alpha, i386, MIPS, PowerPC, and x86_64. The main
+aim of CACAO is to keep the JIT compilation time as small as possible
+while producing quite fast code.
+</project>
+
 </table>
 </en>