Makefile.def: Remove libjava.

2016-09-30  Andrew Haley  <aph@redhat.com>

	* Makefile.def: Remove libjava.
	* Makefile.tpl: Likewise.
	* Makefile.in: Regenerate.
	* configure.ac: Likewise.
	* configure: Likewise.
	* gcc/java: Remove.
	* libjava: Likewise.

From-SVN: r240662

23 files changed, 0 insertions, 3027 deletions

diff --git a/libjava/java/util/logging/ConsoleHandler.h b/libjava/java/util/logging/ConsoleHandler.h
deleted file mode 100644
index 0d1bbe0..0000000
--- a/libjava/java/util/logging/ConsoleHandler.h
+++ /dev/null
@@ -1,21 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_ConsoleHandler__
-#define __java_util_logging_ConsoleHandler__
-
-#pragma interface
-
-#include <java/util/logging/StreamHandler.h>
-
-class java::util::logging::ConsoleHandler : public ::java::util::logging::StreamHandler
-{
-
-public:
-  ConsoleHandler();
-  virtual void close();
-  virtual void publish(::java::util::logging::LogRecord *);
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_ConsoleHandler__
diff --git a/libjava/java/util/logging/ErrorManager.h b/libjava/java/util/logging/ErrorManager.h
deleted file mode 100644
index 58d48c9..0000000
--- a/libjava/java/util/logging/ErrorManager.h
+++ /dev/null
@@ -1,29 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_ErrorManager__
-#define __java_util_logging_ErrorManager__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-
-class java::util::logging::ErrorManager : public ::java::lang::Object
-{
-
-public:
-  ErrorManager();
-  virtual void error(::java::lang::String *, ::java::lang::Exception *, jint);
-  static const jint GENERIC_FAILURE = 0;
-  static const jint WRITE_FAILURE = 1;
-  static const jint FLUSH_FAILURE = 2;
-  static const jint CLOSE_FAILURE = 3;
-  static const jint OPEN_FAILURE = 4;
-  static const jint FORMAT_FAILURE = 5;
-private:
-  jboolean volatile __attribute__((aligned(__alignof__( ::java::lang::Object)))) everUsed;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_ErrorManager__
diff --git a/libjava/java/util/logging/FileHandler$ostr.h b/libjava/java/util/logging/FileHandler$ostr.h
deleted file mode 100644
index e34a3db..0000000
--- a/libjava/java/util/logging/FileHandler$ostr.h
+++ /dev/null
@@ -1,28 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_FileHandler$ostr__
-#define __java_util_logging_FileHandler$ostr__
-
-#pragma interface
-
-#include <java/io/FilterOutputStream.h>
-#include <gcj/array.h>
-
-
-class java::util::logging::FileHandler$ostr : public ::java::io::FilterOutputStream
-{
-
-  FileHandler$ostr(::java::util::logging::FileHandler *, ::java::io::OutputStream *);
-public:
-  void write(jint);
-  void write(JArray< jbyte > *);
-  void write(JArray< jbyte > *, jint, jint);
-public: // actually package-private
-  FileHandler$ostr(::java::util::logging::FileHandler *, ::java::io::OutputStream *, ::java::util::logging::FileHandler$ostr *);
-  ::java::util::logging::FileHandler * __attribute__((aligned(__alignof__( ::java::io::FilterOutputStream)))) this$0;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_FileHandler$ostr__
diff --git a/libjava/java/util/logging/FileHandler.h b/libjava/java/util/logging/FileHandler.h
deleted file mode 100644
index 16feec2..0000000
--- a/libjava/java/util/logging/FileHandler.h
+++ /dev/null
@@ -1,49 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_FileHandler__
-#define __java_util_logging_FileHandler__
-
-#pragma interface
-
-#include <java/util/logging/StreamHandler.h>
-
-class java::util::logging::FileHandler : public ::java::util::logging::StreamHandler
-{
-
-public:
-  FileHandler();
-  FileHandler(::java::lang::String *);
-  FileHandler(::java::lang::String *, jboolean);
-  FileHandler(::java::lang::String *, jint, jint);
-  FileHandler(::java::lang::String *, jint, jint, jboolean);
-private:
-  ::java::io::OutputStream * createFileStream(::java::lang::String *, jint, jint, jboolean, jint);
-  static ::java::lang::String * replaceFileNameEscapes(::java::lang::String *, jint, jint, jint);
-public:
-  virtual void publish(::java::util::logging::LogRecord *);
-private:
-  void rotate();
-  static jboolean has(::java::lang::String *, jchar);
-  static ::java::lang::String * PROPERTY_PREFIX;
-  static ::java::lang::String * PATTERN_KEY;
-  static ::java::lang::String * DEFAULT_PATTERN;
-  static ::java::lang::String * LIMIT_KEY;
-  static const jint DEFAULT_LIMIT = 0;
-  static ::java::lang::String * COUNT_KEY;
-  static const jint DEFAULT_COUNT = 1;
-  static ::java::lang::String * APPEND_KEY;
-  static const jboolean DEFAULT_APPEND = 0;
-  jint __attribute__((aligned(__alignof__( ::java::util::logging::StreamHandler)))) limit;
-  jint count;
-  ::java::lang::String * pattern;
-  jboolean append;
-public: // actually package-private
-  jlong written;
-private:
-  ::java::util::LinkedList * logFiles;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_FileHandler__
diff --git a/libjava/java/util/logging/Filter.h b/libjava/java/util/logging/Filter.h
deleted file mode 100644
index 23b8ca6..0000000
--- a/libjava/java/util/logging/Filter.h
+++ /dev/null
@@ -1,19 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_Filter__
-#define __java_util_logging_Filter__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-
-class java::util::logging::Filter : public ::java::lang::Object
-{
-
-public:
-  virtual jboolean isLoggable(::java::util::logging::LogRecord *) = 0;
-  static ::java::lang::Class class$;
-} __attribute__ ((java_interface));
-
-#endif // __java_util_logging_Filter__
diff --git a/libjava/java/util/logging/Formatter.h b/libjava/java/util/logging/Formatter.h
deleted file mode 100644
index def2245..0000000
--- a/libjava/java/util/logging/Formatter.h
+++ /dev/null
@@ -1,24 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_Formatter__
-#define __java_util_logging_Formatter__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-
-class java::util::logging::Formatter : public ::java::lang::Object
-{
-
-public: // actually protected
-  Formatter();
-public:
-  virtual ::java::lang::String * format(::java::util::logging::LogRecord *) = 0;
-  virtual ::java::lang::String * getHead(::java::util::logging::Handler *);
-  virtual ::java::lang::String * getTail(::java::util::logging::Handler *);
-  virtual ::java::lang::String * formatMessage(::java::util::logging::LogRecord *);
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_Formatter__
diff --git a/libjava/java/util/logging/Handler.h b/libjava/java/util/logging/Handler.h
deleted file mode 100644
index 2c722be..0000000
--- a/libjava/java/util/logging/Handler.h
+++ /dev/null
@@ -1,44 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_Handler__
-#define __java_util_logging_Handler__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-
-class java::util::logging::Handler : public ::java::lang::Object
-{
-
-public: // actually protected
-  Handler();
-public:
-  virtual void publish(::java::util::logging::LogRecord *) = 0;
-  virtual void flush() = 0;
-  virtual void close() = 0;
-  virtual ::java::util::logging::Formatter * getFormatter();
-  virtual void setFormatter(::java::util::logging::Formatter *);
-  virtual ::java::lang::String * getEncoding();
-  virtual void setEncoding(::java::lang::String *);
-  virtual ::java::util::logging::Filter * getFilter();
-  virtual void setFilter(::java::util::logging::Filter *);
-  virtual ::java::util::logging::ErrorManager * getErrorManager();
-  virtual void setErrorManager(::java::util::logging::ErrorManager *);
-public: // actually protected
-  virtual void reportError(::java::lang::String *, ::java::lang::Exception *, jint);
-public:
-  virtual ::java::util::logging::Level * getLevel();
-  virtual void setLevel(::java::util::logging::Level *);
-  virtual jboolean isLoggable(::java::util::logging::LogRecord *);
-public: // actually package-private
-  ::java::util::logging::Formatter * __attribute__((aligned(__alignof__( ::java::lang::Object)))) formatter;
-  ::java::util::logging::Filter * filter;
-  ::java::util::logging::Level * level;
-  ::java::util::logging::ErrorManager * errorManager;
-  ::java::lang::String * encoding;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_Handler__
diff --git a/libjava/java/util/logging/Level.h b/libjava/java/util/logging/Level.h
deleted file mode 100644
index 34f5160..0000000
--- a/libjava/java/util/logging/Level.h
+++ /dev/null
@@ -1,53 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_Level__
-#define __java_util_logging_Level__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-#include <gcj/array.h>
-
-
-class java::util::logging::Level : public ::java::lang::Object
-{
-
-public: // actually protected
-  Level(::java::lang::String *, jint);
-  Level(::java::lang::String *, jint, ::java::lang::String *);
-private:
-  ::java::lang::Object * readResolve();
-public:
-  virtual ::java::lang::String * getResourceBundleName();
-  virtual ::java::lang::String * getName();
-  virtual ::java::lang::String * getLocalizedName();
-  virtual ::java::lang::String * toString();
-  virtual jint intValue();
-  static ::java::util::logging::Level * parse(::java::lang::String *);
-  virtual jboolean equals(::java::lang::Object *);
-  virtual jint hashCode();
-public: // actually package-private
-  virtual jboolean isStandardLevel();
-public:
-  static ::java::util::logging::Level * OFF;
-  static ::java::util::logging::Level * SEVERE;
-  static ::java::util::logging::Level * WARNING;
-  static ::java::util::logging::Level * INFO;
-  static ::java::util::logging::Level * CONFIG;
-  static ::java::util::logging::Level * FINE;
-  static ::java::util::logging::Level * FINER;
-  static ::java::util::logging::Level * FINEST;
-  static ::java::util::logging::Level * ALL;
-private:
-  static JArray< ::java::util::logging::Level * > * knownLevels;
-  ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) name;
-  jint value;
-  ::java::lang::String * resourceBundleName;
-public: // actually package-private
-  static const jlong serialVersionUID = -8176160795706313070LL;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_Level__
diff --git a/libjava/java/util/logging/LogManager$1.h b/libjava/java/util/logging/LogManager$1.h
deleted file mode 100644
index 0d1ed21..0000000
--- a/libjava/java/util/logging/LogManager$1.h
+++ /dev/null
@@ -1,24 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_LogManager$1__
-#define __java_util_logging_LogManager$1__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-
-class java::util::logging::LogManager$1 : public ::java::lang::Object
-{
-
-public: // actually package-private
-  LogManager$1();
-public:
-  virtual ::java::lang::String * getLoggerLevel(::java::lang::String *);
-  virtual ::java::util::List * getLoggerNames();
-  virtual ::java::lang::String * getParentLoggerName(::java::lang::String *);
-  virtual void setLoggerLevel(::java::lang::String *, ::java::lang::String *);
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_LogManager$1__
diff --git a/libjava/java/util/logging/LogManager.h b/libjava/java/util/logging/LogManager.h
deleted file mode 100644
index f552d65..0000000
--- a/libjava/java/util/logging/LogManager.h
+++ /dev/null
@@ -1,77 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_LogManager__
-#define __java_util_logging_LogManager__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-extern "Java"
-{
-  namespace java
-  {
-    namespace beans
-    {
-        class PropertyChangeListener;
-        class PropertyChangeSupport;
-    }
-  }
-}
-
-class java::util::logging::LogManager : public ::java::lang::Object
-{
-
-public: // actually protected
-  LogManager();
-public:
-  static ::java::util::logging::LogManager * getLogManager();
-private:
-  static ::java::util::logging::LogManager * makeLogManager();
-  static void initLogManager();
-public:
-  virtual void addPropertyChangeListener(::java::beans::PropertyChangeListener *);
-  virtual void removePropertyChangeListener(::java::beans::PropertyChangeListener *);
-  virtual jboolean addLogger(::java::util::logging::Logger *);
-private:
-  ::java::util::logging::Logger * findAncestor(::java::util::logging::Logger *);
-public:
-  virtual ::java::util::logging::Logger * getLogger(::java::lang::String *);
-  virtual ::java::util::Enumeration * getLoggerNames();
-  virtual void reset();
-  virtual void readConfiguration();
-  virtual void readConfiguration(::java::io::InputStream *);
-  virtual ::java::lang::String * getProperty(::java::lang::String *);
-public: // actually package-private
-  static jint getIntProperty(::java::lang::String *, jint);
-  static jint getIntPropertyClamped(::java::lang::String *, jint, jint, jint);
-  static jboolean getBooleanProperty(::java::lang::String *, jboolean);
-  static ::java::util::logging::Level * getLevelProperty(::java::lang::String *, ::java::util::logging::Level *);
-  static ::java::lang::Class * getClassProperty(::java::lang::String *, ::java::lang::Class *);
-  static ::java::lang::Object * getInstanceProperty(::java::lang::String *, ::java::lang::Class *, ::java::lang::Class *);
-public:
-  virtual void checkAccess();
-private:
-  static ::java::lang::Object * createInstance(::java::lang::String *, ::java::lang::Class *, ::java::lang::String *);
-  static void warn(::java::lang::String *, ::java::lang::String *, ::java::lang::Throwable *);
-  static void warn(::java::lang::String *, ::java::lang::String *, ::java::lang::String *);
-  static void warn(::java::lang::String *, ::java::lang::String *, ::java::lang::String *, ::java::lang::Throwable *);
-  static void warn(::java::lang::String *, ::java::lang::Throwable *);
-  static ::java::lang::Class * locateClass(::java::lang::String *);
-public:
-  static ::java::util::logging::LoggingMXBean * getLoggingMXBean();
-  static ::java::lang::String * LOGGING_MXBEAN_NAME;
-private:
-  static ::java::util::logging::LogManager * logManager;
-  static ::java::util::logging::LoggingMXBean * loggingBean;
-  ::java::util::Map * __attribute__((aligned(__alignof__( ::java::lang::Object)))) loggers;
-  ::java::util::Properties * properties;
-  ::java::beans::PropertyChangeSupport * pcs;
-  static ::java::lang::String * MANAGER_PROPERTY;
-  static ::java::lang::String * CONFIG_PROPERTY;
-  static ::java::util::logging::LoggingPermission * controlPermission;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_LogManager__
diff --git a/libjava/java/util/logging/LogManager.java b/libjava/java/util/logging/LogManager.java
deleted file mode 100644
index 811310c..0000000
--- a/libjava/java/util/logging/LogManager.java
+++ /dev/null
@@ -1,991 +0,0 @@
-/* LogManager.java -- a class for maintaining Loggers and managing
-   configuration properties
-   Copyright (C) 2002, 2005, 2006, 2007 Free Software Foundation, Inc.
-
-This file is part of GNU Classpath.
-
-GNU Classpath is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-GNU Classpath is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU Classpath; see the file COPYING.  If not, write to the
-Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301 USA.
-
-Linking this library statically or dynamically with other modules is
-making a combined work based on this library.  Thus, the terms and
-conditions of the GNU General Public License cover the whole
-combination.
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent
-modules, and to copy and distribute the resulting executable under
-terms of your choice, provided that you also meet, for each linked
-independent module, the terms and conditions of the license of that
-module.  An independent module is a module which is not derived from
-or based on this library.  If you modify this library, you may extend
-this exception to your version of the library, but you are not
-obligated to do so.  If you do not wish to do so, delete this
-exception statement from your version. */
-
-
-package java.util.logging;
-
-import gnu.classpath.SystemProperties;
-
-import java.beans.PropertyChangeListener;
-import java.beans.PropertyChangeSupport;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.lang.ref.WeakReference;
-import java.net.URL;
-import java.util.Collections;
-import java.util.Enumeration;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Properties;
-import java.util.StringTokenizer;
-
-/**
- * The <code>LogManager</code> maintains a hierarchical namespace
- * of Logger objects and manages properties for configuring the logging
- * framework. There exists only one single <code>LogManager</code>
- * per virtual machine. This instance can be retrieved using the
- * static method {@link #getLogManager()}.
- *
- * <p><strong>Configuration Process:</strong> The global LogManager
- * object is created and configured when the class
- * <code>java.util.logging.LogManager</code> is initialized.
- * The configuration process includes the subsequent steps:
- *
- * <ul>
- * <li>If the system property <code>java.util.logging.manager</code>
- *     is set to the name of a subclass of
- *     <code>java.util.logging.LogManager</code>, an instance of
- *     that subclass is created and becomes the global LogManager.
- *     Otherwise, a new instance of LogManager is created.</li>
- * <li>The <code>LogManager</code> constructor tries to create
- *     a new instance of the class specified by the system
- *     property <code>java.util.logging.config.class</code>.
- *     Typically, the constructor of this class will call
- *     <code>LogManager.getLogManager().readConfiguration(java.io.InputStream)</code>
- *     for configuring the logging framework.
- *     The configuration process stops at this point if
- *     the system property <code>java.util.logging.config.class</code>
- *     is set (irrespective of whether the class constructor
- *     could be called or an exception was thrown).</li>
- *
- * <li>If the system property <code>java.util.logging.config.class</code>
- *     is <em>not</em> set, the configuration parameters are read in from
- *     a file and passed to
- *     {@link #readConfiguration(java.io.InputStream)}.
- *     The name and location of this file are specified by the system
- *     property <code>java.util.logging.config.file</code>.</li>
- * <li>If the system property <code>java.util.logging.config.file</code>
- *     is not set, however, the contents of the URL
- *     "{gnu.classpath.home.url}/logging.properties" are passed to
- *     {@link #readConfiguration(java.io.InputStream)}.
- *     Here, "{gnu.classpath.home.url}" stands for the value of
- *     the system property <code>gnu.classpath.home.url</code>.</li>
- * </ul>
- *
- * <p>The <code>LogManager</code> has a level of <code>INFO</code> by
- * default, and this will be inherited by <code>Logger</code>s unless they
- * override it either by properties or programmatically.
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class LogManager
-{
-  /**
-   * The object name for the logging management bean.
-   * @since 1.5
-   */
-  public static final String LOGGING_MXBEAN_NAME
-    = "java.util.logging:type=Logging";
-
-  /**
-   * The singleton LogManager instance.
-   */
-  private static LogManager logManager;
-
-  /**
-   * The singleton logging bean.
-   */
-  private static LoggingMXBean loggingBean;
-
-  /**
-   * The registered named loggers; maps the name of a Logger to
-   * a WeakReference to it.
-   */
-  private Map<String, WeakReference<Logger>> loggers;
-
-  /**
-   * The properties for the logging framework which have been
-   * read in last.
-   */
-  private Properties properties;
-
-  /**
-   * A delegate object that provides support for handling
-   * PropertyChangeEvents.  The API specification does not
-   * mention which bean should be the source in the distributed
-   * PropertyChangeEvents, but Mauve test code has determined that
-   * the Sun J2SE 1.4 reference implementation uses the LogManager
-   * class object. This is somewhat strange, as the class object
-   * is not the bean with which listeners have to register, but
-   * there is no reason for the GNU Classpath implementation to
-   * behave differently from the reference implementation in
-   * this case.
-   */
-  private final PropertyChangeSupport pcs = new PropertyChangeSupport( /* source bean */
-                                                                      LogManager.class);
-
-  protected LogManager()
-  {
-    loggers = new HashMap();
-  }
-
-  /**
-   * Returns the globally shared LogManager instance.
-   */
-  public static synchronized LogManager getLogManager()
-  {
-    if (logManager == null)
-      {
-        logManager = makeLogManager();
-        initLogManager();
-      }
-    return logManager;
-  }
-
-  private static final String MANAGER_PROPERTY = "java.util.logging.manager";
-
-  private static LogManager makeLogManager()
-  {
-    String managerClassName = SystemProperties.getProperty(MANAGER_PROPERTY);
-    LogManager manager = (LogManager) createInstance
-      (managerClassName, LogManager.class, MANAGER_PROPERTY);
-    if (manager == null)
-      manager = new LogManager();
-    return manager;
-  }
-
-  private static final String CONFIG_PROPERTY = "java.util.logging.config.class";
-
-  private static void initLogManager()
-  {
-    LogManager manager = getLogManager();
-    Logger.root.setLevel(Level.INFO);
-    manager.addLogger(Logger.root);
-
-    /* The Javadoc description of the class explains
-     * what is going on here.
-     */
-    Object configurator = createInstance(System.getProperty(CONFIG_PROPERTY),
-                                         /* must be instance of */ Object.class,
-                                         CONFIG_PROPERTY);
-
-    try
-      {
-        if (configurator == null)
-          manager.readConfiguration();
-      }
-    catch (IOException ex)
-      {
-        /* FIXME: Is it ok to ignore exceptions here? */
-      }
-  }
-
-  /**
-   * Registers a listener which will be notified when the
-   * logging properties are re-read.
-   */
-  public synchronized void addPropertyChangeListener(PropertyChangeListener listener)
-  {
-    /* do not register null. */
-    listener.getClass();
-
-    pcs.addPropertyChangeListener(listener);
-  }
-
-  /**
-   * Unregisters a listener.
-   *
-   * If <code>listener</code> has not been registered previously,
-   * nothing happens.  Also, no exception is thrown if
-   * <code>listener</code> is <code>null</code>.
-   */
-  public synchronized void removePropertyChangeListener(PropertyChangeListener listener)
-  {
-    if (listener != null)
-      pcs.removePropertyChangeListener(listener);
-  }
-
-  /**
-   * Adds a named logger.  If a logger with the same name has
-   * already been registered, the method returns <code>false</code>
-   * without adding the logger.
-   *
-   * <p>The <code>LogManager</code> only keeps weak references
-   * to registered loggers.  Therefore, names can become available
-   * after automatic garbage collection.
-   *
-   * @param logger the logger to be added.
-   *
-   * @return <code>true</code>if <code>logger</code> was added,
-   *         <code>false</code> otherwise.
-   *
-   * @throws NullPointerException if <code>name</code> is
-   *         <code>null</code>.
-   */
-  public synchronized boolean addLogger(Logger logger)
-  {
-    /* To developers thinking about to remove the 'synchronized'
-     * declaration from this method: Please read the comment
-     * in java.util.logging.Logger.getLogger(String, String)
-     * and make sure that whatever you change wrt. synchronization
-     * does not endanger thread-safety of Logger.getLogger.
-     * The current implementation of Logger.getLogger assumes
-     * that LogManager does its synchronization on the globally
-     * shared instance of LogManager.
-     */
-    String name;
-    WeakReference ref;
-
-    /* This will throw a NullPointerException if logger is null,
-     * as required by the API specification.
-     */
-    name = logger.getName();
-
-    ref = loggers.get(name);
-    if (ref != null)
-      {
-	if (ref.get() != null)
-	  return false;
-
-	/* There has been a logger under this name in the past,
-	 * but it has been garbage collected.
-	 */
-	loggers.remove(ref);
-      }
-
-    /* Adding a named logger requires a security permission. */
-    if ((name != null) && ! name.equals(""))
-      checkAccess();
-
-    Logger parent = findAncestor(logger);
-    loggers.put(name, new WeakReference<Logger>(logger));
-    if (parent != logger.getParent())
-      logger.setParent(parent);
-
-    // The level of the newly added logger must be specified.
-    // The easiest case is if there is a level for exactly this logger
-    // in the properties. If no such level exists the level needs to be 
-    // searched along the hirachy. So if there is a new logger 'foo.blah.blub'
-    // and an existing parent logger 'foo' the properties 'foo.blah.blub.level'
-    // and 'foo.blah.level' need to be checked. If both do not exist in the 
-    // properties the level of the new logger is set to 'null' (i.e. it uses the
-    // level of its parent 'foo').
-    Level logLevel = logger.getLevel();
-    String searchName = name;
-    String parentName = parent != null ? parent.getName() : "";
-    while (logLevel == null && ! searchName.equals(parentName))
-      {
-        logLevel = getLevelProperty(searchName + ".level", logLevel);
-        int index = searchName.lastIndexOf('.');
-        if(index > -1)
-          searchName = searchName.substring(0,index);
-        else
-          searchName = "";
-      }
-    logger.setLevel(logLevel);
-
-    /* It can happen that existing loggers should be children of
-     * the newly added logger. For example, assume that there
-     * already exist loggers under the names "", "foo", and "foo.bar.baz".
-     * When adding "foo.bar", the logger "foo.bar.baz" should change
-     * its parent to "foo.bar".
-     */
-    for (Iterator iter = loggers.keySet().iterator(); iter.hasNext();)
-      {
-	Logger possChild = (Logger) ((WeakReference) loggers.get(iter.next()))
-	  .get();
-	if ((possChild == null) || (possChild == logger)
-	    || (possChild.getParent() != parent))
-	  continue;
-	
-	if (! possChild.getName().startsWith(name))
-	  continue;
-	
-	if (possChild.getName().charAt(name.length()) != '.')
-	  continue;
-	
-	possChild.setParent(logger);
-      }
-
-    return true;
-  }
-
-  /**
-   * Finds the closest ancestor for a logger among the currently
-   * registered ones.  For example, if the currently registered
-   * loggers have the names "", "foo", and "foo.bar", the result for
-   * "foo.bar.baz" will be the logger whose name is "foo.bar".
-   *
-   * @param child a logger for whose name no logger has been
-   *        registered.
-   *
-   * @return the closest ancestor for <code>child</code>,
-   *         or <code>null</code> if <code>child</code>
-   *         is the root logger.
-   *
-   * @throws NullPointerException if <code>child</code>
-   *         is <code>null</code>.
-   */
-  private synchronized Logger findAncestor(Logger child)
-  {
-    String childName = child.getName();
-    int childNameLength = childName.length();
-    Logger best = Logger.root;
-    int bestNameLength = 0;
-
-    Logger cand;
-    int candNameLength;
-
-    if (child == Logger.root)
-      return null;
-
-    for (String candName : loggers.keySet())
-      {
-	candNameLength = candName.length();
-
-	if (candNameLength > bestNameLength
-	    && childNameLength > candNameLength
-	    && childName.startsWith(candName)
-	    && childName.charAt(candNameLength) == '.')
-	  {
-	    cand = loggers.get(candName).get();
-	    if ((cand == null) || (cand == child))
-	      continue;
-
-	    bestNameLength = candName.length();
-	    best = cand;
-	  }
-      }
-
-    return best;
-  }
-
-  /**
-   * Returns a Logger given its name.
-   *
-   * @param name the name of the logger.
-   *
-   * @return a named Logger, or <code>null</code> if there is no
-   *     logger with that name.
-   *
-   * @throw java.lang.NullPointerException if <code>name</code>
-   *     is <code>null</code>.
-   */
-  public synchronized Logger getLogger(String name)
-  {
-    WeakReference<Logger> ref;
-
-    /* Throw a NullPointerException if name is null. */
-    name.getClass();
-
-    ref = loggers.get(name);
-    if (ref != null)
-      return ref.get();
-    else
-      return null;
-  }
-
-  /**
-   * Returns an Enumeration of currently registered Logger names.
-   * Since other threads can register loggers at any time, the
-   * result could be different any time this method is called.
-   *
-   * @return an Enumeration with the names of the currently
-   *    registered Loggers.
-   */
-  public synchronized Enumeration<String> getLoggerNames()
-  {
-    return Collections.enumeration(loggers.keySet());
-  }
-
-  /**
-   * Resets the logging configuration by removing all handlers for
-   * registered named loggers and setting their level to <code>null</code>.
-   * The level of the root logger will be set to <code>Level.INFO</code>.
-   *
-   * @throws SecurityException if a security manager exists and
-   *         the caller is not granted the permission to control
-   *         the logging infrastructure.
-   */
-  public synchronized void reset() throws SecurityException
-  {
-    /* Throw a SecurityException if the caller does not have the
-     * permission to control the logging infrastructure.
-     */
-    checkAccess();
-
-    properties = new Properties();
-
-    Iterator<WeakReference<Logger>> iter = loggers.values().iterator();
-    while (iter.hasNext())
-      {
-	WeakReference<Logger> ref;
-	Logger logger;
-
-	ref = iter.next();
-	if (ref != null)
-	  {
-	    logger = ref.get();
-
-	    if (logger == null)
-	      iter.remove();
-	    else if (logger != Logger.root)
-	      {
-	        logger.resetLogger();
-	        logger.setLevel(null);
-	      }
-	  }
-      }
-
-    Logger.root.setLevel(Level.INFO);
-    Logger.root.resetLogger();
-  }
-
-  /**
-   * Configures the logging framework by reading a configuration file.
-   * The name and location of this file are specified by the system
-   * property <code>java.util.logging.config.file</code>.  If this
-   * property is not set, the URL
-   * "{gnu.classpath.home.url}/logging.properties" is taken, where
-   * "{gnu.classpath.home.url}" stands for the value of the system
-   * property <code>gnu.classpath.home.url</code>.
-   *
-   * <p>The task of configuring the framework is then delegated to
-   * {@link #readConfiguration(java.io.InputStream)}, which will
-   * notify registered listeners after having read the properties.
-   *
-   * @throws SecurityException if a security manager exists and
-   *         the caller is not granted the permission to control
-   *         the logging infrastructure, or if the caller is
-   *         not granted the permission to read the configuration
-   *         file.
-   *
-   * @throws IOException if there is a problem reading in the
-   *         configuration file.
-   */
-  public synchronized void readConfiguration()
-    throws IOException, SecurityException
-  {
-    String path;
-    InputStream inputStream;
-
-    path = System.getProperty("java.util.logging.config.file");
-    if ((path == null) || (path.length() == 0))
-      {
-        String url = (System.getProperty("gnu.classpath.home.url")
-                      + "/logging.properties");
-        try
-          {
-            inputStream = new URL(url).openStream();
-          } 
-        catch (Exception e)
-          {
-            inputStream=null;
-          }
-
-        // If no config file could be found use a default configuration.
-        if(inputStream == null)
-          {
-            String defaultConfig = "handlers = java.util.logging.ConsoleHandler   \n"
-              + ".level=INFO \n";
-            inputStream = new ByteArrayInputStream(defaultConfig.getBytes());
-          }
-      }
-    else
-      inputStream = new java.io.FileInputStream(path);
-
-    try
-      {
-        readConfiguration(inputStream);
-      }
-    finally
-      {
-        // Close the stream in order to save
-        // resources such as file descriptors.
-        inputStream.close();
-      }
-  }
-
-  public synchronized void readConfiguration(InputStream inputStream)
-    throws IOException, SecurityException
-  {
-    Properties newProperties;
-    Enumeration keys;
-
-    checkAccess();
-    newProperties = new Properties();
-    newProperties.load(inputStream);
-    reset();
-    this.properties = newProperties;
-    keys = newProperties.propertyNames();
-
-    while (keys.hasMoreElements())
-      {
-	String key = ((String) keys.nextElement()).trim();
-	String value = newProperties.getProperty(key);
-
-	if (value == null)
-	  continue;
-
-	value = value.trim();
-
-	if ("handlers".equals(key))
-	  {
-	    // In Java 5 and earlier this was specified to be
-	    // whitespace-separated, but in reality it also accepted
-	    // commas (tomcat relied on this), and in Java 6 the
-	    // documentation was updated to fit the implementation.
-	    StringTokenizer tokenizer = new StringTokenizer(value,
-							    " \t\n\r\f,");
-	    while (tokenizer.hasMoreTokens())
-	      {
-		String handlerName = tokenizer.nextToken();
-                Handler handler = (Handler)
-                  createInstance(handlerName, Handler.class, key);
-		// Tomcat also relies on the implementation ignoring
-		// items in 'handlers' which are not class names.
-		if (handler != null)
-		  Logger.root.addHandler(handler);
-	      }
-	  }
-
-	if (key.endsWith(".level"))
-	  {
-	    String loggerName = key.substring(0, key.length() - 6);
-	    Logger logger = getLogger(loggerName);
-
-	    if (logger == null)
-	      {
-		logger = Logger.getLogger(loggerName);
-		addLogger(logger);
-	      }
-            Level level = null;
-	    try
-              {
-                level = Level.parse(value);
-              }
-            catch (IllegalArgumentException e)
-              {
-                warn("bad level \'" + value + "\'", e);
-              }
-            if (level != null)
-              {
-                logger.setLevel(level);
-              }
-	    continue;
-	  }
-      }
-
-    /* The API specification does not talk about the
-     * property name that is distributed with the
-     * PropertyChangeEvent.  With test code, it could
-     * be determined that the Sun J2SE 1.4 reference
-     * implementation uses null for the property name.
-     */
-    pcs.firePropertyChange(null, null, null);
-  }
-
-  /**
-   * Returns the value of a configuration property as a String.
-   */
-  public synchronized String getProperty(String name)
-  {
-    if (properties != null)
-      return properties.getProperty(name);
-    else
-      return null;
-  }
-
-  /**
-   * Returns the value of a configuration property as an integer.
-   * This function is a helper used by the Classpath implementation
-   * of java.util.logging, it is <em>not</em> specified in the
-   * logging API.
-   *
-   * @param name the name of the configuration property.
-   *
-   * @param defaultValue the value that will be returned if the
-   *        property is not defined, or if its value is not an integer
-   *        number.
-   */
-  static int getIntProperty(String name, int defaultValue)
-  {
-    try
-      {
-	return Integer.parseInt(getLogManager().getProperty(name));
-      }
-    catch (Exception ex)
-      {
-	return defaultValue;
-      }
-  }
-
-  /**
-   * Returns the value of a configuration property as an integer,
-   * provided it is inside the acceptable range.
-   * This function is a helper used by the Classpath implementation
-   * of java.util.logging, it is <em>not</em> specified in the
-   * logging API.
-   *
-   * @param name the name of the configuration property.
-   *
-   * @param minValue the lowest acceptable value.
-   *
-   * @param maxValue the highest acceptable value.
-   *
-   * @param defaultValue the value that will be returned if the
-   *        property is not defined, or if its value is not an integer
-   *        number, or if it is less than the minimum value,
-   *        or if it is greater than the maximum value.
-   */
-  static int getIntPropertyClamped(String name, int defaultValue,
-                                   int minValue, int maxValue)
-  {
-    int val = getIntProperty(name, defaultValue);
-    if ((val < minValue) || (val > maxValue))
-      val = defaultValue;
-    return val;
-  }
-
-  /**
-   * Returns the value of a configuration property as a boolean.
-   * This function is a helper used by the Classpath implementation
-   * of java.util.logging, it is <em>not</em> specified in the
-   * logging API.
-   *
-   * @param name the name of the configuration property.
-   *
-   * @param defaultValue the value that will be returned if the
-   *        property is not defined, or if its value is neither
-   *        <code>"true"</code> nor <code>"false"</code>.
-   */
-  static boolean getBooleanProperty(String name, boolean defaultValue)
-  {
-    try
-      {
-	return (Boolean.valueOf(getLogManager().getProperty(name))).booleanValue();
-      }
-    catch (Exception ex)
-      {
-	return defaultValue;
-      }
-  }
-
-  /**
-   * Returns the value of a configuration property as a Level.
-   * This function is a helper used by the Classpath implementation
-   * of java.util.logging, it is <em>not</em> specified in the
-   * logging API.
-   *
-   * @param propertyName the name of the configuration property.
-   *
-   * @param defaultValue the value that will be returned if the
-   *        property is not defined, or if
-   *        {@link Level#parse(java.lang.String)} does not like
-   *        the property value.
-   */
-  static Level getLevelProperty(String propertyName, Level defaultValue)
-  {
-    try
-      {
-        String value = getLogManager().getProperty(propertyName);
-	if (value != null)
-	  return Level.parse(getLogManager().getProperty(propertyName));
-        else
-	   return defaultValue;
-      }
-    catch (Exception ex)
-      {
-	return defaultValue;
-      }
-  }
-
-  /**
-   * Returns the value of a configuration property as a Class.
-   * This function is a helper used by the Classpath implementation
-   * of java.util.logging, it is <em>not</em> specified in the
-   * logging API.
-   *
-   * @param propertyName the name of the configuration property.
-   *
-   * @param defaultValue the value that will be returned if the
-   *        property is not defined, or if it does not specify
-   *        the name of a loadable class.
-   */
-  static final Class getClassProperty(String propertyName, Class defaultValue)
-  {
-    String propertyValue = logManager.getProperty(propertyName);
-
-    if (propertyValue != null)
-      try
-        {
-          return locateClass(propertyValue);
-        }
-      catch (ClassNotFoundException e)
-        {
-          warn(propertyName + " = " + propertyValue, e);
-        }
-
-    return defaultValue;
-  }
-
-  static final Object getInstanceProperty(String propertyName, Class ofClass,
-                                          Class defaultClass)
-  {
-    Class klass = getClassProperty(propertyName, defaultClass);
-    if (klass == null)
-      return null;
-
-    try
-      {
-        Object obj = klass.newInstance();
-        if (ofClass.isInstance(obj))
-          return obj;
-      }
-    catch (InstantiationException e)
-      {
-        warn(propertyName + " = " + klass.getName(), e);
-      }
-    catch (IllegalAccessException e)
-      {
-        warn(propertyName + " = " + klass.getName(), e);
-      }
-
-    if (defaultClass == null)
-      return null;
-
-    try
-      {
-	return defaultClass.newInstance();
-      }
-    catch (java.lang.InstantiationException ex)
-      {
-	throw new RuntimeException(ex.getMessage());
-      }
-    catch (java.lang.IllegalAccessException ex)
-      {
-	throw new RuntimeException(ex.getMessage());
-      }
-  }
-
-  /**
-   * An instance of <code>LoggingPermission("control")</code>
-   * that is shared between calls to <code>checkAccess()</code>.
-   */
-  private static final LoggingPermission controlPermission = new LoggingPermission("control",
-                                                                                   null);
-
-  /**
-   * Checks whether the current security context allows changing
-   * the configuration of the logging framework.  For the security
-   * context to be trusted, it has to be granted
-   * a LoggingPermission("control").
-   *
-   * @throws SecurityException if a security manager exists and
-   *         the caller is not granted the permission to control
-   *         the logging infrastructure.
-   */
-  public void checkAccess() throws SecurityException
-  {
-    SecurityManager sm = System.getSecurityManager();
-    if (sm != null)
-      sm.checkPermission(controlPermission);
-  }
-
-  /**
-   * Creates a new instance of a class specified by name and verifies
-   * that it is an instance (or subclass of) a given type.
-   *
-   * @param className the name of the class of which a new instance
-   *        should be created.
-   *
-   * @param type the object created must be an instance of
-   * <code>type</code> or any subclass of <code>type</code>
-   *
-   * @param property the system property to reference in error
-   * messages
-   *
-   * @return the new instance, or <code>null</code> if
-   *         <code>className</code> is <code>null</code>, if no class
-   *         with that name could be found, if there was an error
-   *         loading that class, or if the constructor of the class
-   *         has thrown an exception.
-   */
-  private static final Object createInstance(String className, Class type,
-                                             String property)
-  {
-    Class klass = null;
-
-    if ((className == null) || (className.length() == 0))
-      return null;
-
-    try
-      {
-        klass = locateClass(className);
-        if (type.isAssignableFrom(klass))
-          return klass.newInstance();
-        warn(property, className, "not an instance of " + type.getName());
-      }
-    catch (ClassNotFoundException e)
-      {
-        warn(property, className, "class not found", e);
-      }
-    catch (IllegalAccessException e)
-      {
-        warn(property, className, "illegal access", e);
-      }
-    catch (InstantiationException e)
-      {
-        warn(property, className, e);
-      }
-    catch (java.lang.LinkageError e)
-      {
-        warn(property, className, "linkage error", e);
-      }
-
-    return null;
-  }
-
-  private static final void warn(String property, String klass, Throwable t)
-  {
-    warn(property, klass, null, t);
-  }
-
-  private static final void warn(String property, String klass, String msg)
-  {
-    warn(property, klass, msg, null);
-  }
-
-  private static final void warn(String property, String klass, String msg,
-                                 Throwable t)
-  {
-    warn("error instantiating '" + klass + "' referenced by " + property +
-         (msg == null ? "" : ", " + msg), t);
-  }
-
-  /**
-   * All debug warnings go through this method.
-   */
-
-  private static final void warn(String msg, Throwable t)
-  {
-    System.err.println("WARNING: " + msg);
-    if (t != null)
-      t.printStackTrace(System.err);
-  }
-
-  /**
-   * Locates a class by first checking the system class loader and
-   * then checking the context class loader.
-   *
-   * @param name the fully qualified name of the Class to locate
-   * @return Class the located Class
-   */
-
-  private static Class locateClass(String name) throws ClassNotFoundException
-  {
-    // GCJ LOCAL
-    // Unfortunately this can be called during bootstrap when
-    // Thread.currentThread() will return null.
-    // See bug #27658
-    Thread t = Thread.currentThread();
-    ClassLoader loader = (t == null) ? null : t.getContextClassLoader();
-    try
-      {
-        return Class.forName(name, true, loader);
-      }
-    catch (ClassNotFoundException e)
-      {
-        loader = ClassLoader.getSystemClassLoader();
-        return Class.forName(name, true, loader);
-      }
-  }
-
-  /**
-   * Return the logging bean.  There is a single logging bean per
-   * VM instance.
-   * @since 1.5
-   */
-  public static synchronized LoggingMXBean getLoggingMXBean()
-  {
-    if (loggingBean == null)
-      {
-        loggingBean = new LoggingMXBean()
-        {
-          public String getLoggerLevel(String logger)
-          {
-            LogManager mgr = getLogManager();
-            Logger l = mgr.getLogger(logger);
-            if (l == null)
-              return null;
-            Level lev = l.getLevel();
-            if (lev == null)
-              return "";
-            return lev.getName();
-          }
-
-          public List getLoggerNames()
-          {
-            LogManager mgr = getLogManager();
-            // This is inefficient, but perhaps better for maintenance.
-            return Collections.list(mgr.getLoggerNames());
-          }
-
-          public String getParentLoggerName(String logger)
-          {
-            LogManager mgr = getLogManager();
-            Logger l = mgr.getLogger(logger);
-            if (l == null)
-              return null;
-            l = l.getParent();
-            if (l == null)
-              return "";
-            return l.getName();
-          }
-
-          public void setLoggerLevel(String logger, String level)
-          {
-            LogManager mgr = getLogManager();
-            Logger l = mgr.getLogger(logger);
-            if (l == null)
-              throw new IllegalArgumentException("no logger named " + logger);
-            Level newLevel;
-            if (level == null)
-              newLevel = null;
-            else
-              newLevel = Level.parse(level);
-            l.setLevel(newLevel);
-          }
-        };
-      }
-    return loggingBean;
-  }
-}
diff --git a/libjava/java/util/logging/LogRecord.h b/libjava/java/util/logging/LogRecord.h
deleted file mode 100644
index 4454159..0000000
--- a/libjava/java/util/logging/LogRecord.h
+++ /dev/null
@@ -1,70 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_LogRecord__
-#define __java_util_logging_LogRecord__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-#include <gcj/array.h>
-
-
-class java::util::logging::LogRecord : public ::java::lang::Object
-{
-
-public:
-  LogRecord(::java::util::logging::Level *, ::java::lang::String *);
-private:
-  void readObject(::java::io::ObjectInputStream *);
-  void writeObject(::java::io::ObjectOutputStream *);
-public:
-  virtual ::java::lang::String * getLoggerName();
-  virtual void setLoggerName(::java::lang::String *);
-  virtual ::java::util::ResourceBundle * getResourceBundle();
-  virtual void setResourceBundle(::java::util::ResourceBundle *);
-  virtual ::java::lang::String * getResourceBundleName();
-  virtual void setResourceBundleName(::java::lang::String *);
-  virtual ::java::util::logging::Level * getLevel();
-  virtual void setLevel(::java::util::logging::Level *);
-private:
-  static jlong allocateSeqNum();
-public:
-  virtual jlong getSequenceNumber();
-  virtual void setSequenceNumber(jlong);
-  virtual ::java::lang::String * getSourceClassName();
-  virtual void setSourceClassName(::java::lang::String *);
-  virtual ::java::lang::String * getSourceMethodName();
-  virtual void setSourceMethodName(::java::lang::String *);
-  virtual ::java::lang::String * getMessage();
-  virtual void setMessage(::java::lang::String *);
-  virtual JArray< ::java::lang::Object * > * getParameters();
-  virtual void setParameters(JArray< ::java::lang::Object * > *);
-  virtual jint getThreadID();
-  virtual void setThreadID(jint);
-  virtual jlong getMillis();
-  virtual void setMillis(jlong);
-  virtual ::java::lang::Throwable * getThrown();
-  virtual void setThrown(::java::lang::Throwable *);
-private:
-  ::java::util::logging::Level * __attribute__((aligned(__alignof__( ::java::lang::Object)))) level;
-  jlong sequenceNumber;
-  ::java::lang::String * sourceClassName;
-  ::java::lang::String * sourceMethodName;
-  ::java::lang::String * message;
-  jint threadID;
-  jlong millis;
-  ::java::lang::Throwable * thrown;
-  ::java::lang::String * loggerName;
-  ::java::lang::String * resourceBundleName;
-  JArray< ::java::lang::Object * > * parameters;
-  ::java::util::ResourceBundle * bundle;
-public: // actually package-private
-  static const jlong serialVersionUID = 5372048053134512534LL;
-private:
-  static jlong lastSeqNum;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_LogRecord__
diff --git a/libjava/java/util/logging/Logger$1.h b/libjava/java/util/logging/Logger$1.h
deleted file mode 100644
index 69189e7..0000000
--- a/libjava/java/util/logging/Logger$1.h
+++ /dev/null
@@ -1,21 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_Logger$1__
-#define __java_util_logging_Logger$1__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-
-class java::util::logging::Logger$1 : public ::java::lang::Object
-{
-
-public: // actually package-private
-  Logger$1();
-public:
-  virtual ::java::lang::Object * run();
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_Logger$1__
diff --git a/libjava/java/util/logging/Logger.h b/libjava/java/util/logging/Logger.h
deleted file mode 100644
index c73a8d3..0000000
--- a/libjava/java/util/logging/Logger.h
+++ /dev/null
@@ -1,90 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_Logger__
-#define __java_util_logging_Logger__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-#include <gcj/array.h>
-
-
-class java::util::logging::Logger : public ::java::lang::Object
-{
-
-public: // actually protected
-  Logger(::java::lang::String *, ::java::lang::String *);
-public:
-  static ::java::util::logging::Logger * getLogger(::java::lang::String *);
-  static ::java::util::logging::Logger * getLogger(::java::lang::String *, ::java::lang::String *);
-  static ::java::util::logging::Logger * getAnonymousLogger();
-  static ::java::util::logging::Logger * getAnonymousLogger(::java::lang::String *);
-  virtual ::java::lang::String * getResourceBundleName();
-  virtual ::java::util::ResourceBundle * getResourceBundle();
-  virtual ::java::util::logging::Level * getLevel();
-  virtual jboolean isLoggable(::java::util::logging::Level *);
-  virtual void setLevel(::java::util::logging::Level *);
-  virtual ::java::util::logging::Filter * getFilter();
-  virtual void setFilter(::java::util::logging::Filter *);
-  virtual ::java::lang::String * getName();
-  virtual void log(::java::util::logging::LogRecord *);
-  virtual void log(::java::util::logging::Level *, ::java::lang::String *);
-  virtual void log(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::Object *);
-  virtual void log(::java::util::logging::Level *, ::java::lang::String *, JArray< ::java::lang::Object * > *);
-  virtual void log(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::Throwable *);
-  virtual void logp(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *);
-  virtual void logp(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, ::java::lang::Object *);
-private:
-  ::java::util::ResourceBundle * findResourceBundle();
-  void logImpl(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::Object * > *);
-public:
-  virtual void logp(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::Object * > *);
-  virtual void logp(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, ::java::lang::Throwable *);
-  virtual void logrb(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *);
-  virtual void logrb(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, ::java::lang::Object *);
-  virtual void logrb(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::Object * > *);
-  virtual void logrb(::java::util::logging::Level *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, ::java::lang::Throwable *);
-  virtual void entering(::java::lang::String *, ::java::lang::String *);
-  virtual void entering(::java::lang::String *, ::java::lang::String *, ::java::lang::Object *);
-  virtual void entering(::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::Object * > *);
-  virtual void exiting(::java::lang::String *, ::java::lang::String *);
-  virtual void exiting(::java::lang::String *, ::java::lang::String *, ::java::lang::Object *);
-  virtual void throwing(::java::lang::String *, ::java::lang::String *, ::java::lang::Throwable *);
-  virtual void severe(::java::lang::String *);
-  virtual void warning(::java::lang::String *);
-  virtual void info(::java::lang::String *);
-  virtual void config(::java::lang::String *);
-  virtual void fine(::java::lang::String *);
-  virtual void finer(::java::lang::String *);
-  virtual void finest(::java::lang::String *);
-  virtual void addHandler(::java::util::logging::Handler *);
-  virtual void removeHandler(::java::util::logging::Handler *);
-  virtual JArray< ::java::util::logging::Handler * > * getHandlers();
-  virtual jboolean getUseParentHandlers();
-  virtual void setUseParentHandlers(jboolean);
-  virtual ::java::util::logging::Logger * getParent();
-  virtual void setParent(::java::util::logging::Logger *);
-private:
-  ::java::lang::StackTraceElement * getCallerStackFrame();
-public: // actually package-private
-  virtual void resetLogger();
-  static ::java::util::logging::Logger * root;
-public:
-  static ::java::util::logging::Logger * global;
-private:
-  ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) name;
-  ::java::lang::String * resourceBundleName;
-  ::java::util::ResourceBundle * resourceBundle;
-  ::java::util::logging::Filter * filter;
-  ::java::util::List * handlerList;
-  JArray< ::java::util::logging::Handler * > * handlers;
-  jboolean anonymous;
-  jboolean useParentHandlers;
-  ::java::util::logging::Level * level;
-  ::java::util::logging::Logger * parent;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_Logger__
diff --git a/libjava/java/util/logging/Logger.java b/libjava/java/util/logging/Logger.java
deleted file mode 100644
index 04f24d3..0000000
--- a/libjava/java/util/logging/Logger.java
+++ /dev/null
@@ -1,1206 +0,0 @@
-/* Logger.java -- a class for logging messages
-   Copyright (C) 2002, 2004, 2006, 2007 Free Software Foundation, Inc.
-
-This file is part of GNU Classpath.
-
-GNU Classpath is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-GNU Classpath is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU Classpath; see the file COPYING.  If not, write to the
-Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301 USA.
-
-Linking this library statically or dynamically with other modules is
-making a combined work based on this library.  Thus, the terms and
-conditions of the GNU General Public License cover the whole
-combination.
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent
-modules, and to copy and distribute the resulting executable under
-terms of your choice, provided that you also meet, for each linked
-independent module, the terms and conditions of the license of that
-module.  An independent module is a module which is not derived from
-or based on this library.  If you modify this library, you may extend
-this exception to your version of the library, but you are not
-obligated to do so.  If you do not wish to do so, delete this
-exception statement from your version. */
-
-
-package java.util.logging;
-
-import java.util.List;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-
-/**
- * A Logger is used for logging information about events. Usually, there
- * is a seprate logger for each subsystem or component, although there
- * is a shared instance for components that make only occasional use of
- * the logging framework.
- *
- * <p>It is common to name a logger after the name of a corresponding
- * Java package.  Loggers are organized into a hierarchical namespace;
- * for example, the logger <code>"org.gnu.foo"</code> is the
- * <em>parent</em> of logger <code>"org.gnu.foo.bar"</code>.
- *
- * <p>A logger for a named subsystem can be obtained through {@link
- * java.util.logging.Logger#getLogger(java.lang.String)}.  However,
- * only code which has been granted the permission to control the
- * logging infrastructure will be allowed to customize that logger.
- * Untrusted code can obtain a private, anonymous logger through
- * {@link #getAnonymousLogger()} if it wants to perform any
- * modifications to the logger.
- *
- * <p>FIXME: Write more documentation.
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class Logger
-{
-
-  static final Logger root = new Logger("", null);
-
-  /**
-   * A logger provided to applications that make only occasional use
-   * of the logging framework, typically early prototypes.  Serious
-   * products are supposed to create and use their own Loggers, so
-   * they can be controlled individually.
-   */
-  public static final Logger global;
-
-  static
-    {
-      // Our class might be initialized from an unprivileged context
-      global = (Logger) AccessController.doPrivileged
-	(new PrivilegedAction()
-	  {
-	    public Object run()
-	    {
-	      return getLogger("global");
-	    }
-	  });
-    }
-
-
-  /**
-   * The name of the Logger, or <code>null</code> if the logger is
-   * anonymous.
-   *
-   * <p>A previous version of the GNU Classpath implementation granted
-   * untrusted code the permission to control any logger whose name
-   * was null.  However, test code revealed that the Sun J2SE 1.4
-   * reference implementation enforces the security control for any
-   * logger that was not created through getAnonymousLogger, even if
-   * it has a null name.  Therefore, a separate flag {@link
-   * Logger#anonymous} was introduced.
-   */
-  private final String name;
-
-
-  /**
-   * The name of the resource bundle used for localization.
-   *
-   * <p>This variable cannot be declared as <code>final</code>
-   * because its value can change as a result of calling
-   * getLogger(String,String).
-   */
-  private String resourceBundleName;
-
-
-  /**
-   * The resource bundle used for localization.
-   *
-   * <p>This variable cannot be declared as <code>final</code>
-   * because its value can change as a result of calling
-   * getLogger(String,String).
-   */
-  private ResourceBundle resourceBundle;
-
-  private Filter filter;
-
-  private final List handlerList = new java.util.ArrayList(4);
-  private Handler[] handlers = new Handler[0];
-
-  /**
-   * Indicates whether or not this logger is anonymous.  While
-   * a LoggingPermission is required for any modifications to
-   * a normal logger, untrusted code can obtain an anonymous logger
-   * and modify it according to its needs.
-   *
-   * <p>A previous version of the GNU Classpath implementation
-   * granted access to every logger whose name was null.
-   * However, test code revealed that the Sun J2SE 1.4 reference
-   * implementation enforces the security control for any logger
-   * that was not created through getAnonymousLogger, even
-   * if it has a null name.
-   */
-  private boolean anonymous;
-
-
-  private boolean useParentHandlers;
-
-  private Level level;
-
-  private Logger parent;
-
-  /**
-   * Constructs a Logger for a subsystem.  Most applications do not
-   * need to create new Loggers explicitly; instead, they should call
-   * the static factory methods
-   * {@link #getLogger(java.lang.String,java.lang.String) getLogger}
-   * (with ResourceBundle for localization) or
-   * {@link #getLogger(java.lang.String) getLogger} (without
-   * ResourceBundle), respectively.
-   *
-   * @param name the name for the logger, for example "java.awt"
-   *             or "com.foo.bar". The name should be based on
-   *             the name of the package issuing log records
-   *             and consist of dot-separated Java identifiers.
-   *
-   * @param resourceBundleName the name of a resource bundle
-   *        for localizing messages, or <code>null</code>
-   *	    to indicate that messages do not need to be localized.
-   *
-   * @throws java.util.MissingResourceException if
-   *         <code>resourceBundleName</code> is not <code>null</code>
-   *         and no such bundle could be located.
-   */
-  protected Logger(String name, String resourceBundleName)
-    throws MissingResourceException
-  {
-    this.name = name;
-    this.resourceBundleName = resourceBundleName;
-
-    if (resourceBundleName == null)
-      resourceBundle = null;
-    else
-      resourceBundle = ResourceBundle.getBundle(resourceBundleName);
-
-    level = null;
-
-    /* This is null when the root logger is being constructed,
-     * and the root logger afterwards.
-     */
-    parent = root;
-
-    useParentHandlers = (parent != null);
-  }
-
-
-
-  /**
-   * Finds a registered logger for a subsystem, or creates one in
-   * case no logger has been registered yet.
-   *
-   * @param name the name for the logger, for example "java.awt"
-   *             or "com.foo.bar". The name should be based on
-   *             the name of the package issuing log records
-   *             and consist of dot-separated Java identifiers.
-   *
-   * @throws IllegalArgumentException if a logger for the subsystem
-   *         identified by <code>name</code> has already been created,
-   *         but uses a a resource bundle for localizing messages.
-   *
-   * @throws NullPointerException if <code>name</code> is
-   *         <code>null</code>.
-   *
-   * @return a logger for the subsystem specified by <code>name</code>
-   *         that does not localize messages.
-   */
-  public static Logger getLogger(String name)
-  {
-    return getLogger(name, null);
-  }
-
-    
-  /**
-   * Finds a registered logger for a subsystem, or creates one in case
-   * no logger has been registered yet.
-   *
-   * <p>If a logger with the specified name has already been
-   * registered, the behavior depends on the resource bundle that is
-   * currently associated with the existing logger.
-   *
-   * <ul><li>If the existing logger uses the same resource bundle as
-   * specified by <code>resourceBundleName</code>, the existing logger
-   * is returned.</li>
-   *
-   * <li>If the existing logger currently does not localize messages,
-   * the existing logger is modified to use the bundle specified by
-   * <code>resourceBundleName</code>.  The existing logger is then
-   * returned.  Therefore, all subsystems currently using this logger
-   * will produce localized messages from now on.</li>
-   *
-   * <li>If the existing logger already has an associated resource
-   * bundle, but a different one than specified by
-   * <code>resourceBundleName</code>, an
-   * <code>IllegalArgumentException</code> is thrown.</li></ul>
-   *
-   * @param name the name for the logger, for example "java.awt"
-   *             or "org.gnu.foo". The name should be based on
-   *             the name of the package issuing log records
-   *             and consist of dot-separated Java identifiers.
-   *
-   * @param resourceBundleName the name of a resource bundle
-   *        for localizing messages, or <code>null</code>
-   *	    to indicate that messages do not need to be localized.
-   *
-   * @return a logger for the subsystem specified by <code>name</code>.
-   *
-   * @throws java.util.MissingResourceException if
-   *         <code>resourceBundleName</code> is not <code>null</code>
-   *         and no such bundle could be located.   
-   *
-   * @throws IllegalArgumentException if a logger for the subsystem
-   *         identified by <code>name</code> has already been created,
-   *         but uses a different resource bundle for localizing
-   *         messages.
-   *
-   * @throws NullPointerException if <code>name</code> is
-   *         <code>null</code>.
-   */
-  public static Logger getLogger(String name, String resourceBundleName)
-  {
-    LogManager lm = LogManager.getLogManager();
-    Logger     result;
-
-    if (name == null)
-      throw new NullPointerException();
-
-    /* Without synchronized(lm), it could happen that another thread
-     * would create a logger between our calls to getLogger and
-     * addLogger.  While addLogger would indicate this by returning
-     * false, we could not be sure that this other logger was still
-     * existing when we called getLogger a second time in order
-     * to retrieve it -- note that LogManager is only allowed to
-     * keep weak references to registered loggers, so Loggers
-     * can be garbage collected at any time in general, and between
-     * our call to addLogger and our second call go getLogger
-     * in particular.
-     *
-     * Of course, we assume here that LogManager.addLogger etc.
-     * are synchronizing on the global LogManager object. There
-     * is a comment in the implementation of LogManager.addLogger
-     * referring to this comment here, so that any change in
-     * the synchronization of LogManager will be reflected here.
-     */
-    synchronized (lm)
-    {
-      result = lm.getLogger(name);
-      if (result == null)
-      {
-	boolean couldBeAdded;
-
-	result = new Logger(name, resourceBundleName);
-	couldBeAdded = lm.addLogger(result);
-	if (!couldBeAdded)
-	  throw new IllegalStateException("cannot register new logger");
-      }
-      else
-      {
-	/* The logger already exists. Make sure it uses
-	 * the same resource bundle for localizing messages.
-	 */
-	String existingBundleName = result.getResourceBundleName();
-
-	/* The Sun J2SE 1.4 reference implementation will return the
-	 * registered logger object, even if it does not have a resource
-	 * bundle associated with it. However, it seems to change the
-	 * resourceBundle of the registered logger to the bundle
-	 * whose name was passed to getLogger.
-	 */
-	if ((existingBundleName == null) && (resourceBundleName != null))
-	{
-	  /* If ResourceBundle.getBundle throws an exception, the
-	   * existing logger will be unchanged.  This would be
-	   * different if the assignment to resourceBundleName
-	   * came first.
-	   */
-	  result.resourceBundle = ResourceBundle.getBundle(resourceBundleName);
-	  result.resourceBundleName = resourceBundleName;
-	  return result;
-	}
-
-	if ((existingBundleName != resourceBundleName)
-	    && ((existingBundleName == null)
-		|| !existingBundleName.equals(resourceBundleName)))
-	{
-	  throw new IllegalArgumentException();
-	}
-      }
-    }
-
-    return result;
-  }
-
-  
-  /**
-   * Creates a new, unnamed logger.  Unnamed loggers are not
-   * registered in the namespace of the LogManager, and no special
-   * security permission is required for changing their state.
-   * Therefore, untrusted applets are able to modify their private
-   * logger instance obtained through this method.
-   *
-   * <p>The parent of the newly created logger will the the root
-   * logger, from which the level threshold and the handlers are
-   * inherited.
-   */
-  public static Logger getAnonymousLogger()
-  {
-    return getAnonymousLogger(null);
-  }
-
-
-  /**
-   * Creates a new, unnamed logger.  Unnamed loggers are not
-   * registered in the namespace of the LogManager, and no special
-   * security permission is required for changing their state.
-   * Therefore, untrusted applets are able to modify their private
-   * logger instance obtained through this method.
-   *
-   * <p>The parent of the newly created logger will the the root
-   * logger, from which the level threshold and the handlers are
-   * inherited.
-   *
-   * @param resourceBundleName the name of a resource bundle
-   *        for localizing messages, or <code>null</code>
-   *	    to indicate that messages do not need to be localized.
-   *
-   * @throws java.util.MissingResourceException if
-   *         <code>resourceBundleName</code> is not <code>null</code>
-   *         and no such bundle could be located.
-   */
-  public static Logger getAnonymousLogger(String resourceBundleName)
-    throws MissingResourceException
-  {
-    Logger  result;
-
-    result = new Logger(null, resourceBundleName);
-    result.anonymous = true;
-    return result;
-  }
-
-
-  /**
-   * Returns the name of the resource bundle that is being used for
-   * localizing messages.
-   *
-   * @return the name of the resource bundle used for localizing messages,
-   *         or <code>null</code> if the parent's resource bundle
-   *         is used for this purpose.
-   */
-  public synchronized String getResourceBundleName()
-  {
-    return resourceBundleName;
-  }
-
-
-  /**
-   * Returns the resource bundle that is being used for localizing
-   * messages.
-   *
-   * @return the resource bundle used for localizing messages,
-   *         or <code>null</code> if the parent's resource bundle
-   *         is used for this purpose.
-   */
-  public synchronized ResourceBundle getResourceBundle()
-  {
-    return resourceBundle;
-  }
-
-
-  /**
-   * Returns the severity level threshold for this <code>Handler</code>.
-   * All log records with a lower severity level will be discarded;
-   * a log record of the same or a higher level will be published
-   * unless an installed <code>Filter</code> decides to discard it.
-   *
-   * @return the severity level below which all log messages will be
-   *         discarded, or <code>null</code> if the logger inherits
-   *         the threshold from its parent.
-   */
-  public synchronized Level getLevel()
-  {
-    return level;
-  }
-
-
-  /**
-   * Returns whether or not a message of the specified level
-   * would be logged by this logger.
-   *
-   * @throws NullPointerException if <code>level</code>
-   *         is <code>null</code>.
-   */
-  public synchronized boolean isLoggable(Level level)
-  {
-    if (this.level != null)
-      return this.level.intValue() <= level.intValue();
-
-    if (parent != null)
-      return parent.isLoggable(level);
-    else
-      return false;
-  }
-
-
-  /**
-   * Sets the severity level threshold for this <code>Handler</code>.
-   * All log records with a lower severity level will be discarded
-   * immediately.  A log record of the same or a higher level will be
-   * published unless an installed <code>Filter</code> decides to
-   * discard it.
-   *
-   * @param level the severity level below which all log messages
-   *              will be discarded, or <code>null</code> to
-   *              indicate that the logger should inherit the
-   *              threshold from its parent.
-   *
-   * @throws SecurityException if this logger is not anonymous, a
-   *     security manager exists, and the caller is not granted
-   *     the permission to control the logging infrastructure by
-   *     having LoggingPermission("control").  Untrusted code can
-   *     obtain an anonymous logger through the static factory method
-   *     {@link #getAnonymousLogger(java.lang.String) getAnonymousLogger}.
-   */
-  public synchronized void setLevel(Level level)
-  {
-    /* An application is allowed to control an anonymous logger
-     * without having the permission to control the logging
-     * infrastructure.
-     */
-    if (!anonymous)
-      LogManager.getLogManager().checkAccess();
-
-    this.level = level;
-  }
-
-
-  public synchronized Filter getFilter()
-  {
-    return filter;
-  }
-
-
-  /**
-   * @throws SecurityException if this logger is not anonymous, a
-   *     security manager exists, and the caller is not granted
-   *     the permission to control the logging infrastructure by
-   *     having LoggingPermission("control").  Untrusted code can
-   *     obtain an anonymous logger through the static factory method
-   *     {@link #getAnonymousLogger(java.lang.String) getAnonymousLogger}.
-   */
-  public synchronized void setFilter(Filter filter)
-    throws SecurityException
-  {
-    /* An application is allowed to control an anonymous logger
-     * without having the permission to control the logging
-     * infrastructure.
-     */
-    if (!anonymous)
-      LogManager.getLogManager().checkAccess();
-
-    this.filter = filter;
-  }
-
-
-
-
-  /**
-   * Returns the name of this logger.
-   *
-   * @return the name of this logger, or <code>null</code> if
-   *         the logger is anonymous.
-   */
-  public String getName()
-  {
-    /* Note that the name of a logger cannot be changed during
-     * its lifetime, so no synchronization is needed.
-     */
-    return name;
-  }
-
-
-  /**
-   * Passes a record to registered handlers, provided the record
-   * is considered as loggable both by {@link #isLoggable(Level)}
-   * and a possibly installed custom {@link #setFilter(Filter) filter}.
-   *
-   * <p>If the logger has been configured to use parent handlers,
-   * the record will be forwarded to the parent of this logger
-   * in addition to being processed by the handlers registered with
-   * this logger.
-   *
-   * <p>The other logging methods in this class are convenience methods
-   * that merely create a new LogRecord and pass it to this method.
-   * Therefore, subclasses usually just need to override this single
-   * method for customizing the logging behavior.
-   *
-   * @param record the log record to be inspected and possibly forwarded.
-   */
-  public synchronized void log(LogRecord record)
-  {
-    if (!isLoggable(record.getLevel()))
-      return;
-
-    if ((filter != null) && !filter.isLoggable(record))
-      return;
-
-    /* If no logger name has been set for the log record,
-     * use the name of this logger.
-     */
-    if (record.getLoggerName() == null)
-      record.setLoggerName(name);
-
-    /* Avoid that some other thread is changing the logger hierarchy
-     * while we are traversing it.
-     */
-    synchronized (LogManager.getLogManager())
-    {
-      Logger curLogger = this;
-
-      do
-      {
-        /* The Sun J2SE 1.4 reference implementation seems to call the
-	 * filter only for the logger whose log method is called,
-	 * never for any of its parents.  Also, parent loggers publish
-	 * log record whatever their level might be.  This is pretty
-	 * weird, but GNU Classpath tries to be as compatible as
-	 * possible to the reference implementation.
-	 */
-        for (int i = 0; i < curLogger.handlers.length; i++)
-          curLogger.handlers[i].publish(record);
-
-	if (curLogger.getUseParentHandlers() == false)
-	  break;
-	
-	curLogger = curLogger.getParent();
-      }
-      while (parent != null);
-    }
-  }
-
-
-  public void log(Level level, String message)
-  {
-    if (isLoggable(level))
-      log(level, message, (Object[]) null);
-  }
-
-
-  public synchronized void log(Level level,
-			       String message,
-			       Object param)
-  {
-    if (isLoggable(level))
-      {
-        StackTraceElement caller = getCallerStackFrame();
-        logp(level,
-             caller != null ? caller.getClassName() : "<unknown>",
-             caller != null ? caller.getMethodName() : "<unknown>",
-             message,
-             param);
-      }
-  }
-
-
-  public synchronized void log(Level level,
-			       String message,
-			       Object[] params)
-  {
-    if (isLoggable(level))
-      {
-        StackTraceElement caller = getCallerStackFrame();
-        logp(level,
-             caller != null ? caller.getClassName() : "<unknown>",
-             caller != null ? caller.getMethodName() : "<unknown>",
-             message,
-             params);
-      }
-  }
-
-
-  public synchronized void log(Level level,
-			       String message,
-			       Throwable thrown)
-  {
-    if (isLoggable(level))
-      {
-        StackTraceElement caller = getCallerStackFrame();    
-        logp(level,
-             caller != null ? caller.getClassName() : "<unknown>",
-             caller != null ? caller.getMethodName() : "<unknown>",
-             message,
-             thrown);
-      }
-  }
-
-
-  public synchronized void logp(Level level,
-				String sourceClass,
-				String sourceMethod,
-				String message)
-  {
-    logp(level, sourceClass, sourceMethod, message,
-	 (Object[]) null);
-  }
-
-
-  public synchronized void logp(Level level,
-				String sourceClass,
-				String sourceMethod,
-				String message,
-				Object param)
-  {
-    logp(level, sourceClass, sourceMethod, message,
-	 new Object[] { param });
-  }
-
-
-  private synchronized ResourceBundle findResourceBundle()
-  {
-    if (resourceBundle != null)
-      return resourceBundle;
-
-    if (parent != null)
-      return parent.findResourceBundle();
-
-    return null;
-  }
-
-
-  private synchronized void logImpl(Level level,
-				    String sourceClass,
-				    String sourceMethod,
-				    String message,
-				    Object[] params)
-  {
-    LogRecord rec = new LogRecord(level, message);
-
-    rec.setResourceBundle(findResourceBundle());
-    rec.setSourceClassName(sourceClass);
-    rec.setSourceMethodName(sourceMethod);
-    rec.setParameters(params);
-
-    log(rec);
-  }
-
-
-  public synchronized void logp(Level level,
-				String sourceClass,
-				String sourceMethod,
-				String message,
-				Object[] params)
-  {
-    logImpl(level, sourceClass, sourceMethod, message, params);
-  }
-
-
-  public synchronized void logp(Level level,
-				String sourceClass,
-				String sourceMethod,
-				String message,
-				Throwable thrown)
-  {
-    LogRecord rec = new LogRecord(level, message);
-
-    rec.setResourceBundle(resourceBundle);
-    rec.setSourceClassName(sourceClass);
-    rec.setSourceMethodName(sourceMethod);
-    rec.setThrown(thrown);
-
-    log(rec);
-  }
-
-
-  public synchronized void logrb(Level level,
-				 String sourceClass,
-				 String sourceMethod,
-				 String bundleName,
-				 String message)
-  {
-    logrb(level, sourceClass, sourceMethod, bundleName,
-	  message, (Object[]) null);
-  }
-
-
-  public synchronized void logrb(Level level,
-				 String sourceClass,
-				 String sourceMethod,
-				 String bundleName,
-				 String message,
-				 Object param)
-  {
-    logrb(level, sourceClass, sourceMethod, bundleName,
-	  message, new Object[] { param });
-  }
-
-
-  public synchronized void logrb(Level level,
-				 String sourceClass,
-				 String sourceMethod,
-				 String bundleName,
-				 String message,
-				 Object[] params)
-  {
-    LogRecord rec = new LogRecord(level, message);
-
-    rec.setResourceBundleName(bundleName);
-    rec.setSourceClassName(sourceClass);
-    rec.setSourceMethodName(sourceMethod);
-    rec.setParameters(params);
-
-    log(rec);
-  }
-
-
-  public synchronized void logrb(Level level,
-				 String sourceClass,
-				 String sourceMethod,
-				 String bundleName,
-				 String message,
-				 Throwable thrown)
-  {
-    LogRecord rec = new LogRecord(level, message);
-
-    rec.setResourceBundleName(bundleName);
-    rec.setSourceClassName(sourceClass);
-    rec.setSourceMethodName(sourceMethod);
-    rec.setThrown(thrown);
-
-    log(rec);
-  }
-
-
-  public synchronized void entering(String sourceClass,
-				    String sourceMethod)
-  {
-    if (isLoggable(Level.FINER))
-      logp(Level.FINER, sourceClass, sourceMethod, "ENTRY");
-  }
-
-
-  public synchronized void entering(String sourceClass,
-				    String sourceMethod,
-				    Object param)
-  {
-    if (isLoggable(Level.FINER))
-      logp(Level.FINER, sourceClass, sourceMethod, "ENTRY {0}", param);
-  }
-
-
-  public synchronized void entering(String sourceClass,
-				    String sourceMethod,
-				    Object[] params)
-  {
-    if (isLoggable(Level.FINER))
-    {
-      StringBuffer buf = new StringBuffer(80);
-      buf.append("ENTRY");
-      for (int i = 0; i < params.length; i++)
-      {
-	buf.append(" {");
-	buf.append(i);
-	buf.append('}');
-      }
-      
-      logp(Level.FINER, sourceClass, sourceMethod, buf.toString(), params);
-    }
-  }
-
-
-  public synchronized void exiting(String sourceClass,
-				   String sourceMethod)
-  {
-    if (isLoggable(Level.FINER))
-      logp(Level.FINER, sourceClass, sourceMethod, "RETURN");
-  }
-
-   
-  public synchronized void exiting(String sourceClass,
-				   String sourceMethod,
-				   Object result)
-  {
-    if (isLoggable(Level.FINER))
-      logp(Level.FINER, sourceClass, sourceMethod, "RETURN {0}", result);
-  }
-
- 
-  public synchronized void throwing(String sourceClass,
-				    String sourceMethod,
-				    Throwable thrown)
-  {
-    if (isLoggable(Level.FINER))
-      logp(Level.FINER, sourceClass, sourceMethod, "THROW", thrown);
-  }
-
-
-  /**
-   * Logs a message with severity level SEVERE, indicating a serious
-   * failure that prevents normal program execution.  Messages at this
-   * level should be understandable to an inexperienced, non-technical
-   * end user.  Ideally, they explain in simple words what actions the
-   * user can take in order to resolve the problem.
-   *
-   * @see Level#SEVERE
-   *
-   * @param message the message text, also used as look-up key if the
-   *                logger is localizing messages with a resource
-   *                bundle.  While it is possible to pass
-   *                <code>null</code>, this is not recommended, since
-   *                a logging message without text is unlikely to be
-   *                helpful.
-   */
-  public synchronized void severe(String message)
-  {
-    if (isLoggable(Level.SEVERE))
-      log(Level.SEVERE, message);
-  }
-
-
-  /**
-   * Logs a message with severity level WARNING, indicating a
-   * potential problem that does not prevent normal program execution.
-   * Messages at this level should be understandable to an
-   * inexperienced, non-technical end user.  Ideally, they explain in
-   * simple words what actions the user can take in order to resolve
-   * the problem.
-   *
-   * @see Level#WARNING
-   *
-   * @param message the message text, also used as look-up key if the
-   *                logger is localizing messages with a resource
-   *                bundle.  While it is possible to pass
-   *                <code>null</code>, this is not recommended, since
-   *                a logging message without text is unlikely to be
-   *                helpful.
-   */
-  public synchronized void warning(String message)
-  {
-    if (isLoggable(Level.WARNING))
-      log(Level.WARNING, message);
-  }
-
-
-  /**
-   * Logs a message with severity level INFO.  {@link Level#INFO} is
-   * intended for purely informational messages that do not indicate
-   * error or warning situations. In the default logging
-   * configuration, INFO messages will be written to the system
-   * console.  For this reason, the INFO level should be used only for
-   * messages that are important to end users and system
-   * administrators.  Messages at this level should be understandable
-   * to an inexperienced, non-technical user.
-   *
-   * @param message the message text, also used as look-up key if the
-   *                logger is localizing messages with a resource
-   *                bundle.  While it is possible to pass
-   *                <code>null</code>, this is not recommended, since
-   *                a logging message without text is unlikely to be
-   *                helpful.
-   */
-  public synchronized void info(String message)
-  {
-    if (isLoggable(Level.INFO))
-      log(Level.INFO, message);
-  }
-
-
-  /**
-   * Logs a message with severity level CONFIG.  {@link Level#CONFIG} is
-   * intended for static configuration messages, for example about the
-   * windowing environment, the operating system version, etc.
-   *
-   * @param message the message text, also used as look-up key if the
-   *     logger is localizing messages with a resource bundle.  While
-   *     it is possible to pass <code>null</code>, this is not
-   *     recommended, since a logging message without text is unlikely
-   *     to be helpful.
-   */
-  public synchronized void config(String message)
-  {
-    if (isLoggable(Level.CONFIG))
-      log(Level.CONFIG, message);
-  }
-
-
-  /**
-   * Logs a message with severity level FINE.  {@link Level#FINE} is
-   * intended for messages that are relevant for developers using
-   * the component generating log messages. Examples include minor,
-   * recoverable failures, or possible inefficiencies.
-   *
-   * @param message the message text, also used as look-up key if the
-   *                logger is localizing messages with a resource
-   *                bundle.  While it is possible to pass
-   *                <code>null</code>, this is not recommended, since
-   *                a logging message without text is unlikely to be
-   *                helpful.
-   */
-  public synchronized void fine(String message)
-  {
-    if (isLoggable(Level.FINE))
-      log(Level.FINE, message);
-  }
-
-
-  /**
-   * Logs a message with severity level FINER.  {@link Level#FINER} is
-   * intended for rather detailed tracing, for example entering a
-   * method, returning from a method, or throwing an exception.
-   *
-   * @param message the message text, also used as look-up key if the
-   *                logger is localizing messages with a resource
-   *                bundle.  While it is possible to pass
-   *                <code>null</code>, this is not recommended, since
-   *                a logging message without text is unlikely to be
-   *                helpful.
-   */
-  public synchronized void finer(String message)
-  {
-    if (isLoggable(Level.FINER))
-      log(Level.FINER, message);
-  }
-
-
-  /**
-   * Logs a message with severity level FINEST.  {@link Level#FINEST}
-   * is intended for highly detailed tracing, for example reaching a
-   * certain point inside the body of a method.
-   *
-   * @param message the message text, also used as look-up key if the
-   *                logger is localizing messages with a resource
-   *                bundle.  While it is possible to pass
-   *                <code>null</code>, this is not recommended, since
-   *                a logging message without text is unlikely to be
-   *                helpful.
-   */
-  public synchronized void finest(String message)
-  {
-    if (isLoggable(Level.FINEST))
-      log(Level.FINEST, message);
-  }
-
-
-  /**
-   * Adds a handler to the set of handlers that get notified
-   * when a log record is to be published.
-   *
-   * @param handler the handler to be added.
-   *
-   * @throws NullPointerException if <code>handler</code>
-   *     is <code>null</code>.
-   *
-   * @throws SecurityException if this logger is not anonymous, a
-   *     security manager exists, and the caller is not granted
-   *     the permission to control the logging infrastructure by
-   *     having LoggingPermission("control").  Untrusted code can
-   *     obtain an anonymous logger through the static factory method
-   *     {@link #getAnonymousLogger(java.lang.String) getAnonymousLogger}.
-   */
-  public synchronized void addHandler(Handler handler)
-    throws SecurityException
-  {
-    if (handler == null)
-      throw new NullPointerException();
-
-    /* An application is allowed to control an anonymous logger
-     * without having the permission to control the logging
-     * infrastructure.
-     */
-    if (!anonymous)
-      LogManager.getLogManager().checkAccess();
-
-    if (!handlerList.contains(handler))
-    {
-      handlerList.add(handler);
-      handlers = getHandlers();
-    }
-  }
-
-
-  /**
-   * Removes a handler from the set of handlers that get notified
-   * when a log record is to be published.
-   *
-   * @param handler the handler to be removed.
-   *
-   * @throws SecurityException if this logger is not anonymous, a
-   *     security manager exists, and the caller is not granted the
-   *     permission to control the logging infrastructure by having
-   *     LoggingPermission("control").  Untrusted code can obtain an
-   *     anonymous logger through the static factory method {@link
-   *     #getAnonymousLogger(java.lang.String) getAnonymousLogger}.
-   *
-   * @throws NullPointerException if <code>handler</code>
-   *     is <code>null</code>.
-   */
-  public synchronized void removeHandler(Handler handler)
-    throws SecurityException
-  {
-    /* An application is allowed to control an anonymous logger
-     * without having the permission to control the logging
-     * infrastructure.
-     */
-    if (!anonymous)
-      LogManager.getLogManager().checkAccess();
-
-    if (handler == null)
-      throw new NullPointerException();
-
-    handlerList.remove(handler);
-    handlers = getHandlers();
-  }
-
-
-  /**
-   * Returns the handlers currently registered for this Logger.
-   * When a log record has been deemed as being loggable,
-   * it will be passed to all registered handlers for
-   * publication.  In addition, if the logger uses parent handlers
-   * (see {@link #getUseParentHandlers() getUseParentHandlers}
-   * and {@link #setUseParentHandlers(boolean) setUseParentHandlers},
-   * the log record will be passed to the parent's handlers.
-   */
-  public synchronized Handler[] getHandlers()
-  {
-    /* We cannot return our internal handlers array
-     * because we do not have any guarantee that the
-     * caller would not change the array entries.
-     */
-    return (Handler[]) handlerList.toArray(new Handler[handlerList.size()]);
-  }
-
-
-  /**
-   * Returns whether or not this Logger forwards log records to
-   * handlers registered for its parent loggers.
-   *
-   * @return <code>false</code> if this Logger sends log records
-   *         merely to Handlers registered with itself;
-   *         <code>true</code> if this Logger sends log records
-   *         not only to Handlers registered with itself, but also
-   *         to those Handlers registered with parent loggers.
-   */
-  public synchronized boolean getUseParentHandlers()
-  {
-    return useParentHandlers;
-  }
-
-
-  /**
-   * Sets whether or not this Logger forwards log records to
-   * handlers registered for its parent loggers.
-   *
-   * @param useParentHandlers <code>false</code> to let this
-   *         Logger send log records merely to Handlers registered
-   *         with itself; <code>true</code> to let this Logger
-   *         send log records not only to Handlers registered
-   *         with itself, but also to those Handlers registered with
-   *         parent loggers.
-   *
-   * @throws SecurityException if this logger is not anonymous, a
-   *     security manager exists, and the caller is not granted
-   *     the permission to control the logging infrastructure by
-   *     having LoggingPermission("control").  Untrusted code can
-   *     obtain an anonymous logger through the static factory method
-   *     {@link #getAnonymousLogger(java.lang.String) getAnonymousLogger}.
-   *
-   */
-  public synchronized void setUseParentHandlers(boolean useParentHandlers)
-  {
-    /* An application is allowed to control an anonymous logger
-     * without having the permission to control the logging
-     * infrastructure.
-     */
-    if (!anonymous)
-      LogManager.getLogManager().checkAccess();
-
-    this.useParentHandlers = useParentHandlers;
-  }
-
-
-  /**
-   * Returns the parent of this logger.  By default, the parent is
-   * assigned by the LogManager by inspecting the logger's name.
-   *
-   * @return the parent of this logger (as detemined by the LogManager
-   *     by inspecting logger names), the root logger if no other
-   *     logger has a name which is a prefix of this logger's name, or
-   *     <code>null</code> for the root logger.
-   */
-  public synchronized Logger getParent()
-  {
-    return parent;
-  }
-
-
-  /**
-   * Sets the parent of this logger.  Usually, applications do not
-   * call this method directly.  Instead, the LogManager will ensure
-   * that the tree of loggers reflects the hierarchical logger
-   * namespace.  Basically, this method should not be public at all,
-   * but the GNU implementation follows the API specification.
-   *
-   * @throws NullPointerException if <code>parent</code> is
-   *     <code>null</code>.
-   *
-   * @throws SecurityException if this logger is not anonymous, a
-   *     security manager exists, and the caller is not granted
-   *     the permission to control the logging infrastructure by
-   *     having LoggingPermission("control").  Untrusted code can
-   *     obtain an anonymous logger through the static factory method
-   *     {@link #getAnonymousLogger(java.lang.String) getAnonymousLogger}.
-   */
-  public synchronized void setParent(Logger parent)
-  {
-    if (parent == null)
-      throw new NullPointerException();
-
-    if (this == root)
-        throw new IllegalArgumentException(
-          "the root logger can only have a null parent");
-
-    /* An application is allowed to control an anonymous logger
-     * without having the permission to control the logging
-     * infrastructure.
-     */
-    if (!anonymous)
-      LogManager.getLogManager().checkAccess();
-
-    this.parent = parent;
-  }
-  
-  /**
-   * Gets the StackTraceElement of the first class that is not this class.
-   * That should be the initial caller of a logging method.
-   * @return caller of the initial logging method or null if unknown.
-   */
-  private native StackTraceElement getCallerStackFrame();
-  
-  /**
-   * Reset and close handlers attached to this logger. This function is package
-   * private because it must only be avaiable to the LogManager.
-   */
-  void resetLogger()
-  {
-    for (int i = 0; i < handlers.length; i++)
-      {
-        handlers[i].close();
-        handlerList.remove(handlers[i]);
-      }
-    handlers = getHandlers();
-  }
-}
diff --git a/libjava/java/util/logging/LoggingMXBean.h b/libjava/java/util/logging/LoggingMXBean.h
deleted file mode 100644
index 4bac932..0000000
--- a/libjava/java/util/logging/LoggingMXBean.h
+++ /dev/null
@@ -1,22 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_LoggingMXBean__
-#define __java_util_logging_LoggingMXBean__
-
-#pragma interface
-
-#include <java/lang/Object.h>
-
-class java::util::logging::LoggingMXBean : public ::java::lang::Object
-{
-
-public:
-  virtual ::java::lang::String * getLoggerLevel(::java::lang::String *) = 0;
-  virtual ::java::util::List * getLoggerNames() = 0;
-  virtual ::java::lang::String * getParentLoggerName(::java::lang::String *) = 0;
-  virtual void setLoggerLevel(::java::lang::String *, ::java::lang::String *) = 0;
-  static ::java::lang::Class class$;
-} __attribute__ ((java_interface));
-
-#endif // __java_util_logging_LoggingMXBean__
diff --git a/libjava/java/util/logging/LoggingPermission.h b/libjava/java/util/logging/LoggingPermission.h
deleted file mode 100644
index a3b803a..0000000
--- a/libjava/java/util/logging/LoggingPermission.h
+++ /dev/null
@@ -1,22 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_LoggingPermission__
-#define __java_util_logging_LoggingPermission__
-
-#pragma interface
-
-#include <java/security/BasicPermission.h>
-
-class java::util::logging::LoggingPermission : public ::java::security::BasicPermission
-{
-
-public:
-  LoggingPermission(::java::lang::String *, ::java::lang::String *);
-private:
-  static const jlong serialVersionUID = 63564341580231582LL;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_LoggingPermission__
diff --git a/libjava/java/util/logging/MemoryHandler.h b/libjava/java/util/logging/MemoryHandler.h
deleted file mode 100644
index 4ce638a..0000000
--- a/libjava/java/util/logging/MemoryHandler.h
+++ /dev/null
@@ -1,35 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_MemoryHandler__
-#define __java_util_logging_MemoryHandler__
-
-#pragma interface
-
-#include <java/util/logging/Handler.h>
-#include <gcj/array.h>
-
-
-class java::util::logging::MemoryHandler : public ::java::util::logging::Handler
-{
-
-public:
-  MemoryHandler();
-  MemoryHandler(::java::util::logging::Handler *, jint, ::java::util::logging::Level *);
-  virtual void publish(::java::util::logging::LogRecord *);
-  virtual void push();
-  virtual void flush();
-  virtual void close();
-  virtual ::java::util::logging::Level * getPushLevel();
-  virtual void setPushLevel(::java::util::logging::Level *);
-private:
-  JArray< ::java::util::logging::LogRecord * > * __attribute__((aligned(__alignof__( ::java::util::logging::Handler)))) buffer;
-  jint position;
-  jint numPublished;
-  ::java::util::logging::Level * pushLevel;
-  ::java::util::logging::Handler * target;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_MemoryHandler__
diff --git a/libjava/java/util/logging/SimpleFormatter.h b/libjava/java/util/logging/SimpleFormatter.h
deleted file mode 100644
index 6afece7..0000000
--- a/libjava/java/util/logging/SimpleFormatter.h
+++ /dev/null
@@ -1,35 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_SimpleFormatter__
-#define __java_util_logging_SimpleFormatter__
-
-#pragma interface
-
-#include <java/util/logging/Formatter.h>
-extern "Java"
-{
-  namespace java
-  {
-    namespace text
-    {
-        class DateFormat;
-    }
-  }
-}
-
-class java::util::logging::SimpleFormatter : public ::java::util::logging::Formatter
-{
-
-public:
-  SimpleFormatter();
-  virtual ::java::lang::String * format(::java::util::logging::LogRecord *);
-private:
-  ::java::text::DateFormat * __attribute__((aligned(__alignof__( ::java::util::logging::Formatter)))) dateFormat;
-public: // actually package-private
-  static ::java::lang::String * lineSep;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_SimpleFormatter__
diff --git a/libjava/java/util/logging/SocketHandler.h b/libjava/java/util/logging/SocketHandler.h
deleted file mode 100644
index 8286f13..0000000
--- a/libjava/java/util/logging/SocketHandler.h
+++ /dev/null
@@ -1,25 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_SocketHandler__
-#define __java_util_logging_SocketHandler__
-
-#pragma interface
-
-#include <java/util/logging/StreamHandler.h>
-
-class java::util::logging::SocketHandler : public ::java::util::logging::StreamHandler
-{
-
-public:
-  SocketHandler();
-  SocketHandler(::java::lang::String *, jint);
-private:
-  static jint getPortNumber();
-  static ::java::io::OutputStream * createSocket(::java::lang::String *, jint);
-public:
-  virtual void publish(::java::util::logging::LogRecord *);
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_SocketHandler__
diff --git a/libjava/java/util/logging/StreamHandler.h b/libjava/java/util/logging/StreamHandler.h
deleted file mode 100644
index 11dca98..0000000
--- a/libjava/java/util/logging/StreamHandler.h
+++ /dev/null
@@ -1,43 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_StreamHandler__
-#define __java_util_logging_StreamHandler__
-
-#pragma interface
-
-#include <java/util/logging/Handler.h>
-
-class java::util::logging::StreamHandler : public ::java::util::logging::Handler
-{
-
-public:
-  StreamHandler();
-  StreamHandler(::java::io::OutputStream *, ::java::util::logging::Formatter *);
-public: // actually package-private
-  StreamHandler(::java::io::OutputStream *, ::java::lang::String *, ::java::util::logging::Level *, ::java::util::logging::Formatter *, ::java::lang::Class *);
-private:
-  void checkOpen();
-  void checkFresh();
-  void changeWriter(::java::io::OutputStream *, ::java::lang::String *);
-public:
-  virtual void setEncoding(::java::lang::String *);
-public: // actually protected
-  virtual void setOutputStream(::java::io::OutputStream *);
-public:
-  virtual void publish(::java::util::logging::LogRecord *);
-  virtual jboolean isLoggable(::java::util::logging::LogRecord *);
-  virtual void flush();
-  virtual void close();
-private:
-  ::java::io::OutputStream * __attribute__((aligned(__alignof__( ::java::util::logging::Handler)))) out;
-  ::java::io::Writer * writer;
-  jint streamState;
-  static const jint STATE_FRESH = 0;
-  static const jint STATE_PUBLISHED = 1;
-  static const jint STATE_CLOSED = 2;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_StreamHandler__
diff --git a/libjava/java/util/logging/XMLFormatter.h b/libjava/java/util/logging/XMLFormatter.h
deleted file mode 100644
index a5de354..0000000
--- a/libjava/java/util/logging/XMLFormatter.h
+++ /dev/null
@@ -1,50 +0,0 @@
-
-// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
-
-#ifndef __java_util_logging_XMLFormatter__
-#define __java_util_logging_XMLFormatter__
-
-#pragma interface
-
-#include <java/util/logging/Formatter.h>
-extern "Java"
-{
-  namespace gnu
-  {
-    namespace java
-    {
-      namespace lang
-      {
-          class CPStringBuilder;
-      }
-    }
-  }
-  namespace java
-  {
-    namespace text
-    {
-        class SimpleDateFormat;
-    }
-  }
-}
-
-class java::util::logging::XMLFormatter : public ::java::util::logging::Formatter
-{
-
-public:
-  XMLFormatter();
-private:
-  static void appendTag(::gnu::java::lang::CPStringBuilder *, jint, ::java::lang::String *, ::java::lang::String *);
-  static void appendTag(::gnu::java::lang::CPStringBuilder *, jint, ::java::lang::String *, jlong);
-public:
-  virtual ::java::lang::String * format(::java::util::logging::LogRecord *);
-  virtual ::java::lang::String * getHead(::java::util::logging::Handler *);
-  virtual ::java::lang::String * getTail(::java::util::logging::Handler *);
-private:
-  static ::java::lang::String * lineSep;
-  ::java::text::SimpleDateFormat * __attribute__((aligned(__alignof__( ::java::util::logging::Formatter)))) iso8601;
-public:
-  static ::java::lang::Class class$;
-};
-
-#endif // __java_util_logging_XMLFormatter__
diff --git a/libjava/java/util/logging/natLogger.cc b/libjava/java/util/logging/natLogger.cc
deleted file mode 100644
index 5c68b17..0000000
--- a/libjava/java/util/logging/natLogger.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-// natLogger.cc - Native part of Logger class.
-
-/* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation
-
-   This Logger is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License.  Please consult the Logger "LIBGCJ_LICENSE" for
-details.  */
-
-#include <config.h>
-#include <platform.h>
-
-#include <string.h>
-
-#pragma implementation "Logger.h"
-
-#include <gcj/cni.h>
-#include <jvm.h>
-#include <java-stack.h>
-
-#include <java/lang/Object.h>
-#include <java/lang/Class.h>
-#include <java/util/logging/Logger.h>
-#include <java/lang/StackTraceElement.h>
-#include <java/lang/ArrayIndexOutOfBoundsException.h>
-
-using namespace java::util::logging;
-
-java::lang::StackTraceElement* 
-java::util::logging::Logger::getCallerStackFrame ()
-{
-  jclass klass = NULL;
-  _Jv_Method *meth = NULL;
-  _Jv_StackTrace::GetCallerInfo (&Logger::class$, &klass, &meth);
-
-  jstring meth_name = NULL;
-  jstring klass_name = NULL;
-  if (klass != NULL)
-    klass_name = klass->getName();
-  if (meth != NULL)
-    meth_name = _Jv_NewStringUtf8Const (meth->name);
-  
-  java::lang::StackTraceElement *e 
-    = new java::lang::StackTraceElement
-    (JvNewStringUTF (""), 0, klass_name, meth_name, false);
-
-  return e;
-}