From 07b78716af6a9d7c9fd1e94d9baf94a52c873947 Mon Sep 17 00:00:00 2001
From: Andrew Haley <aph@redhat.com>
Date: Fri, 30 Sep 2016 16:24:48 +0000
Subject: 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
---
.../java/util/logging/ConsoleHandler.java | 125 --
.../classpath/java/util/logging/ErrorManager.java | 193 ----
.../classpath/java/util/logging/FileHandler.java | 665 -----------
libjava/classpath/java/util/logging/Filter.java | 64 --
libjava/classpath/java/util/logging/Formatter.java | 171 ---
libjava/classpath/java/util/logging/Handler.java | 386 -------
libjava/classpath/java/util/logging/Level.java | 416 -------
.../classpath/java/util/logging/LogManager.java | 1007 -----------------
libjava/classpath/java/util/logging/LogRecord.java | 672 -----------
libjava/classpath/java/util/logging/Logger.java | 1193 --------------------
.../classpath/java/util/logging/LoggingMXBean.java | 85 --
.../java/util/logging/LoggingPermission.java | 75 --
.../classpath/java/util/logging/MemoryHandler.java | 345 ------
.../java/util/logging/SimpleFormatter.java | 131 ---
.../classpath/java/util/logging/SocketHandler.java | 220 ----
.../classpath/java/util/logging/StreamHandler.java | 521 ---------
.../classpath/java/util/logging/XMLFormatter.java | 389 -------
libjava/classpath/java/util/logging/package.html | 46 -
18 files changed, 6704 deletions(-)
delete mode 100644 libjava/classpath/java/util/logging/ConsoleHandler.java
delete mode 100644 libjava/classpath/java/util/logging/ErrorManager.java
delete mode 100644 libjava/classpath/java/util/logging/FileHandler.java
delete mode 100644 libjava/classpath/java/util/logging/Filter.java
delete mode 100644 libjava/classpath/java/util/logging/Formatter.java
delete mode 100644 libjava/classpath/java/util/logging/Handler.java
delete mode 100644 libjava/classpath/java/util/logging/Level.java
delete mode 100644 libjava/classpath/java/util/logging/LogManager.java
delete mode 100644 libjava/classpath/java/util/logging/LogRecord.java
delete mode 100644 libjava/classpath/java/util/logging/Logger.java
delete mode 100644 libjava/classpath/java/util/logging/LoggingMXBean.java
delete mode 100644 libjava/classpath/java/util/logging/LoggingPermission.java
delete mode 100644 libjava/classpath/java/util/logging/MemoryHandler.java
delete mode 100644 libjava/classpath/java/util/logging/SimpleFormatter.java
delete mode 100644 libjava/classpath/java/util/logging/SocketHandler.java
delete mode 100644 libjava/classpath/java/util/logging/StreamHandler.java
delete mode 100644 libjava/classpath/java/util/logging/XMLFormatter.java
delete mode 100644 libjava/classpath/java/util/logging/package.html
(limited to 'libjava/classpath/java/util/logging')
diff --git a/libjava/classpath/java/util/logging/ConsoleHandler.java b/libjava/classpath/java/util/logging/ConsoleHandler.java
deleted file mode 100644
index 9f6bb72..0000000
--- a/libjava/classpath/java/util/logging/ConsoleHandler.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/* ConsoleHandler.java -- a class for publishing log messages to System.err
- Copyright (C) 2002, 2004 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;
-
-/**
- * A <code>ConsoleHandler</code> publishes log records to
- * <code>System.err</code>.
- *
- * <p><strong>Configuration:</strong> Values of the subsequent
- * <code>LogManager</code> properties are taken into consideration
- * when a <code>ConsoleHandler</code> is initialized.
- * If a property is not defined, or if it has an invalid
- * value, a default is taken without an exception being thrown.
- *
- * <ul>
- *
- * <li><code>java.util.logging.ConsoleHandler.level</code> - specifies
- * the initial severity level threshold. Default value:
- * <code>Level.INFO</code>.</li>
- *
- * <li><code>java.util.logging.ConsoleHandler.filter</code> - specifies
- * the name of a Filter class. Default value: No Filter.</li>
- *
- * <li><code>java.util.logging.ConsoleHandler.formatter</code> - specifies
- * the name of a Formatter class. Default value:
- * <code>java.util.logging.SimpleFormatter</code>.</li>
- *
- * <li><code>java.util.logging.ConsoleHandler.encoding</code> - specifies
- * the name of the character encoding. Default value:
- * the default platform encoding.</li>
- *
- * </ul>
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class ConsoleHandler
- extends StreamHandler
-{
- /**
- * Constructs a <code>StreamHandler</code> that publishes
- * log records to <code>System.err</code>. The initial
- * configuration is determined by the <code>LogManager</code>
- * properties described above.
- */
- public ConsoleHandler()
- {
- super(System.err, "java.util.logging.ConsoleHandler", Level.INFO,
- /* formatter */ null, SimpleFormatter.class);
- }
-
-
- /**
- * Forces any data that may have been buffered to the underlying
- * output device, but does <i>not</i> close <code>System.err</code>.
- *
- * <p>In case of an I/O failure, the <code>ErrorManager</code>
- * of this <code>ConsoleHandler</code> will be informed, but the caller
- * of this method will not receive an exception.
- */
- public void close()
- {
- flush();
- }
-
-
- /**
- * Publishes a <code>LogRecord</code> to the console, provided the
- * record passes all tests for being loggable.
- *
- * <p>Most applications do not need to call this method directly.
- * Instead, they will use use a <code>Logger</code>, which will
- * create LogRecords and distribute them to registered handlers.
- *
- * <p>In case of an I/O failure, the <code>ErrorManager</code>
- * of this <code>SocketHandler</code> will be informed, but the caller
- * of this method will not receive an exception.
- *
- * <p>The GNU implementation of <code>ConsoleHandler.publish</code>
- * calls flush() for every request to publish a record, so
- * they appear immediately on the console.
- *
- * @param record the log event to be published.
- */
- public void publish(LogRecord record)
- {
- super.publish(record);
- flush();
- }
-}
diff --git a/libjava/classpath/java/util/logging/ErrorManager.java b/libjava/classpath/java/util/logging/ErrorManager.java
deleted file mode 100644
index 291efb2f..0000000
--- a/libjava/classpath/java/util/logging/ErrorManager.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/* ErrorManager.java --
- A class for dealing with errors that a Handler encounters
- during logging
- Copyright (C) 2002, 2003 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;
-
-/**
- * An <code>ErrorManager</code> deals with errors that a <code>Handler</code>
- * encounters while logging.
- *
- * @see Handler#setErrorManager(ErrorManager)
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class ErrorManager
-{
- /* The values have been taken from Sun's public J2SE 1.4 API
- * documentation.
- * See http://java.sun.com/j2se/1.4/docs/api/constant-values.html
- */
-
- /**
- * Indicates that there was a failure that does not readily
- * fall into any of the other categories.
- */
- public static final int GENERIC_FAILURE = 0;
-
-
- /**
- * Indicates that there was a problem upon writing to
- * an output stream.
- */
- public static final int WRITE_FAILURE = 1;
-
-
- /**
- * Indicates that there was a problem upon flushing
- * an output stream.
- */
- public static final int FLUSH_FAILURE = 2;
-
-
- /**
- * Indicates that there was a problem upon closing
- * an output stream.
- */
- public static final int CLOSE_FAILURE = 3;
-
-
- /**
- * Indicates that there was a problem upon opening
- * an output stream.
- */
- public static final int OPEN_FAILURE = 4;
-
-
- /**
- * Indicates that there was a problem upon formatting
- * the message of a log record.
- */
- public static final int FORMAT_FAILURE = 5;
-
-
- /**
- * Indicates whether the {@link #error} method of this ErrorManager
- * has ever been used.
- *
- * Declared volatile in order to correctly support the
- * double-checked locking idiom (once the revised Java Memory Model
- * gets adopted); see Classpath bug #2944.
- */
- private volatile boolean everUsed = false;
-
-
- public ErrorManager()
- {
- }
-
-
- /**
- * Reports an error that occured upon logging. The default implementation
- * emits the very first error to System.err, ignoring subsequent errors.
- *
- * @param message a message describing the error, or <code>null</code> if
- * there is no suitable description.
- *
- * @param ex an exception, or <code>null</code> if the error is not
- * related to an exception.
- *
- * @param errorCode one of the defined error codes, for example
- * <code>ErrorManager.CLOSE_FAILURE</code>.
- */
- public void error(String message, Exception ex, int errorCode)
- {
- if (everUsed)
- return;
-
- synchronized (this)
- {
- /* The double check is intentional. If the first check was
- * omitted, the monitor would have to be entered every time
- * error() method was called. If the second check was
- * omitted, the code below could be executed by multiple
- * threads simultaneously.
- *
- * This is the 'double-checked locking' idiom, which is broken
- * with the current version of the Java memory model. However,
- * we assume that JVMs will have adopted a revised version of
- * the Java Memory Model by the time GNU Classpath gains
- * widespread acceptance. See Classpath bug #2944.
- */
- if (everUsed)
- return;
-
- everUsed = true;
- }
-
- String codeMsg;
- switch (errorCode)
- {
- case GENERIC_FAILURE:
- codeMsg = "GENERIC_FAILURE";
- break;
-
- case WRITE_FAILURE:
- codeMsg = "WRITE_FAILURE";
- break;
-
- case FLUSH_FAILURE:
- codeMsg = "FLUSH_FAILURE";
- break;
-
- case CLOSE_FAILURE:
- codeMsg = "CLOSE_FAILURE";
- break;
-
- case OPEN_FAILURE:
- codeMsg = "OPEN_FAILURE";
- break;
-
- case FORMAT_FAILURE:
- codeMsg = "FORMAT_FAILURE";
- break;
-
- default:
- codeMsg = String.valueOf(errorCode);
- break;
- }
-
- System.err.println("Error upon logging: " + codeMsg);
- if ((message != null) && (message.length() > 0))
- System.err.println(message);
-
- if (ex != null)
- ex.printStackTrace();
- }
-}
diff --git a/libjava/classpath/java/util/logging/FileHandler.java b/libjava/classpath/java/util/logging/FileHandler.java
deleted file mode 100644
index 00d967f..0000000
--- a/libjava/classpath/java/util/logging/FileHandler.java
+++ /dev/null
@@ -1,665 +0,0 @@
-/* FileHandler.java -- a class for publishing log messages to log files
- Copyright (C) 2002, 2003, 2004, 2005 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.java.lang.CPStringBuilder;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.FilterOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.util.LinkedList;
-import java.util.ListIterator;
-
-/**
- * A <code>FileHandler</code> publishes log records to a set of log
- * files. A maximum file size can be specified; as soon as a log file
- * reaches the size limit, it is closed and the next file in the set
- * is taken.
- *
- * <p><strong>Configuration:</strong> Values of the subsequent
- * <code>LogManager</code> properties are taken into consideration
- * when a <code>FileHandler</code> is initialized. If a property is
- * not defined, or if it has an invalid value, a default is taken
- * without an exception being thrown.
- *
- * <ul>
- *
- * <li><code>java.util.FileHandler.level</code> - specifies
- * the initial severity level threshold. Default value:
- * <code>Level.ALL</code>.</li>
- *
- * <li><code>java.util.FileHandler.filter</code> - specifies
- * the name of a Filter class. Default value: No Filter.</li>
- *
- * <li><code>java.util.FileHandler.formatter</code> - specifies
- * the name of a Formatter class. Default value:
- * <code>java.util.logging.XMLFormatter</code>.</li>
- *
- * <li><code>java.util.FileHandler.encoding</code> - specifies
- * the name of the character encoding. Default value:
- * the default platform encoding.</li>
- *
- * <li><code>java.util.FileHandler.limit</code> - specifies the number
- * of bytes a log file is approximately allowed to reach before it
- * is closed and the handler switches to the next file in the
- * rotating set. A value of zero means that files can grow
- * without limit. Default value: 0 (unlimited growth).</li>
- *
- * <li><code>java.util.FileHandler.count</code> - specifies the number
- * of log files through which this handler cycles. Default value:
- * 1.</li>
- *
- * <li><code>java.util.FileHandler.pattern</code> - specifies a
- * pattern for the location and name of the produced log files.
- * See the section on <a href="#filePatterns">file name
- * patterns</a> for details. Default value:
- * <code>"%h/java%u.log"</code>.</li>
- *
- * <li><code>java.util.FileHandler.append</code> - specifies
- * whether the handler will append log records to existing
- * files, or whether the handler will clear log files
- * upon switching to them. Default value: <code>false</code>,
- * indicating that files will be cleared.</li>
- *
- * </ul>
- *
- * <p><a name="filePatterns"><strong>File Name Patterns:</strong></a>
- * The name and location and log files are specified with pattern
- * strings. The handler will replace the following character sequences
- * when opening log files:
- *
- * <p><ul>
- * <li><code>/</code> - replaced by the platform-specific path name
- * separator. This value is taken from the system property
- * <code>file.separator</code>.</li>
- *
- * <li><code>%t</code> - replaced by the platform-specific location of
- * the directory intended for temporary files. This value is
- * taken from the system property <code>java.io.tmpdir</code>.</li>
- *
- * <li><code>%h</code> - replaced by the location of the home
- * directory of the current user. This value is taken from the
- * system property <code>user.home</code>.</li>
- *
- * <li><code>%g</code> - replaced by a generation number for
- * distinguisthing the individual items in the rotating set
- * of log files. The generation number cycles through the
- * sequence 0, 1, ..., <code>count</code> - 1.</li>
- *
- * <li><code>%u</code> - replaced by a unique number for
- * distinguisthing the output files of several concurrently
- * running processes. The <code>FileHandler</code> starts
- * with 0 when it tries to open a log file. If the file
- * cannot be opened because it is currently in use,
- * the unique number is incremented by one and opening
- * is tried again. These steps are repeated until the
- * opening operation succeeds.
- *
- * <p>FIXME: Is the following correct? Please review. The unique
- * number is determined for each log file individually when it is
- * opened upon switching to the next file. Therefore, it is not
- * correct to assume that all log files in a rotating set bear the
- * same unique number.
- *
- * <p>FIXME: The Javadoc for the Sun reference implementation
- * says: "Note that the use of unique ids to avoid conflicts is
- * only guaranteed to work reliably when using a local disk file
- * system." Why? This needs to be mentioned as well, in case
- * the reviewers decide the statement is true. Otherwise,
- * file a bug report with Sun.</li>
- *
- * <li><code>%%</code> - replaced by a single percent sign.</li>
- * </ul>
- *
- * <p>If the pattern string does not contain <code>%g</code> and
- * <code>count</code> is greater than one, the handler will append
- * the string <code>.%g</code> to the specified pattern.
- *
- * <p>If the handler attempts to open a log file, this log file
- * is being used at the time of the attempt, and the pattern string
- * does not contain <code>%u</code>, the handler will append
- * the string <code>.%u</code> to the specified pattern. This
- * step is performed after any generation number has been
- * appended.
- *
- * <p><em>Examples for the GNU platform:</em>
- *
- * <p><ul>
- *
- * <li><code>%h/java%u.log</code> will lead to a single log file
- * <code>/home/janet/java0.log</code>, assuming <code>count</code>
- * equals 1, the user's home directory is
- * <code>/home/janet</code>, and the attempt to open the file
- * succeeds.</li>
- *
- * <li><code>%h/java%u.log</code> will lead to three log files
- * <code>/home/janet/java0.log.0</code>,
- * <code>/home/janet/java0.log.1</code>, and
- * <code>/home/janet/java0.log.2</code>,
- * assuming <code>count</code> equals 3, the user's home
- * directory is <code>/home/janet</code>, and all attempts
- * to open files succeed.</li>
- *
- * <li><code>%h/java%u.log</code> will lead to three log files
- * <code>/home/janet/java0.log.0</code>,
- * <code>/home/janet/java1.log.1</code>, and
- * <code>/home/janet/java0.log.2</code>,
- * assuming <code>count</code> equals 3, the user's home
- * directory is <code>/home/janet</code>, and the attempt
- * to open <code>/home/janet/java0.log.1</code> fails.</li>
- *
- * </ul>
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class FileHandler
- extends StreamHandler
-{
- /**
- * A literal that prefixes all file-handler related properties in the
- * logging.properties file.
- */
- private static final String PROPERTY_PREFIX = "java.util.logging.FileHandler";
- /**
- * The name of the property to set for specifying a file naming (incl. path)
- * pattern to use with rotating log files.
- */
- private static final String PATTERN_KEY = PROPERTY_PREFIX + ".pattern";
- /**
- * The default pattern to use when the <code>PATTERN_KEY</code> property was
- * not specified in the logging.properties file.
- */
- private static final String DEFAULT_PATTERN = "%h/java%u.log";
- /**
- * The name of the property to set for specifying an approximate maximum
- * amount, in bytes, to write to any one log output file. A value of zero
- * (which is the default) implies a no limit.
- */
- private static final String LIMIT_KEY = PROPERTY_PREFIX + ".limit";
- private static final int DEFAULT_LIMIT = 0;
- /**
- * The name of the property to set for specifying how many output files to
- * cycle through. The default value is 1.
- */
- private static final String COUNT_KEY = PROPERTY_PREFIX + ".count";
- private static final int DEFAULT_COUNT = 1;
- /**
- * The name of the property to set for specifying whether this handler should
- * append, or not, its output to existing files. The default value is
- * <code>false</code> meaning NOT to append.
- */
- private static final String APPEND_KEY = PROPERTY_PREFIX + ".append";
- private static final boolean DEFAULT_APPEND = false;
-
- /**
- * The number of bytes a log file is approximately allowed to reach
- * before it is closed and the handler switches to the next file in
- * the rotating set. A value of zero means that files can grow
- * without limit.
- */
- private final int limit;
-
-
- /**
- * The number of log files through which this handler cycles.
- */
- private final int count;
-
-
- /**
- * The pattern for the location and name of the produced log files.
- * See the section on <a href="#filePatterns">file name patterns</a>
- * for details.
- */
- private final String pattern;
-
-
- /**
- * Indicates whether the handler will append log records to existing
- * files (<code>true</code>), or whether the handler will clear log files
- * upon switching to them (<code>false</code>).
- */
- private final boolean append;
-
-
- /**
- * The number of bytes that have currently been written to the stream.
- * Package private for use in inner classes.
- */
- long written;
-
-
- /**
- * A linked list of files we are, or have written to. The entries
- * are file path strings, kept in the order
- */
- private LinkedList logFiles;
-
-
- /**
- * Constructs a <code>FileHandler</code>, taking all property values
- * from the current {@link LogManager LogManager} configuration.
- *
- * @throws java.io.IOException FIXME: The Sun Javadoc says: "if
- * there are IO problems opening the files." This conflicts
- * with the general principle that configuration errors do
- * not prohibit construction. Needs review.
- *
- * @throws SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- */
- public FileHandler()
- throws IOException, SecurityException
- {
- this(LogManager.getLogManager().getProperty(PATTERN_KEY),
- LogManager.getIntProperty(LIMIT_KEY, DEFAULT_LIMIT),
- LogManager.getIntProperty(COUNT_KEY, DEFAULT_COUNT),
- LogManager.getBooleanProperty(APPEND_KEY, DEFAULT_APPEND));
- }
-
-
- /* FIXME: Javadoc missing. */
- public FileHandler(String pattern)
- throws IOException, SecurityException
- {
- this(pattern, DEFAULT_LIMIT, DEFAULT_COUNT, DEFAULT_APPEND);
- }
-
-
- /* FIXME: Javadoc missing. */
- public FileHandler(String pattern, boolean append)
- throws IOException, SecurityException
- {
- this(pattern, DEFAULT_LIMIT, DEFAULT_COUNT, append);
- }
-
-
- /* FIXME: Javadoc missing. */
- public FileHandler(String pattern, int limit, int count)
- throws IOException, SecurityException
- {
- this(pattern, limit, count,
- LogManager.getBooleanProperty(APPEND_KEY, DEFAULT_APPEND));
- }
-
-
- /**
- * Constructs a <code>FileHandler</code> given the pattern for the
- * location and name of the produced log files, the size limit, the
- * number of log files thorough which the handler will rotate, and
- * the <code>append</code> property. All other property values are
- * taken from the current {@link LogManager LogManager}
- * configuration.
- *
- * @param pattern The pattern for the location and name of the
- * produced log files. See the section on <a
- * href="#filePatterns">file name patterns</a> for details.
- * If <code>pattern</code> is <code>null</code>, the value is
- * taken from the {@link LogManager LogManager} configuration
- * property
- * <code>java.util.logging.FileHandler.pattern</code>.
- * However, this is a pecularity of the GNU implementation,
- * and Sun's API specification does not mention what behavior
- * is to be expected for <code>null</code>. Therefore,
- * applications should not rely on this feature.
- *
- * @param limit specifies the number of bytes a log file is
- * approximately allowed to reach before it is closed and the
- * handler switches to the next file in the rotating set. A
- * value of zero means that files can grow without limit.
- *
- * @param count specifies the number of log files through which this
- * handler cycles.
- *
- * @param append specifies whether the handler will append log
- * records to existing files (<code>true</code>), or whether the
- * handler will clear log files upon switching to them
- * (<code>false</code>).
- *
- * @throws java.io.IOException FIXME: The Sun Javadoc says: "if
- * there are IO problems opening the files." This conflicts
- * with the general principle that configuration errors do
- * not prohibit construction. Needs review.
- *
- * @throws SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- * <p>FIXME: This seems in contrast to all other handler
- * constructors -- verify this by running tests against
- * the Sun reference implementation.
- */
- public FileHandler(String pattern,
- int limit,
- int count,
- boolean append)
- throws IOException, SecurityException
- {
- super(/* output stream, created below */ null,
- PROPERTY_PREFIX,
- /* default level */ Level.ALL,
- /* formatter */ null,
- /* default formatter */ XMLFormatter.class);
-
- if ((limit <0) || (count < 1))
- throw new IllegalArgumentException();
-
- this.pattern = pattern != null ? pattern : DEFAULT_PATTERN;
- this.limit = limit;
- this.count = count;
- this.append = append;
- this.written = 0;
- this.logFiles = new LinkedList ();
-
- setOutputStream (createFileStream (this.pattern, limit, count, append,
- /* generation */ 0));
- }
-
-
- /* FIXME: Javadoc missing. */
- private OutputStream createFileStream(String pattern,
- int limit,
- int count,
- boolean append,
- int generation)
- {
- String path;
- int unique = 0;
-
- /* Throws a SecurityException if the caller does not have
- * LoggingPermission("control").
- */
- LogManager.getLogManager().checkAccess();
-
- /* Default value from the java.util.logging.FileHandler.pattern
- * LogManager configuration property.
- */
- if (pattern == null)
- pattern = LogManager.getLogManager().getProperty(PATTERN_KEY);
- if (pattern == null)
- pattern = DEFAULT_PATTERN;
-
- if (count > 1 && !has (pattern, 'g'))
- pattern = pattern + ".%g";
-
- do
- {
- path = replaceFileNameEscapes(pattern, generation, unique, count);
-
- try
- {
- File file = new File(path);
- if (!file.exists () || append)
- {
- FileOutputStream fout = new FileOutputStream (file, append);
- // FIXME we need file locks for this to work properly, but they
- // are not implemented yet in Classpath! Madness!
-// FileChannel channel = fout.getChannel ();
-// FileLock lock = channel.tryLock ();
-// if (lock != null) // We've locked the file.
-// {
- if (logFiles.isEmpty ())
- logFiles.addFirst (path);
- return new ostr (fout);
-// }
- }
- }
- catch (Exception ex)
- {
- reportError (null, ex, ErrorManager.OPEN_FAILURE);
- }
-
- unique = unique + 1;
- if (!has (pattern, 'u'))
- pattern = pattern + ".%u";
- }
- while (true);
- }
-
-
- /**
- * Replaces the substrings <code>"/"</code> by the value of the
- * system property <code>"file.separator"</code>, <code>"%t"</code>
- * by the value of the system property
- * <code>"java.io.tmpdir"</code>, <code>"%h"</code> by the value of
- * the system property <code>"user.home"</code>, <code>"%g"</code>
- * by the value of <code>generation</code>, <code>"%u"</code> by the
- * value of <code>uniqueNumber</code>, and <code>"%%"</code> by a
- * single percent character. If <code>pattern</code> does
- * <em>not</em> contain the sequence <code>"%g"</code>,
- * the value of <code>generation</code> will be appended to
- * the result.
- *
- * @throws NullPointerException if one of the system properties
- * <code>"file.separator"</code>,
- * <code>"java.io.tmpdir"</code>, or
- * <code>"user.home"</code> has no value and the
- * corresponding escape sequence appears in
- * <code>pattern</code>.
- */
- private static String replaceFileNameEscapes(String pattern,
- int generation,
- int uniqueNumber,
- int count)
- {
- CPStringBuilder buf = new CPStringBuilder(pattern);
- String replaceWith;
- boolean foundGeneration = false;
-
- int pos = 0;
- do
- {
- // Uncomment the next line for finding bugs.
- // System.out.println(buf.substring(0,pos) + '|' + buf.substring(pos));
-
- if (buf.charAt(pos) == '/')
- {
- /* The same value is also provided by java.io.File.separator. */
- replaceWith = System.getProperty("file.separator");
- buf.replace(pos, pos + 1, replaceWith);
- pos = pos + replaceWith.length() - 1;
- continue;
- }
-
- if (buf.charAt(pos) == '%')
- {
- switch (buf.charAt(pos + 1))
- {
- case 't':
- replaceWith = System.getProperty("java.io.tmpdir");
- break;
-
- case 'h':
- replaceWith = System.getProperty("user.home");
- break;
-
- case 'g':
- replaceWith = Integer.toString(generation);
- foundGeneration = true;
- break;
-
- case 'u':
- replaceWith = Integer.toString(uniqueNumber);
- break;
-
- case '%':
- replaceWith = "%";
- break;
-
- default:
- replaceWith = "??";
- break; // FIXME: Throw exception?
- }
-
- buf.replace(pos, pos + 2, replaceWith);
- pos = pos + replaceWith.length() - 1;
- continue;
- }
- }
- while (++pos < buf.length() - 1);
-
- if (!foundGeneration && (count > 1))
- {
- buf.append('.');
- buf.append(generation);
- }
-
- return buf.toString();
- }
-
-
- /* FIXME: Javadoc missing. */
- public void publish(LogRecord record)
- {
- if (limit > 0 && written >= limit)
- rotate ();
- super.publish(record);
- flush ();
- }
-
- /**
- * Rotates the current log files, possibly removing one if we
- * exceed the file count.
- */
- private synchronized void rotate ()
- {
- if (logFiles.size () > 0)
- {
- File f1 = null;
- ListIterator lit = null;
-
- // If we reach the file count, ditch the oldest file.
- if (logFiles.size () == count)
- {
- f1 = new File ((String) logFiles.getLast ());
- f1.delete ();
- lit = logFiles.listIterator (logFiles.size () - 1);
- }
- // Otherwise, move the oldest to a new location.
- else
- {
- String path = replaceFileNameEscapes (pattern, logFiles.size (),
- /* unique */ 0, count);
- f1 = new File (path);
- logFiles.addLast (path);
- lit = logFiles.listIterator (logFiles.size () - 1);
- }
-
- // Now rotate the files.
- while (lit.hasPrevious ())
- {
- String s = (String) lit.previous ();
- File f2 = new File (s);
- f2.renameTo (f1);
- f1 = f2;
- }
- }
-
- setOutputStream (createFileStream (pattern, limit, count, append,
- /* generation */ 0));
-
- // Reset written count.
- written = 0;
- }
-
- /**
- * Tell if <code>pattern</code> contains the pattern sequence
- * with character <code>escape</code>. That is, if <code>escape</code>
- * is 'g', this method returns true if the given pattern contains
- * "%g", and not just the substring "%g" (for example, in the case of
- * "%%g").
- *
- * @param pattern The pattern to test.
- * @param escape The escape character to search for.
- * @return True iff the pattern contains the escape sequence with the
- * given character.
- */
- private static boolean has (final String pattern, final char escape)
- {
- final int len = pattern.length ();
- boolean sawPercent = false;
- for (int i = 0; i < len; i++)
- {
- char c = pattern.charAt (i);
- if (sawPercent)
- {
- if (c == escape)
- return true;
- if (c == '%') // Double percent
- {
- sawPercent = false;
- continue;
- }
- }
- sawPercent = (c == '%');
- }
- return false;
- }
-
- /**
- * An output stream that tracks the number of bytes written to it.
- */
- private final class ostr extends FilterOutputStream
- {
- private ostr (OutputStream out)
- {
- super (out);
- }
-
- public void write (final int b) throws IOException
- {
- out.write (b);
- FileHandler.this.written++; // FIXME: synchronize?
- }
-
- public void write (final byte[] b) throws IOException
- {
- write (b, 0, b.length);
- }
-
- public void write (final byte[] b, final int offset, final int length)
- throws IOException
- {
- out.write (b, offset, length);
- FileHandler.this.written += length; // FIXME: synchronize?
- }
- }
-}
diff --git a/libjava/classpath/java/util/logging/Filter.java b/libjava/classpath/java/util/logging/Filter.java
deleted file mode 100644
index ec45976..0000000
--- a/libjava/classpath/java/util/logging/Filter.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/* Filter.java -- an interface for filters that decide whether a
- LogRecord should be published or discarded
- Copyright (C) 2002, 2004 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;
-
-/**
- * By implementing the <code>Filter</code> interface, applications
- * can control what is being logged based on arbitrary properties,
- * not just the severity level. Both <code>Handler</code> and
- * <code>Logger</code> allow to register Filters whose
- * <code>isLoggable</code> method will be called when a
- * <code>LogRecord</code> has passed the test based on the
- * severity level.
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public interface Filter
-{
- /**
- * Determines whether a LogRecord should be published or discarded.
- *
- * @param record the <code>LogRecord</code> to be inspected.
- *
- * @return <code>true</code> if the record should be published,
- * <code>false</code> if it should be discarded.
- */
- boolean isLoggable(LogRecord record);
-}
diff --git a/libjava/classpath/java/util/logging/Formatter.java b/libjava/classpath/java/util/logging/Formatter.java
deleted file mode 100644
index feaf553..0000000
--- a/libjava/classpath/java/util/logging/Formatter.java
+++ /dev/null
@@ -1,171 +0,0 @@
-/* Formatter.java --
- A class for formatting log messages by localizing message texts
- and performing substitution of parameters
- Copyright (C) 2002, 2004 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.text.MessageFormat;
-import java.util.ResourceBundle;
-
-/**
- * A <code>Formatter</code> supports handlers by localizing
- * message texts and by subsituting parameter values for their
- * placeholders.
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public abstract class Formatter
-{
- /**
- * Constructs a new Formatter.
- */
- protected Formatter()
- {
- }
-
-
- /**
- * Formats a LogRecord into a string. Usually called by handlers
- * which need a string for a log record, for example to append
- * a record to a log file or to transmit a record over the network.
- *
- * @param record the log record for which a string form is requested.
- */
- public abstract String format(LogRecord record);
-
-
- /**
- * Returns a string that handlers are supposed to emit before
- * the first log record. The base implementation returns an
- * empty string, but subclasses such as {@link XMLFormatter}
- * override this method in order to provide a suitable header.
- *
- * @return a string for the header.
- *
- * @param handler the handler which will prepend the returned
- * string in front of the first log record. This method
- * may inspect certain properties of the handler, for
- * example its encoding, in order to construct the header.
- */
- public String getHead(Handler handler)
- {
- return "";
- }
-
-
- /**
- * Returns a string that handlers are supposed to emit after
- * the last log record. The base implementation returns an
- * empty string, but subclasses such as {@link XMLFormatter}
- * override this method in order to provide a suitable tail.
- *
- * @return a string for the header.
- *
- * @param handler the handler which will append the returned
- * string after the last log record. This method
- * may inspect certain properties of the handler
- * in order to construct the tail.
- */
- public String getTail(Handler handler)
- {
- return "";
- }
-
-
- /**
- * Formats the message part of a log record.
- *
- * <p>First, the Formatter localizes the record message to the
- * default locale by looking up the message in the record's
- * localization resource bundle. If this step fails because there
- * is no resource bundle associated with the record, or because the
- * record message is not a key in the bundle, the raw message is
- * used instead.
- *
- * <p>Second, the Formatter substitutes appropriate strings for
- * the message parameters. If the record returns a non-empty
- * array for <code>getParameters()</code> and the localized
- * message string contains the character sequence "{0", the
- * formatter uses <code>java.text.MessageFormat</code> to format
- * the message. Otherwise, no parameter substitution is performed.
- *
- * @param record the log record to be localized and formatted.
- *
- * @return the localized message text where parameters have been
- * substituted by suitable strings.
- *
- * @throws NullPointerException if <code>record</code>
- * is <code>null</code>.
- */
- public String formatMessage(LogRecord record)
- {
- String msg;
- ResourceBundle bundle;
- Object[] params;
-
- /* This will throw a NullPointerExceptionif record is null. */
- msg = record.getMessage();
- if (msg == null)
- msg = "";
-
- /* Try to localize the message. */
- bundle = record.getResourceBundle();
- if (bundle != null)
- {
- try
- {
- msg = bundle.getString(msg);
- }
- catch (java.util.MissingResourceException _)
- {
- }
- }
-
- /* Format the message if there are parameters. */
- params = record.getParameters();
- if ((params != null)
- && (params.length > 0)
- && (msg.indexOf("{0") >= 0))
- {
- msg = MessageFormat.format(msg, params);
- }
-
- return msg;
- }
-}
diff --git a/libjava/classpath/java/util/logging/Handler.java b/libjava/classpath/java/util/logging/Handler.java
deleted file mode 100644
index e254b4d..0000000
--- a/libjava/classpath/java/util/logging/Handler.java
+++ /dev/null
@@ -1,386 +0,0 @@
-/* Handler.java -- a class for publishing log messages
- Copyright (C) 2002, 2004 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.io.UnsupportedEncodingException;
-
-/**
- * A <code>Handler</code> publishes <code>LogRecords</code> to
- * a sink, for example a file, the console or a network socket.
- * There are different subclasses of <code>Handler</code>
- * to deal with different kinds of sinks.
- *
- * <p>FIXME: Are handlers thread-safe, or is the assumption that only
- * loggers are, and a handler can belong only to one single logger? If
- * the latter, should we enforce it? (Spec not clear). In any
- * case, it needs documentation.
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public abstract class Handler
-{
- Formatter formatter;
- Filter filter;
- Level level;
- ErrorManager errorManager;
- String encoding;
-
- /**
- * Constructs a Handler with a logging severity level of
- * <code>Level.ALL</code>, no formatter, no filter, and
- * an instance of <code>ErrorManager</code> managing errors.
- *
- * <p><strong>Specification Note:</strong> The specification of the
- * Java<sup>TM</sup> Logging API does not mention which character
- * encoding is to be used by freshly constructed Handlers. The GNU
- * implementation uses the default platform encoding, but other
- * Java implementations might behave differently.
- *
- * <p><strong>Specification Note:</strong> While a freshly constructed
- * Handler is required to have <em>no filter</em> according to the
- * specification, <code>null</code> is not a valid parameter for
- * <code>Handler.setFormatter</code>. Therefore, the following
- * code will throw a <code>java.lang.NullPointerException</code>:
- *
- * <p><pre>Handler h = new MyConcreteSubclassOfHandler();
-h.setFormatter(h.getFormatter());</pre>
- *
- * It seems strange that a freshly constructed Handler is not
- * supposed to provide a Formatter, but this is what the specification
- * says.
- */
- protected Handler()
- {
- level = Level.ALL;
- }
-
-
- /**
- * Publishes a <code>LogRecord</code> to an appropriate sink,
- * provided the record passes all tests for being loggable. The
- * <code>Handler</code> will localize the message of the log
- * record and substitute any message parameters.
- *
- * <p>Most applications do not need to call this method directly.
- * Instead, they will use use a {@link Logger}, which will
- * create LogRecords and distribute them to registered handlers.
- *
- * <p>In case of an I/O failure, the <code>ErrorManager</code>
- * of this <code>Handler</code> will be informed, but the caller
- * of this method will not receive an exception.
- *
- * @param record the log event to be published.
- */
- public abstract void publish(LogRecord record);
-
-
- /**
- * Forces any data that may have been buffered to the underlying
- * output device.
- *
- * <p>In case of an I/O failure, the <code>ErrorManager</code>
- * of this <code>Handler</code> will be informed, but the caller
- * of this method will not receive an exception.
- */
- public abstract void flush();
-
-
- /**
- * Closes this <code>Handler</code> after having flushed
- * the buffers. As soon as <code>close</code> has been called,
- * a <code>Handler</code> should not be used anymore. Attempts
- * to publish log records, to flush buffers, or to modify the
- * <code>Handler</code> in any other way may throw runtime
- * exceptions after calling <code>close</code>.
- *
- * <p>In case of an I/O failure, the <code>ErrorManager</code>
- * of this <code>Handler</code> will be informed, but the caller
- * of this method will not receive an exception.
- *
- * @throws SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- */
- public abstract void close()
- throws SecurityException;
-
-
- /**
- * Returns the <code>Formatter</code> which will be used to
- * localize the text of log messages and to substitute
- * message parameters. A <code>Handler</code> is encouraged,
- * but not required to actually use an assigned
- * <code>Formatter</code>.
- *
- * @return the <code>Formatter</code> being used, or
- * <code>null</code> if this <code>Handler</code>
- * does not use formatters and no formatter has
- * ever been set by calling <code>setFormatter</code>.
- */
- public Formatter getFormatter()
- {
- return formatter;
- }
-
-
- /**
- * Sets the <code>Formatter</code> which will be used to
- * localize the text of log messages and to substitute
- * message parameters. A <code>Handler</code> is encouraged,
- * but not required to actually use an assigned
- * <code>Formatter</code>.
- *
- * @param formatter the new <code>Formatter</code> to use.
- *
- * @throws SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- *
- * @throws NullPointerException if <code>formatter</code> is
- * <code>null</code>.
- */
- public void setFormatter(Formatter formatter)
- throws SecurityException
- {
- LogManager.getLogManager().checkAccess();
-
- /* Throws a NullPointerException if formatter is null. */
- formatter.getClass();
-
- this.formatter = formatter;
- }
-
-
- /**
- * Returns the character encoding which this handler uses for publishing
- * log records.
- *
- * @return the name of a character encoding, or <code>null</code>
- * for the default platform encoding.
- */
- public String getEncoding()
- {
- return encoding;
- }
-
-
- /**
- * Sets the character encoding which this handler uses for publishing
- * log records. The encoding of a <code>Handler</code> must be
- * set before any log records have been published.
- *
- * @param encoding the name of a character encoding, or <code>null</code>
- * for the default encoding.
- *
- * @exception SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- *
- */
- public void setEncoding(String encoding)
- throws SecurityException, UnsupportedEncodingException
- {
- /* Should any developer ever change this implementation, they are
- * advised to have a look at StreamHandler.setEncoding(String),
- * which overrides this method without calling super.setEncoding.
- */
- LogManager.getLogManager().checkAccess();
-
- /* Simple check for supported encodings. This is more expensive
- * than it could be, but this method is overwritten by StreamHandler
- * anyway.
- */
- if (encoding != null)
- new String(new byte[0], encoding);
-
- this.encoding = encoding;
- }
-
-
- /**
- * Returns the <code>Filter</code> that currently controls which
- * log records are being published by this <code>Handler</code>.
- *
- * @return the currently active <code>Filter</code>, or
- * <code>null</code> if no filter has been associated.
- * In the latter case, log records are filtered purely
- * based on their severity level.
- */
- public Filter getFilter()
- {
- return filter;
- }
-
-
- /**
- * Sets the <code>Filter</code> for controlling which
- * log records will be published by this <code>Handler</code>.
- *
- * @param filter the <code>Filter</code> to use, or
- * <code>null</code> to filter log records purely based
- * on their severity level.
- */
- public void setFilter(Filter filter)
- throws SecurityException
- {
- LogManager.getLogManager().checkAccess();
- this.filter = filter;
- }
-
-
- /**
- * Returns the <code>ErrorManager</code> that currently deals
- * with errors originating from this Handler.
- *
- * @exception SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- */
- public ErrorManager getErrorManager()
- {
- LogManager.getLogManager().checkAccess();
-
- /* Developers wanting to change the subsequent code should
- * have a look at Handler.reportError -- it also can create
- * an ErrorManager, but does so without checking permissions
- * to control the logging infrastructure.
- */
- if (errorManager == null)
- errorManager = new ErrorManager();
-
- return errorManager;
- }
-
-
- public void setErrorManager(ErrorManager manager)
- {
- LogManager.getLogManager().checkAccess();
-
- /* Make sure manager is not null. */
- manager.getClass();
-
- this.errorManager = manager;
- }
-
-
- protected void reportError(String message, Exception ex, int code)
- {
- if (errorManager == null)
- errorManager = new ErrorManager();
-
- errorManager.error(message, ex, code);
- }
-
-
- /**
- * 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.
- */
- public Level getLevel()
- {
- return level;
- }
-
-
- /**
- * Sets 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.
- *
- * @param level the severity level below which all log messages
- * will be discarded.
- *
- * @exception SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- *
- * @exception NullPointerException if <code>level</code> is
- * <code>null</code>.
- */
- public void setLevel(Level level)
- {
- LogManager.getLogManager().checkAccess();
-
- /* Throw NullPointerException if level is null. */
- level.getClass();
- this.level = level;
- }
-
-
- /**
- * Checks whether a <code>LogRecord</code> would be logged
- * if it was passed to this <code>Handler</code> for publication.
- *
- * <p>The <code>Handler</code> implementation considers a record as
- * loggable if its level is greater than or equal to the severity
- * level threshold. In a second step, if a {@link Filter} has
- * been installed, its {@link Filter#isLoggable(LogRecord) isLoggable}
- * method is invoked. Subclasses of <code>Handler</code> can override
- * this method to impose their own constraints.
- *
- * @param record the <code>LogRecord</code> to be checked.
- *
- * @return <code>true</code> if <code>record</code> would
- * be published by {@link #publish(LogRecord) publish},
- * <code>false</code> if it would be discarded.
- *
- * @see #setLevel(Level)
- * @see #setFilter(Filter)
- * @see Filter#isLoggable(LogRecord)
- *
- * @throws NullPointerException if <code>record</code>
- * is <code>null</code>.
- */
- public boolean isLoggable(LogRecord record)
- {
- if (record.getLevel().intValue() < level.intValue())
- return false;
-
- if (filter != null)
- return filter.isLoggable(record);
- else
- return true;
- }
-}
diff --git a/libjava/classpath/java/util/logging/Level.java b/libjava/classpath/java/util/logging/Level.java
deleted file mode 100644
index ea2c83f..0000000
--- a/libjava/classpath/java/util/logging/Level.java
+++ /dev/null
@@ -1,416 +0,0 @@
-/* Level.java -- a class for indicating logging levels
- Copyright (C) 2002, 2005, 2006 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.io.Serializable;
-import java.util.ResourceBundle;
-
-/**
- * A class for indicating logging levels. A number of commonly used
- * levels is pre-defined (such as <code>java.util.logging.Level.INFO</code>),
- * and applications should utilize those whenever possible. For specialized
- * purposes, however, applications can sub-class Level in order to define
- * custom logging levels.
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class Level implements Serializable
-{
- /* The integer values are the same as in the Sun J2SE 1.4.
- * They have been obtained with a test program. In J2SE 1.4.1,
- * Sun has amended the API documentation; these values are now
- * publicly documented.
- */
-
- /**
- * The <code>OFF</code> level is used as a threshold for filtering
- * log records, meaning that no message should be logged.
- *
- * @see Logger#setLevel(java.util.logging.Level)
- */
- public static final Level OFF = new Level ("OFF", Integer.MAX_VALUE);
-
- /**
- * Log records whose level is <code>SEVERE</code> indicate 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.
- */
- public static final Level SEVERE = new Level ("SEVERE", 1000);
-
-
- /**
- * Log records whose level is <code>WARNING</code> indicate 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.
- */
- public static final Level WARNING = new Level ("WARNING", 900);
-
-
- /**
- * Log records whose level is <code>INFO</code> are used in purely
- * informational situations that do not constitute serious errors or
- * potential problems. 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.
- */
- public static final Level INFO = new Level ("INFO", 800);
-
-
- /**
- * Log records whose level is <code>CONFIG</code> are used for
- * describing the static configuration, for example the windowing
- * environment, the operating system version, etc.
- */
- public static final Level CONFIG = new Level ("CONFIG", 700);
-
-
- /**
- * Log records whose level is <code>FINE</code> are typically used
- * for messages that are relevant for developers using
- * the component generating log messages. Examples include minor,
- * recoverable failures, or possible inefficiencies.
- */
- public static final Level FINE = new Level ("FINE", 500);
-
-
- /**
- * Log records whose level is <code>FINER</code> are intended for
- * rather detailed tracing, for example entering a method, returning
- * from a method, or throwing an exception.
- */
- public static final Level FINER = new Level ("FINER", 400);
-
-
- /**
- * Log records whose level is <code>FINEST</code> are used for
- * highly detailed tracing, for example to indicate that a certain
- * point inside the body of a method has been reached.
- */
- public static final Level FINEST = new Level ("FINEST", 300);
-
-
- /**
- * The <code>ALL</code> level is used as a threshold for filtering
- * log records, meaning that every message should be logged.
- *
- * @see Logger#setLevel(java.util.logging.Level)
- */
- public static final Level ALL = new Level ("ALL", Integer.MIN_VALUE);
-
-
- private static final Level[] knownLevels = {
- ALL, FINEST, FINER, FINE, CONFIG, INFO, WARNING, SEVERE, OFF
- };
-
-
- /**
- * The name of the Level without localizing it, for example
- * "WARNING".
- */
- private String name;
-
-
- /**
- * The integer value of this <code>Level</code>.
- */
- private int value;
-
-
- /**
- * The name of the resource bundle used for localizing the level
- * name, or <code>null</code> if the name does not undergo
- * localization.
- */
- private String resourceBundleName;
-
-
- /**
- * Creates a logging level given a name and an integer value.
- * It rarely is necessary to create custom levels,
- * as most applications should be well served with one of the
- * standard levels such as <code>Level.CONFIG</code>,
- * <code>Level.INFO</code>, or <code>Level.FINE</code>.
- *
- * @param name the name of the level.
- *
- * @param value the integer value of the level. Please note
- * that the Java<small><sup>TM</sup></small>
- * Logging API does not specify integer
- * values for standard levels (such as
- * Level.FINE). Therefore, a custom
- * level should pass an integer value that
- * is calculated at run-time, e.g.
- * <code>(Level.FINE.intValue() + Level.CONFIG.intValue())
- * / 2</code> for a level between FINE and CONFIG.
- */
- protected Level(String name, int value)
- {
- this(name, value, null);
- }
-
-
- /**
- * Create a logging level given a name, an integer value and a name
- * of a resource bundle for localizing the level name. It rarely
- * is necessary to create custom levels, as most applications
- * should be well served with one of the standard levels such as
- * <code>Level.CONFIG</code>, <code>Level.INFO</code>, or
- * <code>Level.FINE</code>.
- *
- * @param name the name of the level.
- *
- * @param value the integer value of the level. Please note
- * that the Java<small><sup>TM</sup></small>
- * Logging API does not specify integer
- * values for standard levels (such as
- * Level.FINE). Therefore, a custom
- * level should pass an integer value that
- * is calculated at run-time, e.g.
- * <code>(Level.FINE.intValue() + Level.CONFIG.intValue())
- * / 2</code> for a level between FINE and CONFIG.
- *
- * @param resourceBundleName the name of a resource bundle
- * for localizing the level name, or <code>null</code>
- * if the name does not need to be localized.
- */
- protected Level(String name, int value, String resourceBundleName)
- {
- this.name = name;
- this.value = value;
- this.resourceBundleName = resourceBundleName;
- }
-
-
- static final long serialVersionUID = -8176160795706313070L;
-
-
- /**
- * Checks whether the Level has the same intValue as one of the
- * pre-defined levels. If so, the pre-defined level object is
- * returned.
- *
- * <br/>Since the resource bundle name is not taken into
- * consideration, it is possible to resolve Level objects that have
- * been de-serialized by another implementation, even if the other
- * implementation uses a different resource bundle for localizing
- * the names of pre-defined levels.
- */
- private Object readResolve()
- {
- for (int i = 0; i < knownLevels.length; i++)
- if (value == knownLevels[i].intValue())
- return knownLevels[i];
-
- return this;
- }
-
-
- /**
- * Returns the name of the resource bundle used for localizing the
- * level name.
- *
- * @return the name of the resource bundle used for localizing the
- * level name, or <code>null</code> if the name does not undergo
- * localization.
- */
- public String getResourceBundleName()
- {
- return resourceBundleName;
- }
-
-
- /**
- * Returns the name of the Level without localizing it, for example
- * "WARNING".
- */
- public String getName()
- {
- return name;
- }
-
-
- /**
- * Returns the name of the Level after localizing it, for example
- * "WARNUNG".
- */
- public String getLocalizedName()
- {
- String localizedName = null;
-
- if (resourceBundleName != null)
- {
- try
- {
- ResourceBundle b = ResourceBundle.getBundle(resourceBundleName);
- localizedName = b.getString(name);
- }
- catch (Exception _)
- {
- }
- }
-
- if (localizedName != null)
- return localizedName;
- else
- return name;
- }
-
-
- /**
- * Returns the name of the Level without localizing it, for example
- * "WARNING".
- */
- public final String toString()
- {
- return getName();
- }
-
-
- /**
- * Returns the integer value of the Level.
- */
- public final int intValue()
- {
- return value;
- }
-
-
- /**
- * Returns one of the standard Levels given either its name or its
- * integer value. Custom subclasses of Level will not be returned
- * by this method.
- *
- * @throws IllegalArgumentException if <code>name</code> is neither
- * the name nor the integer value of one of the pre-defined standard
- * logging levels.
- *
- * @throws NullPointerException if <code>name</code> is null.
- *
- */
- public static Level parse(String name)
- throws IllegalArgumentException
- {
- /* This will throw a NullPointerException if name is null,
- * as required by the API specification.
- */
- name = name.intern();
-
- for (int i = 0; i < knownLevels.length; i++)
- {
- // It's safe to use == instead of .equals here because only the
- // standard logging levels will be returned by this method, and
- // they are all created using string literals.
- if (name == knownLevels[i].name)
- return knownLevels[i];
- }
-
- try
- {
- int num = Integer.parseInt(name);
- for (int i = 0; i < knownLevels.length; i++)
- if (num == knownLevels[i].value)
- return knownLevels[i];
- }
- catch (NumberFormatException _)
- {
- }
-
- String msg = "Not the name of a standard logging level: \"" + name + "\"";
- throw new IllegalArgumentException(msg);
- }
-
-
- /**
- * Checks whether this Level's integer value is equal to that of
- * another object.
- *
- * @return <code>true</code> if <code>other</code> is an instance of
- * <code>java.util.logging.Level</code> and has the same integer
- * value, <code>false</code> otherwise.
- */
- public boolean equals(Object other)
- {
- if (!(other instanceof Level))
- return false;
-
- return value == ((Level) other).value;
- }
-
-
- /**
- * Returns a hash code for this Level which is based on its numeric
- * value.
- */
- public int hashCode()
- {
- return value;
- }
-
-
- /**
- * Determines whether or not this Level is one of the standard
- * levels specified in the Logging API.
- *
- * <p>This method is package-private because it is not part
- * of the logging API specification. However, an XMLFormatter
- * is supposed to emit the numeric value for a custom log
- * level, but the name for a pre-defined level. It seems
- * cleaner to put this method to Level than to write some
- * procedural code for XMLFormatter.
- *
- * @return <code>true</code> if this Level is a standard level,
- * <code>false</code> otherwise.
- */
- final boolean isStandardLevel()
- {
- for (int i = 0; i < knownLevels.length; i++)
- if (knownLevels[i] == this)
- return true;
-
- return false;
- }
-}
diff --git a/libjava/classpath/java/util/logging/LogManager.java b/libjava/classpath/java/util/logging/LogManager.java
deleted file mode 100644
index f8c6c33..0000000
--- a/libjava/classpath/java/util/logging/LogManager.java
+++ /dev/null
@@ -1,1007 +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.
- *
- * @param listener the event listener to register.
- * @throws NullPointerException if the listener is {@code null}.
- * @throws SecurityException if a security manager exists and the
- * calling code does not have the permission
- * {@code LoggingPermission("control")}.
- */
- public synchronized void addPropertyChangeListener(PropertyChangeListener listener)
- {
- if (listener == null)
- throw new NullPointerException("Attempt to add null property change listener");
-
- SecurityManager sm = System.getSecurityManager();
- if (sm != null)
- sm.checkPermission(new LoggingPermission("control", null));
-
- 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>.
- *
- * @param listener the listener to remove.
- * @throws SecurityException if a security manager exists and the
- * calling code does not have the permission
- * {@code LoggingPermission("control")}.
- */
- public synchronized void removePropertyChangeListener(PropertyChangeListener listener)
- {
- if (listener != null)
- {
- SecurityManager sm = System.getSecurityManager();
- if (sm != null)
- sm.checkPermission(new LoggingPermission("control", 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
- {
- ClassLoader loader = Thread.currentThread().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/classpath/java/util/logging/LogRecord.java b/libjava/classpath/java/util/logging/LogRecord.java
deleted file mode 100644
index ee99ee6..0000000
--- a/libjava/classpath/java/util/logging/LogRecord.java
+++ /dev/null
@@ -1,672 +0,0 @@
-/* LogRecord.java --
- A class for the state associated with individual logging events
- Copyright (C) 2002, 2003, 2004 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.ResourceBundle;
-
-
-/**
- * A <code>LogRecord</code> contains the state for an individual
- * event to be logged.
- *
- * <p>As soon as a LogRecord instance has been handed over to the
- * logging framework, applications should not manipulate it anymore.
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class LogRecord
- implements java.io.Serializable
-{
- /**
- * The severity level of this <code>LogRecord</code>.
- */
- private Level level;
-
-
- /**
- * The sequence number of this <code>LogRecord</code>.
- */
- private long sequenceNumber;
-
-
- /**
- * The name of the class that issued the logging request, or
- * <code>null</code> if this information could not be obtained.
- */
- private String sourceClassName;
-
-
- /**
- * The name of the method that issued the logging request, or
- * <code>null</code> if this information could not be obtained.
- */
- private String sourceMethodName;
-
-
- /**
- * The message for this <code>LogRecord</code> before
- * any localization or formatting.
- */
- private String message;
-
-
- /**
- * An identifier for the thread in which this <code>LogRecord</code>
- * was created. The identifier is not necessarily related to any
- * thread identifiers used by the operating system.
- */
- private int threadID;
-
-
- /**
- * The time when this <code>LogRecord</code> was created,
- * in milliseconds since the beginning of January 1, 1970.
- */
- private long millis;
-
-
- /**
- * The Throwable associated with this <code>LogRecord</code>, or
- * <code>null</code> if the logged event is not related to an
- * exception or error.
- */
- private Throwable thrown;
-
-
- /**
- * The name of the logger where this <code>LogRecord</code> has
- * originated, or <code>null</code> if this <code>LogRecord</code>
- * does not originate from a <code>Logger</code>.
- */
- private String loggerName;
-
-
- /**
- * The name of the resource bundle used for localizing log messages,
- * or <code>null</code> if no bundle has been specified.
- */
- private String resourceBundleName;
-
- private transient Object[] parameters;
-
- private transient ResourceBundle bundle;
-
-
- /**
- * Constructs a <code>LogRecord</code> given a severity level and
- * an unlocalized message text. In addition, the sequence number,
- * creation time (as returned by <code>getMillis()</code>) and
- * thread ID are assigned. All other properties are set to
- * <code>null</code>.
- *
- * @param level the severity level, for example <code>Level.WARNING</code>.
- *
- * @param message the message text (which will be used as key
- * for looking up the localized message text
- * if a resource bundle has been associated).
- */
- public LogRecord(Level level, String message)
- {
- this.level = level;
- this.message = message;
- this.millis = System.currentTimeMillis();
-
- /* A subclass of java.lang.Thread could override hashCode(),
- * in which case the result would not be guaranteed anymore
- * to be unique among all threads. While System.identityHashCode
- * is not necessarily unique either, it at least cannot be
- * overridden by user code. However, is might be a good idea
- * to use something better for generating thread IDs.
- */
- this.threadID = System.identityHashCode(Thread.currentThread());
-
- sequenceNumber = allocateSeqNum();
- }
-
-
- /**
- * Determined with the serialver tool of the Sun J2SE 1.4.
- */
- static final long serialVersionUID = 5372048053134512534L;
-
- private void readObject(java.io.ObjectInputStream in)
- throws java.io.IOException, java.lang.ClassNotFoundException
- {
- in.defaultReadObject();
-
- /* We assume that future versions will be downwards compatible,
- * so we can ignore the versions.
- */
- byte majorVersion = in.readByte();
- byte minorVersion = in.readByte();
-
- int numParams = in.readInt();
- if (numParams >= 0)
- {
- parameters = new Object[numParams];
- for (int i = 0; i < numParams; i++)
- parameters[i] = in.readObject();
- }
- }
-
-
- /**
- * @serialData The default fields, followed by a major byte version
- * number, followed by a minor byte version number, followed by
- * information about the log record parameters. If
- * <code>parameters</code> is <code>null</code>, the integer -1 is
- * written, otherwise the length of the <code>parameters</code>
- * array (which can be zero), followed by the result of calling
- * {@link Object#toString() toString()} on the parameter (or
- * <code>null</code> if the parameter is <code>null</code>).
- *
- * <p><strong>Specification Note:</strong> The Javadoc for the
- * Sun reference implementation does not specify the version
- * number. FIXME: Reverse-engineer the JDK and file a bug
- * report with Sun, asking for amendment of the specification.
- */
- private void writeObject(java.io.ObjectOutputStream out)
- throws java.io.IOException
- {
- out.defaultWriteObject();
-
- /* Major, minor version number: The Javadoc for J2SE1.4 does not
- * specify the values.
- */
- out.writeByte(0);
- out.writeByte(0);
-
- if (parameters == null)
- out.writeInt(-1);
- else
- {
- out.writeInt(parameters.length);
- for (int i = 0; i < parameters.length; i++)
- {
- if (parameters[i] == null)
- out.writeObject(null);
- else
- out.writeObject(parameters[i].toString());
- }
- }
- }
-
-
- /**
- * Returns the name of the logger where this <code>LogRecord</code>
- * has originated.
- *
- * @return the name of the source {@link Logger}, or
- * <code>null</code> if this <code>LogRecord</code>
- * does not originate from a <code>Logger</code>.
- */
- public String getLoggerName()
- {
- return loggerName;
- }
-
-
- /**
- * Sets the name of the logger where this <code>LogRecord</code>
- * has originated.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param name the name of the source logger, or <code>null</code> to
- * indicate that this <code>LogRecord</code> does not
- * originate from a <code>Logger</code>.
- */
- public void setLoggerName(String name)
- {
- loggerName = name;
- }
-
-
- /**
- * Returns the resource bundle that is used when the message
- * of this <code>LogRecord</code> needs to be localized.
- *
- * @return the resource bundle used for localization,
- * or <code>null</code> if this message does not need
- * to be localized.
- */
- public ResourceBundle getResourceBundle()
- {
- return bundle;
- }
-
-
- /**
- * Sets the resource bundle that is used when the message
- * of this <code>LogRecord</code> needs to be localized.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param bundle the resource bundle to be used, or
- * <code>null</code> to indicate that this
- * message does not need to be localized.
- */
- public void setResourceBundle(ResourceBundle bundle)
- {
- this.bundle = bundle;
-
- /* FIXME: Is there a way to infer the name
- * of a resource bundle from a ResourceBundle object?
- */
- this.resourceBundleName = null;
- }
-
-
- /**
- * Returns the name of the resource bundle that is used when the
- * message of this <code>LogRecord</code> needs to be localized.
- *
- * @return the name of the resource bundle used for localization,
- * or <code>null</code> if this message does not need
- * to be localized.
- */
- public String getResourceBundleName()
- {
- return resourceBundleName;
- }
-
-
- /**
- * Sets the name of the resource bundle that is used when the
- * message of this <code>LogRecord</code> needs to be localized.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param name the name of the resource bundle to be used, or
- * <code>null</code> to indicate that this message
- * does not need to be localized.
- */
- public void setResourceBundleName(String name)
- {
- resourceBundleName = name;
- bundle = null;
-
- try
- {
- if (resourceBundleName != null)
- bundle = ResourceBundle.getBundle(resourceBundleName);
- }
- catch (java.util.MissingResourceException _)
- {
- }
- }
-
-
- /**
- * Returns the level of the LogRecord.
- *
- * <p>Applications should be aware of the possibility that the
- * result is not necessarily one of the standard logging levels,
- * since the logging framework allows to create custom subclasses
- * of <code>java.util.logging.Level</code>. Therefore, filters
- * should perform checks like <code>theRecord.getLevel().intValue()
- * == Level.INFO.intValue()</code> instead of <code>theRecord.getLevel()
- * == Level.INFO</code>.
- */
- public Level getLevel()
- {
- return level;
- }
-
-
- /**
- * Sets the severity level of this <code>LogRecord</code> to a new
- * value.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param level the new severity level, for example
- * <code>Level.WARNING</code>.
- */
- public void setLevel(Level level)
- {
- this.level = level;
- }
-
-
- /**
- * The last used sequence number for any LogRecord.
- */
- private static long lastSeqNum;
-
-
- /**
- * Allocates a sequence number for a new LogRecord. This class
- * method is only called by the LogRecord constructor.
- */
- private static synchronized long allocateSeqNum()
- {
- lastSeqNum += 1;
- return lastSeqNum;
- }
-
-
- /**
- * Returns the sequence number of this <code>LogRecord</code>.
- */
- public long getSequenceNumber()
- {
- return sequenceNumber;
- }
-
-
- /**
- * Sets the sequence number of this <code>LogRecord</code> to a new
- * value.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param seqNum the new sequence number.
- */
- public void setSequenceNumber(long seqNum)
- {
- this.sequenceNumber = seqNum;
- }
-
-
- /**
- * Returns the name of the class where the event being logged
- * has had its origin. This information can be passed as
- * parameter to some logging calls, and in certain cases, the
- * logging framework tries to determine an approximation
- * (which may or may not be accurate).
- *
- * @return the name of the class that issued the logging request,
- * or <code>null</code> if this information could not
- * be obtained.
- */
- public String getSourceClassName()
- {
- if (sourceClassName != null)
- return sourceClassName;
-
- /* FIXME: Should infer this information from the call stack. */
- return null;
- }
-
-
- /**
- * Sets the name of the class where the event being logged
- * has had its origin.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param sourceClassName the name of the class that issued the
- * logging request, or <code>null</code> to indicate that
- * this information could not be obtained.
- */
- public void setSourceClassName(String sourceClassName)
- {
- this.sourceClassName = sourceClassName;
- }
-
-
- /**
- * Returns the name of the method where the event being logged
- * has had its origin. This information can be passed as
- * parameter to some logging calls, and in certain cases, the
- * logging framework tries to determine an approximation
- * (which may or may not be accurate).
- *
- * @return the name of the method that issued the logging request,
- * or <code>null</code> if this information could not
- * be obtained.
- */
- public String getSourceMethodName()
- {
- if (sourceMethodName != null)
- return sourceMethodName;
-
- /* FIXME: Should infer this information from the call stack. */
- return null;
- }
-
-
- /**
- * Sets the name of the method where the event being logged
- * has had its origin.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param sourceMethodName the name of the method that issued the
- * logging request, or <code>null</code> to indicate that
- * this information could not be obtained.
- */
- public void setSourceMethodName(String sourceMethodName)
- {
- this.sourceMethodName = sourceMethodName;
- }
-
-
- /**
- * Returns the message for this <code>LogRecord</code> before
- * any localization or parameter substitution.
- *
- * <p>A {@link Logger} will try to localize the message
- * if a resource bundle has been associated with this
- * <code>LogRecord</code>. In this case, the logger will call
- * <code>getMessage()</code> and use the result as the key
- * for looking up the localized message in the bundle.
- * If no bundle has been associated, or if the result of
- * <code>getMessage()</code> is not a valid key in the
- * bundle, the logger will use the raw message text as
- * returned by this method.
- *
- * @return the message text, or <code>null</code> if there
- * is no message text.
- */
- public String getMessage()
- {
- return message;
- }
-
-
- /**
- * Sets the message for this <code>LogRecord</code>.
- *
- * <p>A <code>Logger</code> will try to localize the message
- * if a resource bundle has been associated with this
- * <code>LogRecord</code>. In this case, the logger will call
- * <code>getMessage()</code> and use the result as the key
- * for looking up the localized message in the bundle.
- * If no bundle has been associated, or if the result of
- * <code>getMessage()</code> is not a valid key in the
- * bundle, the logger will use the raw message text as
- * returned by this method.
- *
- * <p>It is possible to set the message to either an empty String or
- * <code>null</code>, although this does not make the the message
- * very helpful to human users.
- *
- * @param message the message text (which will be used as key
- * for looking up the localized message text
- * if a resource bundle has been associated).
- */
- public void setMessage(String message)
- {
- this.message = message;
- }
-
-
- /**
- * Returns the parameters to the log message.
- *
- * @return the parameters to the message, or <code>null</code> if
- * the message has no parameters.
- */
- public Object[] getParameters()
- {
- return parameters;
- }
-
-
- /**
- * Sets the parameters to the log message.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param parameters the parameters to the message, or <code>null</code>
- * to indicate that the message has no parameters.
- */
- public void setParameters(Object[] parameters)
- {
- this.parameters = parameters;
- }
-
-
- /**
- * Returns an identifier for the thread in which this
- * <code>LogRecord</code> was created. The identifier is not
- * necessarily related to any thread identifiers used by the
- * operating system.
- *
- * @return an identifier for the source thread.
- */
- public int getThreadID()
- {
- return threadID;
- }
-
-
- /**
- * Sets the identifier indicating in which thread this
- * <code>LogRecord</code> was created. The identifier is not
- * necessarily related to any thread identifiers used by the
- * operating system.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param threadID the identifier for the source thread.
- */
- public void setThreadID(int threadID)
- {
- this.threadID = threadID;
- }
-
-
- /**
- * Returns the time when this <code>LogRecord</code> was created.
- *
- * @return the time of creation in milliseconds since the beginning
- * of January 1, 1970.
- */
- public long getMillis()
- {
- return millis;
- }
-
-
- /**
- * Sets the time when this <code>LogRecord</code> was created.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param millis the time of creation in milliseconds since the
- * beginning of January 1, 1970.
- */
- public void setMillis(long millis)
- {
- this.millis = millis;
- }
-
-
- /**
- * Returns the Throwable associated with this <code>LogRecord</code>,
- * or <code>null</code> if the logged event is not related to an exception
- * or error.
- */
- public Throwable getThrown()
- {
- return thrown;
- }
-
-
- /**
- * Associates this <code>LogRecord</code> with an exception or error.
- *
- * <p>As soon as a <code>LogRecord</code> has been handed over
- * to the logging framework, applications should not modify it
- * anymore. Therefore, this method should only be called on
- * freshly constructed LogRecords.
- *
- * @param thrown the exception or error to associate with, or
- * <code>null</code> if this <code>LogRecord</code>
- * should be made unrelated to an exception or error.
- */
- public void setThrown(Throwable thrown)
- {
- this.thrown = thrown;
- }
-}
diff --git a/libjava/classpath/java/util/logging/Logger.java b/libjava/classpath/java/util/logging/Logger.java
deleted file mode 100644
index c55e133..0000000
--- a/libjava/classpath/java/util/logging/Logger.java
+++ /dev/null
@@ -1,1193 +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 gnu.java.lang.CPStringBuilder;
-
-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;
-
- /**
- * Use to lock methods on this class instead of calling synchronize on methods
- * to avoid deadlocks. Yeah, no kidding, we got them :)
- */
- private static final Object[] lock = new Object[0];
-
- 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 (lock)
- {
- 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 String getResourceBundleName()
- {
- synchronized (lock)
- {
- 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 ResourceBundle getResourceBundle()
- {
- synchronized (lock)
- {
- 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 Level getLevel()
- {
- synchronized (lock)
- {
- 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 boolean isLoggable(Level level)
- {
- synchronized (lock)
- {
- 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 void setLevel(Level level)
- {
- synchronized (lock)
- {
- /*
- * 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 Filter getFilter()
- {
- synchronized (lock)
- {
- 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 void setFilter(Filter filter) throws SecurityException
- {
- synchronized (lock)
- {
- /*
- * 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 void log(LogRecord record)
- {
- synchronized (lock)
- {
- 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 void log(Level level, String message, Object param)
- {
- synchronized (lock)
- {
- if (isLoggable(level))
- {
- StackTraceElement caller = getCallerStackFrame();
- logp(level, caller != null ? caller.getClassName() : "<unknown>",
- caller != null ? caller.getMethodName() : "<unknown>",
- message, param);
- }
- }
- }
-
- public void log(Level level, String message, Object[] params)
- {
- synchronized (lock)
- {
- if (isLoggable(level))
- {
- StackTraceElement caller = getCallerStackFrame();
- logp(level, caller != null ? caller.getClassName() : "<unknown>",
- caller != null ? caller.getMethodName() : "<unknown>",
- message, params);
-
- }
- }
- }
-
- public void log(Level level, String message, Throwable thrown)
- {
- synchronized (lock)
- {
- if (isLoggable(level))
- {
- StackTraceElement caller = getCallerStackFrame();
- logp(level, caller != null ? caller.getClassName() : "<unknown>",
- caller != null ? caller.getMethodName() : "<unknown>",
- message, thrown);
- }
- }
- }
-
- public void logp(Level level, String sourceClass, String sourceMethod,
- String message)
- {
- synchronized (lock)
- {
- logp(level, sourceClass, sourceMethod, message, (Object[]) null);
- }
- }
-
- public void logp(Level level, String sourceClass, String sourceMethod,
- String message, Object param)
- {
- synchronized (lock)
- {
- logp(level, sourceClass, sourceMethod, message, new Object[] { param });
- }
-
- }
-
- private ResourceBundle findResourceBundle()
- {
- synchronized (lock)
- {
- if (resourceBundle != null)
- return resourceBundle;
-
- if (parent != null)
- return parent.findResourceBundle();
-
- return null;
- }
- }
-
- private void logImpl(Level level, String sourceClass, String sourceMethod,
- String message, Object[] params)
- {
- synchronized (lock)
- {
- LogRecord rec = new LogRecord(level, message);
-
- rec.setResourceBundle(findResourceBundle());
- rec.setSourceClassName(sourceClass);
- rec.setSourceMethodName(sourceMethod);
- rec.setParameters(params);
-
- log(rec);
- }
- }
-
- public void logp(Level level, String sourceClass, String sourceMethod,
- String message, Object[] params)
- {
- synchronized (lock)
- {
- logImpl(level, sourceClass, sourceMethod, message, params);
- }
- }
-
- public void logp(Level level, String sourceClass, String sourceMethod,
- String message, Throwable thrown)
- {
- synchronized (lock)
- {
- LogRecord rec = new LogRecord(level, message);
-
- rec.setResourceBundle(resourceBundle);
- rec.setSourceClassName(sourceClass);
- rec.setSourceMethodName(sourceMethod);
- rec.setThrown(thrown);
-
- log(rec);
- }
- }
-
- public void logrb(Level level, String sourceClass, String sourceMethod,
- String bundleName, String message)
- {
- synchronized (lock)
- {
- logrb(level, sourceClass, sourceMethod, bundleName, message,
- (Object[]) null);
- }
- }
-
- public void logrb(Level level, String sourceClass, String sourceMethod,
- String bundleName, String message, Object param)
- {
- synchronized (lock)
- {
- logrb(level, sourceClass, sourceMethod, bundleName, message,
- new Object[] { param });
- }
- }
-
- public void logrb(Level level, String sourceClass, String sourceMethod,
- String bundleName, String message, Object[] params)
- {
- synchronized (lock)
- {
- LogRecord rec = new LogRecord(level, message);
-
- rec.setResourceBundleName(bundleName);
- rec.setSourceClassName(sourceClass);
- rec.setSourceMethodName(sourceMethod);
- rec.setParameters(params);
-
- log(rec);
- }
- }
-
- public void logrb(Level level, String sourceClass, String sourceMethod,
- String bundleName, String message, Throwable thrown)
- {
- synchronized (lock)
- {
- LogRecord rec = new LogRecord(level, message);
-
- rec.setResourceBundleName(bundleName);
- rec.setSourceClassName(sourceClass);
- rec.setSourceMethodName(sourceMethod);
- rec.setThrown(thrown);
-
- log(rec);
- }
- }
-
- public void entering(String sourceClass, String sourceMethod)
- {
- synchronized (lock)
- {
- if (isLoggable(Level.FINER))
- logp(Level.FINER, sourceClass, sourceMethod, "ENTRY");
- }
- }
-
- public void entering(String sourceClass, String sourceMethod, Object param)
- {
- synchronized (lock)
- {
- if (isLoggable(Level.FINER))
- logp(Level.FINER, sourceClass, sourceMethod, "ENTRY {0}", param);
- }
- }
-
- public void entering(String sourceClass, String sourceMethod, Object[] params)
- {
- synchronized (lock)
- {
- if (isLoggable(Level.FINER))
- {
- CPStringBuilder buf = new CPStringBuilder(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 void exiting(String sourceClass, String sourceMethod)
- {
- synchronized (lock)
- {
- if (isLoggable(Level.FINER))
- logp(Level.FINER, sourceClass, sourceMethod, "RETURN");
- }
- }
-
- public void exiting(String sourceClass, String sourceMethod, Object result)
- {
- synchronized (lock)
- {
- if (isLoggable(Level.FINER))
- logp(Level.FINER, sourceClass, sourceMethod, "RETURN {0}", result);
- }
- }
-
- public void throwing(String sourceClass, String sourceMethod, Throwable thrown)
- {
- synchronized (lock)
- {
- 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 void severe(String message)
- {
- synchronized (lock)
- {
- 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 void warning(String message)
- {
- synchronized (lock)
- {
- 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 void info(String message)
- {
- synchronized (lock)
- {
- 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 void config(String message)
- {
- synchronized (lock)
- {
- 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 void fine(String message)
- {
- synchronized (lock)
- {
- 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 void finer(String message)
- {
- synchronized (lock)
- {
- 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 void finest(String message)
- {
- synchronized (lock)
- {
- 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 void addHandler(Handler handler) throws SecurityException
- {
- synchronized (lock)
- {
- 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 void removeHandler(Handler handler) throws SecurityException
- {
- synchronized (lock)
- {
- /*
- * 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 Handler[] getHandlers()
- {
- synchronized (lock)
- {
- /*
- * 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 boolean getUseParentHandlers()
- {
- synchronized (lock)
- {
- 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 void setUseParentHandlers(boolean useParentHandlers)
- {
- synchronized (lock)
- {
- /*
- * 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 Logger getParent()
- {
- synchronized (lock)
- {
- 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 void setParent(Logger parent)
- {
- synchronized (lock)
- {
- 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 StackTraceElement getCallerStackFrame()
- {
- Throwable t = new Throwable();
- StackTraceElement[] stackTrace = t.getStackTrace();
- int index = 0;
-
- // skip to stackentries until this class
- while (index < stackTrace.length
- && ! stackTrace[index].getClassName().equals(getClass().getName()))
- index++;
-
- // skip the stackentries of this class
- while (index < stackTrace.length
- && stackTrace[index].getClassName().equals(getClass().getName()))
- index++;
-
- return index < stackTrace.length ? stackTrace[index] : null;
- }
-
- /**
- * Reset and close handlers attached to this logger. This function is package
- * private because it must only be available 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/classpath/java/util/logging/LoggingMXBean.java b/libjava/classpath/java/util/logging/LoggingMXBean.java
deleted file mode 100644
index 24d8834..0000000
--- a/libjava/classpath/java/util/logging/LoggingMXBean.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/* LoggingMxBean.java -- Management interface for logging
- Copyright (C) 2006 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;
-
-/**
- * This interface represents the management interface for logging.
- * There is a single logging bean per VM instance, which can be
- * retrieved via {@link LogManager#getLoggingMXBean()}.
- *
- * @since 1.5
- */
-public interface LoggingMXBean
-{
- /**
- * Return the name of the logging level given the name of
- * a logger. Returns null if no such logger exists.
- * @param logger the logger's name
- * @return the logging level's name, or null
- */
- String getLoggerLevel(String logger);
-
- /**
- * Return a list of all logger names.
- */
- List<String> getLoggerNames();
-
- /**
- * Return the name of the parent of the indicated logger.
- * If no such logger exists, returns null. If the logger
- * is the root logger, returns the empty string.
- * @param logger the logger's name
- * @return the name of the logger's parent, or null
- */
- String getParentLoggerName(String logger);
-
- /**
- * Sets the logging level for a particular logger.
- *
- * @param logger the name of the logger
- * @param level the name of the new logging level, or null
- * @throws IllegalArgumentException if the level is not
- * recognized, or if the logger does not exist
- * @throws SecurityException if access is denied;
- * see {@link Logger#setLevel(Level)}
- */
- void setLoggerLevel(String logger, String level);
-}
diff --git a/libjava/classpath/java/util/logging/LoggingPermission.java b/libjava/classpath/java/util/logging/LoggingPermission.java
deleted file mode 100644
index 804fb94..0000000
--- a/libjava/classpath/java/util/logging/LoggingPermission.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/* LoggingPermission.java -- a class for logging permissions.
- Copyright (C) 2002 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;
-
-public final class LoggingPermission
- extends java.security.BasicPermission
-{
- private static final long serialVersionUID = 63564341580231582L;
-
- /**
- * Creates a new LoggingPermission.
- *
- * @param name the name of the permission, which must be "control".
- *
- * @param actions the list of actions for the permission, which
- * must be either <code>null</code> or an empty
- * string.
- *
- * @exception IllegalArgumentException if <code>name</code>
- * is not "control", or <code>actions</code> is
- * neither <code>null</code> nor empty.
- */
- public LoggingPermission(String name, String actions)
- {
- super("control", "");
-
- if (!"control".equals(name))
- {
- throw new IllegalArgumentException(
- "name of LoggingPermission must be \"control\"");
- }
-
- if ((actions != null) && (actions.length() != 0))
- {
- throw new IllegalArgumentException(
- "actions of LoggingPermissions must be null or empty");
- }
- }
-}
diff --git a/libjava/classpath/java/util/logging/MemoryHandler.java b/libjava/classpath/java/util/logging/MemoryHandler.java
deleted file mode 100644
index e5c258b..0000000
--- a/libjava/classpath/java/util/logging/MemoryHandler.java
+++ /dev/null
@@ -1,345 +0,0 @@
-/* MemoryHandler.java -- a class for buffering log messages in a memory buffer
- Copyright (C) 2002, 2004 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;
-
-/**
- * A <code>MemoryHandler</code> maintains a circular buffer of
- * log records.
- *
- * <p><strong>Configuration:</strong> Values of the subsequent
- * <code>LogManager</code> properties are taken into consideration
- * when a <code>MemoryHandler</code> is initialized.
- * If a property is not defined, or if it has an invalid
- * value, a default is taken without an exception being thrown.
- *
- * <ul>
- * <li><code>java.util.MemoryHandler.level</code> - specifies
- * the initial severity level threshold. Default value:
- * <code>Level.ALL</code>.</li>
- * <li><code>java.util.MemoryHandler.filter</code> - specifies
- * the name of a Filter class. Default value: No Filter.</li>
- * <li><code>java.util.MemoryHandler.size</code> - specifies the
- * maximum number of log records that are kept in the circular
- * buffer. Default value: 1000.</li>
- * <li><code>java.util.MemoryHandler.push</code> - specifies the
- * <code>pushLevel</code>. Default value:
- * <code>Level.SEVERE</code>.</li>
- * <li><code>java.util.MemoryHandler.target</code> - specifies the
- * name of a subclass of {@link Handler} that will be used as the
- * target handler. There is no default value for this property;
- * if it is not set, the no-argument MemoryHandler constructor
- * will throw an exception.</li>
- * </ul>
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class MemoryHandler
- extends Handler
-{
- /**
- * The storage area used for buffering the unpushed log records in
- * memory.
- */
- private final LogRecord[] buffer;
-
-
- /**
- * The current position in the circular buffer. For a new
- * MemoryHandler, or immediately after {@link #push()} was called,
- * the value of this variable is zero. Each call to {@link
- * #publish(LogRecord)} will store the published LogRecord into
- * <code>buffer[position]</code> before position is incremented by
- * one. If position becomes greater than the size of the buffer, it
- * is reset to zero.
- */
- private int position;
-
-
- /**
- * The number of log records which have been published, but not
- * pushed yet to the target handler.
- */
- private int numPublished;
-
-
- /**
- * The push level threshold for this <code>Handler</code>. When a
- * record is published whose severity level is greater than or equal
- * to the <code>pushLevel</code> of this <code>MemoryHandler</code>,
- * the {@link #push()} method will be invoked for pushing the buffer
- * contents to the target <code>Handler</code>.
- */
- private Level pushLevel;
-
-
- /**
- * The Handler to which log records are forwarded for actual
- * publication.
- */
- private final Handler target;
-
-
- /**
- * Constructs a <code>MemoryHandler</code> for keeping a circular
- * buffer of LogRecords; the initial configuration is determined by
- * the <code>LogManager</code> properties described above.
- */
- public MemoryHandler()
- {
- this((Handler) LogManager.getInstanceProperty(
- "java.util.logging.MemoryHandler.target",
- Handler.class, /* default */ null),
- LogManager.getIntPropertyClamped(
- "java.util.logging.MemoryHandler.size",
- /* default */ 1000,
- /* minimum value */ 1,
- /* maximum value */ Integer.MAX_VALUE),
- LogManager.getLevelProperty(
- "java.util.logging.MemoryHandler.push",
- /* default push level */ Level.SEVERE));
- }
-
-
- /**
- * Constructs a <code>MemoryHandler</code> for keeping a circular
- * buffer of LogRecords, given some parameters. The values of the
- * other parameters are taken from LogManager properties, as
- * described above.
- *
- * @param target the target handler that will receive those
- * log records that are passed on for publication.
- *
- * @param size the number of log records that are kept in the buffer.
- * The value must be a at least one.
- *
- * @param pushLevel the push level threshold for this
- * <code>MemoryHandler</code>. When a record is published whose
- * severity level is greater than or equal to
- * <code>pushLevel</code>, the {@link #push()} method will be
- * invoked in order to push the bufffer contents to
- * <code>target</code>.
- *
- * @throws java.lang.IllegalArgumentException if <code>size</code>
- * is negative or zero. The GNU implementation also throws
- * an IllegalArgumentException if <code>target</code> or
- * <code>pushLevel</code> are <code>null</code>, but the
- * API specification does not prescribe what should happen
- * in those cases.
- */
- public MemoryHandler(Handler target, int size, Level pushLevel)
- {
- if ((target == null) || (size <= 0) || (pushLevel == null))
- throw new IllegalArgumentException();
-
- buffer = new LogRecord[size];
- this.pushLevel = pushLevel;
- this.target = target;
-
- setLevel(LogManager.getLevelProperty(
- "java.util.logging.MemoryHandler.level",
- /* default value */ Level.ALL));
-
- setFilter((Filter) LogManager.getInstanceProperty(
- "java.util.logging.MemoryHandler.filter",
- /* must be instance of */ Filter.class,
- /* default value */ null));
- }
-
-
- /**
- * Stores a <code>LogRecord</code> in a fixed-size circular buffer,
- * provided the record passes all tests for being loggable. If the
- * buffer is full, the oldest record will be discarded.
- *
- * <p>If the record has a severity level which is greater than or
- * equal to the <code>pushLevel</code> of this
- * <code>MemoryHandler</code>, the {@link #push()} method will be
- * invoked for pushing the buffer contents to the target
- * <code>Handler</code>.
- *
- * <p>Most applications do not need to call this method directly.
- * Instead, they will use use a {@link Logger}, which will create
- * LogRecords and distribute them to registered handlers.
- *
- * @param record the log event to be published.
- */
- public void publish(LogRecord record)
- {
- if (!isLoggable(record))
- return;
-
- buffer[position] = record;
- position = (position + 1) % buffer.length;
- numPublished = numPublished + 1;
-
- if (record.getLevel().intValue() >= pushLevel.intValue())
- push();
- }
-
-
- /**
- * Pushes the contents of the memory buffer to the target
- * <code>Handler</code> and clears the buffer. Note that
- * the target handler will discard those records that do
- * not satisfy its own severity level threshold, or that are
- * not considered loggable by an installed {@link Filter}.
- *
- * <p>In case of an I/O failure, the {@link ErrorManager} of the
- * target <code>Handler</code> will be notified, but the caller of
- * this method will not receive an exception.
- */
- public void push()
- {
- int i;
-
- if (numPublished < buffer.length)
- {
- for (i = 0; i < position; i++)
- target.publish(buffer[i]);
- }
- else
- {
- for (i = position; i < buffer.length; i++)
- target.publish(buffer[i]);
- for (i = 0; i < position; i++)
- target.publish(buffer[i]);
- }
-
- numPublished = 0;
- position = 0;
- }
-
-
- /**
- * Forces any data that may have been buffered by the target
- * <code>Handler</code> to the underlying output device, but
- * does <em>not</em> push the contents of the circular memory
- * buffer to the target handler.
- *
- * <p>In case of an I/O failure, the {@link ErrorManager} of the
- * target <code>Handler</code> will be notified, but the caller of
- * this method will not receive an exception.
- *
- * @see #push()
- */
- public void flush()
- {
- target.flush();
- }
-
-
- /**
- * Closes this <code>MemoryHandler</code> and its associated target
- * handler, discarding the contents of the memory buffer. However,
- * any data that may have been buffered by the target
- * <code>Handler</code> is forced to the underlying output device.
- *
- * <p>As soon as <code>close</code> has been called,
- * a <code>Handler</code> should not be used anymore. Attempts
- * to publish log records, to flush buffers, or to modify the
- * <code>Handler</code> in any other way may throw runtime
- * exceptions after calling <code>close</code>.</p>
- *
- * <p>In case of an I/O failure, the <code>ErrorManager</code> of
- * the associated target <code>Handler</code> will be informed, but
- * the caller of this method will not receive an exception.</p>
- *
- * @throws SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- *
- * @see #push()
- */
- public void close()
- throws SecurityException
- {
- push();
-
- /* This will check for LoggingPermission("control"). If the
- * current security context does not grant this permission,
- * push() has been executed, but this does not impose a
- * security risk.
- */
- target.close();
- }
-
-
-
- /**
- * Returns the push level threshold for this <code>Handler</code>.
- * When a record is published whose severity level is greater
- * than or equal to the <code>pushLevel</code> of this
- * <code>MemoryHandler</code>, the {@link #push()} method will be
- * invoked for pushing the buffer contents to the target
- * <code>Handler</code>.
- *
- * @return the push level threshold for automatic pushing.
- */
- public Level getPushLevel()
- {
- return pushLevel;
- }
-
-
- /**
- * Sets the push level threshold for this <code>Handler</code>.
- * When a record is published whose severity level is greater
- * than or equal to the <code>pushLevel</code> of this
- * <code>MemoryHandler</code>, the {@link #push()} method will be
- * invoked for pushing the buffer contents to the target
- * <code>Handler</code>.
- *
- * @param pushLevel the push level threshold for automatic pushing.
- *
- * @exception SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- *
- * @exception NullPointerException if <code>pushLevel</code> is
- * <code>null</code>.
- */
- public void setPushLevel(Level pushLevel)
- {
- LogManager.getLogManager().checkAccess();
-
- /* Throws a NullPointerException if pushLevel is null. */
- pushLevel.getClass();
-
- this.pushLevel = pushLevel;
- }
-}
diff --git a/libjava/classpath/java/util/logging/SimpleFormatter.java b/libjava/classpath/java/util/logging/SimpleFormatter.java
deleted file mode 100644
index da731f2..0000000
--- a/libjava/classpath/java/util/logging/SimpleFormatter.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/* SimpleFormatter.java --
- A class for formatting log records into short human-readable messages
- Copyright (C) 2002, 2004 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.java.lang.CPStringBuilder;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.text.DateFormat;
-import java.util.Date;
-
-/**
- * A <code>SimpleFormatter</code> formats log records into
- * short human-readable messages, typically one or two lines.
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class SimpleFormatter
- extends Formatter
-{
- /**
- * Constructs a SimpleFormatter.
- */
- public SimpleFormatter()
- {
- }
-
-
- /**
- * An instance of a DateFormatter that is used for formatting
- * the time of a log record into a human-readable string,
- * according to the rules of the current locale. The value
- * is set after the first invocation of format, since it is
- * common that a JVM will instantiate a SimpleFormatter without
- * ever using it.
- */
- private DateFormat dateFormat;
-
- /**
- * The character sequence that is used to separate lines in the
- * generated stream. Somewhat surprisingly, the Sun J2SE 1.4
- * reference implementation always uses UNIX line endings, even on
- * platforms that have different line ending conventions (i.e.,
- * DOS). The GNU implementation does not replicate this bug.
- *
- * @see Sun bug parade, bug #4462871,
- * "java.util.logging.SimpleFormatter uses hard-coded line separator".
- */
- static final String lineSep = System.getProperty("line.separator");
-
-
- /**
- * Formats a log record into a String.
- *
- * @param record the log record to be formatted.
- *
- * @return a short human-readable message, typically one or two
- * lines. Lines are separated using the default platform line
- * separator.
- *
- * @throws NullPointerException if <code>record</code>
- * is <code>null</code>.
- */
- public String format(LogRecord record)
- {
- CPStringBuilder buf = new CPStringBuilder(180);
-
- if (dateFormat == null)
- dateFormat = DateFormat.getDateTimeInstance();
-
- buf.append(dateFormat.format(new Date(record.getMillis())));
- buf.append(' ');
- buf.append(record.getSourceClassName());
- buf.append(' ');
- buf.append(record.getSourceMethodName());
- buf.append(lineSep);
-
- buf.append(record.getLevel());
- buf.append(": ");
- buf.append(formatMessage(record));
-
- buf.append(lineSep);
-
- Throwable throwable = record.getThrown();
- if (throwable != null)
- {
- StringWriter sink = new StringWriter();
- throwable.printStackTrace(new PrintWriter(sink, true));
- buf.append(sink.toString());
- }
-
- return buf.toString();
- }
-}
diff --git a/libjava/classpath/java/util/logging/SocketHandler.java b/libjava/classpath/java/util/logging/SocketHandler.java
deleted file mode 100644
index 3c17b9b..0000000
--- a/libjava/classpath/java/util/logging/SocketHandler.java
+++ /dev/null
@@ -1,220 +0,0 @@
-/* SocketHandler.java -- a class for publishing log messages to network sockets
- Copyright (C) 2002 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;
-
-
-/**
- * A <code>SocketHandler</code> publishes log records to
- * a TCP/IP socket.
- *
- * <p><strong>Configuration:</strong> Values of the subsequent
- * <code>LogManager</code> properties are taken into consideration
- * when a <code>SocketHandler</code> is initialized.
- * If a property is not defined, or if it has an invalid
- * value, a default is taken without an exception being thrown.
- *
- * <ul>
- *
- * <li><code>java.util.SocketHandler.level</code> - specifies
- * the initial severity level threshold. Default value:
- * <code>Level.ALL</code>.</li>
- *
- * <li><code>java.util.SocketHandler.filter</code> - specifies
- * the name of a Filter class. Default value: No Filter.</li>
- *
- * <li><code>java.util.SocketHandler.formatter</code> - specifies
- * the name of a Formatter class. Default value:
- * <code>java.util.logging.XMLFormatter</code>.</li>
- *
- * <li><code>java.util.SocketHandler.encoding</code> - specifies
- * the name of the character encoding. Default value:
- * the default platform encoding.</li>
- *
- * <li><code>java.util.SocketHandler.host</code> - specifies
- * the name of the host to which records are published.
- * There is no default value for this property; if it is
- * not set, the SocketHandler constructor will throw
- * an exception.</li>
- *
- * <li><code>java.util.SocketHandler.port</code> - specifies
- * the TCP/IP port to which records are published.
- * There is no default value for this property; if it is
- * not set, the SocketHandler constructor will throw
- * an exception.</li>
- *
- * </ul>
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class SocketHandler
- extends StreamHandler
-{
- /**
- * Constructs a <code>SocketHandler</code> that publishes log
- * records to a TCP/IP socket. Tthe initial configuration is
- * determined by the <code>LogManager</code> properties described
- * above.
- *
- * @throws java.io.IOException if the connection to the specified
- * network host and port cannot be established.
- *
- * @throws java.lang.IllegalArgumentException if either the
- * <code>java.util.logging.SocketHandler.host</code>
- * or <code>java.util.logging.SocketHandler.port</code>
- * LogManager properties is not defined, or specifies
- * an invalid value.
- */
- public SocketHandler()
- throws java.io.IOException
- {
- this(LogManager.getLogManager().getProperty("java.util.logging.SocketHandler.host"),
- getPortNumber());
- }
-
-
- /**
- * Constructs a <code>SocketHandler</code> that publishes log
- * records to a TCP/IP socket. With the exception of the internet
- * host and port, the initial configuration is determined by the
- * <code>LogManager</code> properties described above.
- *
- * @param host the Internet host to which log records will be
- * forwarded.
- *
- * @param port the port at the host which will accept a request
- * for a TCP/IP connection.
- *
- * @throws java.io.IOException if the connection to the specified
- * network host and port cannot be established.
- *
- * @throws java.lang.IllegalArgumentException if either
- * <code>host</code> or <code>port</code> specify
- * an invalid value.
- */
- public SocketHandler(String host, int port)
- throws java.io.IOException
- {
- super(createSocket(host, port),
- "java.util.logging.SocketHandler",
- /* default level */ Level.ALL,
- /* formatter */ null,
- /* default formatter */ XMLFormatter.class);
- }
-
-
- /**
- * Retrieves the port number from the java.util.logging.SocketHandler.port
- * LogManager property.
- *
- * @throws IllegalArgumentException if the property is not defined or
- * does not specify an integer value.
- */
- private static int getPortNumber()
- {
- try {
- return Integer.parseInt(LogManager.getLogManager().getProperty("java.util.logging.SocketHandler.port"));
- } catch (Exception ex) {
- throw new IllegalArgumentException();
- }
- }
-
-
- /**
- * Creates an OutputStream for publishing log records to an Internet
- * host and port. This private method is a helper for use by the
- * constructor of SocketHandler.
- *
- * @param host the Internet host to which log records will be
- * forwarded.
- *
- * @param port the port at the host which will accept a request
- * for a TCP/IP connection.
- *
- * @throws java.io.IOException if the connection to the specified
- * network host and port cannot be established.
- *
- * @throws java.lang.IllegalArgumentException if either
- * <code>host</code> or <code>port</code> specify
- * an invalid value.
- */
- private static java.io.OutputStream createSocket(String host, int port)
- throws java.io.IOException, java.lang.IllegalArgumentException
- {
- java.net.Socket socket;
-
- if ((host == null) || (port < 1))
- throw new IllegalArgumentException();
-
- socket = new java.net.Socket(host, port);
-
- socket.shutdownInput();
-
- /* The architecture of the logging framework provides replaceable
- * formatters. Because these formatters perform their task by
- * returning one single String for each LogRecord to be formatted,
- * there is no need to buffer.
- */
- socket.setTcpNoDelay(true);
-
- return socket.getOutputStream();
- }
-
-
- /**
- * Publishes a <code>LogRecord</code> to the network socket,
- * provided the record passes all tests for being loggable.
- * In addition, all data that may have been buffered will
- * be forced to the network stream.
- *
- * <p>Most applications do not need to call this method directly.
- * Instead, they will use a {@link Logger} instance, which will
- * create LogRecords and distribute them to registered handlers.
- *
- * <p>In case of an I/O failure, the <code>ErrorManager</code>
- * of this <code>SocketHandler</code> will be informed, but the caller
- * of this method will not receive an exception.
- *
- * @param record the log event to be published.
- */
- public void publish(LogRecord record)
- {
- super.publish(record);
- flush();
- }
-}
diff --git a/libjava/classpath/java/util/logging/StreamHandler.java b/libjava/classpath/java/util/logging/StreamHandler.java
deleted file mode 100644
index d74dfac..0000000
--- a/libjava/classpath/java/util/logging/StreamHandler.java
+++ /dev/null
@@ -1,521 +0,0 @@
-/* StreamHandler.java --
- A class for publishing log messages to instances of java.io.OutputStream
- Copyright (C) 2002 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.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.io.UnsupportedEncodingException;
-import java.io.Writer;
-
-/**
- * A <code>StreamHandler</code> publishes <code>LogRecords</code> to
- * a instances of <code>java.io.OutputStream</code>.
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class StreamHandler
- extends Handler
-{
- private OutputStream out;
- private Writer writer;
-
-
- /**
- * Indicates the current state of this StreamHandler. The value
- * should be one of STATE_FRESH, STATE_PUBLISHED, or STATE_CLOSED.
- */
- private int streamState = STATE_FRESH;
-
-
- /**
- * streamState having this value indicates that the StreamHandler
- * has been created, but the publish(LogRecord) method has not been
- * called yet. If the StreamHandler has been constructed without an
- * OutputStream, writer will be null, otherwise it is set to a
- * freshly created OutputStreamWriter.
- */
- private static final int STATE_FRESH = 0;
-
-
- /**
- * streamState having this value indicates that the publish(LocRecord)
- * method has been called at least once.
- */
- private static final int STATE_PUBLISHED = 1;
-
-
- /**
- * streamState having this value indicates that the close() method
- * has been called.
- */
- private static final int STATE_CLOSED = 2;
-
-
- /**
- * Creates a <code>StreamHandler</code> without an output stream.
- * Subclasses can later use {@link
- * #setOutputStream(java.io.OutputStream)} to associate an output
- * stream with this StreamHandler.
- */
- public StreamHandler()
- {
- this(null, null);
- }
-
-
- /**
- * Creates a <code>StreamHandler</code> that formats log messages
- * with the specified Formatter and publishes them to the specified
- * output stream.
- *
- * @param out the output stream to which the formatted log messages
- * are published.
- *
- * @param formatter the <code>Formatter</code> that will be used
- * to format log messages.
- */
- public StreamHandler(OutputStream out, Formatter formatter)
- {
- this(out, "java.util.logging.StreamHandler", Level.INFO,
- formatter, SimpleFormatter.class);
- }
-
-
- StreamHandler(
- OutputStream out,
- String propertyPrefix,
- Level defaultLevel,
- Formatter formatter, Class defaultFormatterClass)
- {
- this.level = LogManager.getLevelProperty(propertyPrefix + ".level",
- defaultLevel);
-
- this.filter = (Filter) LogManager.getInstanceProperty(
- propertyPrefix + ".filter",
- /* must be instance of */ Filter.class,
- /* default: new instance of */ null);
-
- if (formatter != null)
- this.formatter = formatter;
- else
- this.formatter = (Formatter) LogManager.getInstanceProperty(
- propertyPrefix + ".formatter",
- /* must be instance of */ Formatter.class,
- /* default: new instance of */ defaultFormatterClass);
-
- try
- {
- String enc = LogManager.getLogManager().getProperty(propertyPrefix
- + ".encoding");
-
- /* make sure enc actually is a valid encoding */
- if ((enc != null) && (enc.length() > 0))
- new String(new byte[0], enc);
-
- this.encoding = enc;
- }
- catch (Exception _)
- {
- }
-
- if (out != null)
- {
- try
- {
- changeWriter(out, getEncoding());
- }
- catch (UnsupportedEncodingException uex)
- {
- /* This should never happen, since the validity of the encoding
- * name has been checked above.
- */
- throw new RuntimeException(uex.getMessage());
- }
- }
- }
-
-
- private void checkOpen()
- {
- if (streamState == STATE_CLOSED)
- throw new IllegalStateException(this.toString() + " has been closed");
- }
-
- private void checkFresh()
- {
- checkOpen();
- if (streamState != STATE_FRESH)
- throw new IllegalStateException("some log records have been published to " + this);
- }
-
-
- private void changeWriter(OutputStream out, String encoding)
- throws UnsupportedEncodingException
- {
- OutputStreamWriter writer;
-
- /* The logging API says that a null encoding means the default
- * platform encoding. However, java.io.OutputStreamWriter needs
- * another constructor for the default platform encoding,
- * passing null would throw an exception.
- */
- if (encoding == null)
- writer = new OutputStreamWriter(out);
- else
- writer = new OutputStreamWriter(out, encoding);
-
- /* Closing the stream has side effects -- do this only after
- * creating a new writer has been successful.
- */
- if ((streamState != STATE_FRESH) || (this.writer != null))
- close();
-
- this.writer = writer;
- this.out = out;
- this.encoding = encoding;
- streamState = STATE_FRESH;
- }
-
-
- /**
- * Sets the character encoding which this handler uses for publishing
- * log records. The encoding of a <code>StreamHandler</code> must be
- * set before any log records have been published.
- *
- * @param encoding the name of a character encoding, or <code>null</code>
- * for the default encoding.
- *
- * @throws SecurityException if a security manager exists and
- * the caller is not granted the permission to control the
- * the logging infrastructure.
- *
- * @exception IllegalStateException if any log records have been
- * published to this <code>StreamHandler</code> before. Please
- * be aware that this is a pecularity of the GNU implementation.
- * While the API specification indicates that it is an error
- * if the encoding is set after records have been published,
- * it does not mandate any specific behavior for that case.
- */
- public void setEncoding(String encoding)
- throws SecurityException, UnsupportedEncodingException
- {
- /* The inherited implementation first checks whether the invoking
- * code indeed has the permission to control the logging infra-
- * structure, and throws a SecurityException if this was not the
- * case.
- *
- * Next, it verifies that the encoding is supported and throws
- * an UnsupportedEncodingExcpetion otherwise. Finally, it remembers
- * the name of the encoding.
- */
- super.setEncoding(encoding);
-
- checkFresh();
-
- /* If out is null, setEncoding is being called before an output
- * stream has been set. In that case, we need to check that the
- * encoding is valid, and remember it if this is the case. Since
- * this is exactly what the inherited implementation of
- * Handler.setEncoding does, we can delegate.
- */
- if (out != null)
- {
- /* The logging API says that a null encoding means the default
- * platform encoding. However, java.io.OutputStreamWriter needs
- * another constructor for the default platform encoding, passing
- * null would throw an exception.
- */
- if (encoding == null)
- writer = new OutputStreamWriter(out);
- else
- writer = new OutputStreamWriter(out, encoding);
- }
- }
-
-
- /**
- * Changes the output stream to which this handler publishes
- * logging records.
- *
- * @throws SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- *
- * @throws NullPointerException if <code>out</code>
- * is <code>null</code>.
- */
- protected void setOutputStream(OutputStream out)
- throws SecurityException
- {
- LogManager.getLogManager().checkAccess();
-
- /* Throw a NullPointerException if out is null. */
- out.getClass();
-
- try
- {
- changeWriter(out, getEncoding());
- }
- catch (UnsupportedEncodingException ex)
- {
- /* This seems quite unlikely to happen, unless the underlying
- * implementation of java.io.OutputStreamWriter changes its
- * mind (at runtime) about the set of supported character
- * encodings.
- */
- throw new RuntimeException(ex.getMessage());
- }
- }
-
-
- /**
- * Publishes a <code>LogRecord</code> to the associated output
- * stream, provided the record passes all tests for being loggable.
- * The <code>StreamHandler</code> will localize the message of the
- * log record and substitute any message parameters.
- *
- * <p>Most applications do not need to call this method directly.
- * Instead, they will use use a {@link Logger}, which will create
- * LogRecords and distribute them to registered handlers.
- *
- * <p>In case of an I/O failure, the <code>ErrorManager</code>
- * of this <code>Handler</code> will be informed, but the caller
- * of this method will not receive an exception.
- *
- * <p>If a log record is being published to a
- * <code>StreamHandler</code> that has been closed earlier, the Sun
- * J2SE 1.4 reference can be observed to silently ignore the
- * call. The GNU implementation, however, intentionally behaves
- * differently by informing the <code>ErrorManager</code> associated
- * with this <code>StreamHandler</code>. Since the condition
- * indicates a programming error, the programmer should be
- * informed. It also seems extremely unlikely that any application
- * would depend on the exact behavior in this rather obscure,
- * erroneous case -- especially since the API specification does not
- * prescribe what is supposed to happen.
- *
- * @param record the log event to be published.
- */
- public void publish(LogRecord record)
- {
- String formattedMessage;
-
- if (!isLoggable(record))
- return;
-
- if (streamState == STATE_FRESH)
- {
- try
- {
- writer.write(formatter.getHead(this));
- }
- catch (java.io.IOException ex)
- {
- reportError(null, ex, ErrorManager.WRITE_FAILURE);
- return;
- }
- catch (Exception ex)
- {
- reportError(null, ex, ErrorManager.GENERIC_FAILURE);
- return;
- }
-
- streamState = STATE_PUBLISHED;
- }
-
- try
- {
- formattedMessage = formatter.format(record);
- }
- catch (Exception ex)
- {
- reportError(null, ex, ErrorManager.FORMAT_FAILURE);
- return;
- }
-
- try
- {
- writer.write(formattedMessage);
- }
- catch (Exception ex)
- {
- reportError(null, ex, ErrorManager.WRITE_FAILURE);
- }
- }
-
-
- /**
- * Checks whether or not a <code>LogRecord</code> would be logged
- * if it was passed to this <code>StreamHandler</code> for publication.
- *
- * <p>The <code>StreamHandler</code> implementation first checks
- * whether a writer is present and the handler's level is greater
- * than or equal to the severity level threshold. In a second step,
- * if a {@link Filter} has been installed, its {@link
- * Filter#isLoggable(LogRecord) isLoggable} method is
- * invoked. Subclasses of <code>StreamHandler</code> can override
- * this method to impose their own constraints.
- *
- * @param record the <code>LogRecord</code> to be checked.
- *
- * @return <code>true</code> if <code>record</code> would
- * be published by {@link #publish(LogRecord) publish},
- * <code>false</code> if it would be discarded.
- *
- * @see #setLevel(Level)
- * @see #setFilter(Filter)
- * @see Filter#isLoggable(LogRecord)
- *
- * @throws NullPointerException if <code>record</code> is
- * <code>null</code>. */
- public boolean isLoggable(LogRecord record)
- {
- return (writer != null) && super.isLoggable(record);
- }
-
-
- /**
- * Forces any data that may have been buffered to the underlying
- * output device.
- *
- * <p>In case of an I/O failure, the <code>ErrorManager</code>
- * of this <code>Handler</code> will be informed, but the caller
- * of this method will not receive an exception.
- *
- * <p>If a <code>StreamHandler</code> that has been closed earlier
- * is closed a second time, the Sun J2SE 1.4 reference can be
- * observed to silently ignore the call. The GNU implementation,
- * however, intentionally behaves differently by informing the
- * <code>ErrorManager</code> associated with this
- * <code>StreamHandler</code>. Since the condition indicates a
- * programming error, the programmer should be informed. It also
- * seems extremely unlikely that any application would depend on the
- * exact behavior in this rather obscure, erroneous case --
- * especially since the API specification does not prescribe what is
- * supposed to happen.
- */
- public void flush()
- {
- try
- {
- checkOpen();
- if (writer != null)
- writer.flush();
- }
- catch (Exception ex)
- {
- reportError(null, ex, ErrorManager.FLUSH_FAILURE);
- }
- }
-
-
- /**
- * Closes this <code>StreamHandler</code> after having forced any
- * data that may have been buffered to the underlying output
- * device.
- *
- * <p>As soon as <code>close</code> has been called,
- * a <code>Handler</code> should not be used anymore. Attempts
- * to publish log records, to flush buffers, or to modify the
- * <code>Handler</code> in any other way may throw runtime
- * exceptions after calling <code>close</code>.</p>
- *
- * <p>In case of an I/O failure, the <code>ErrorManager</code>
- * of this <code>Handler</code> will be informed, but the caller
- * of this method will not receive an exception.</p>
- *
- * <p>If a <code>StreamHandler</code> that has been closed earlier
- * is closed a second time, the Sun J2SE 1.4 reference can be
- * observed to silently ignore the call. The GNU implementation,
- * however, intentionally behaves differently by informing the
- * <code>ErrorManager</code> associated with this
- * <code>StreamHandler</code>. Since the condition indicates a
- * programming error, the programmer should be informed. It also
- * seems extremely unlikely that any application would depend on the
- * exact behavior in this rather obscure, erroneous case --
- * especially since the API specification does not prescribe what is
- * supposed to happen.
- *
- * @throws SecurityException if a security manager exists and
- * the caller is not granted the permission to control
- * the logging infrastructure.
- */
- public void close()
- throws SecurityException
- {
- LogManager.getLogManager().checkAccess();
-
- try
- {
- /* Although flush also calls checkOpen, it catches
- * any exceptions and reports them to the ErrorManager
- * as flush failures. However, we want to report
- * a closed stream as a close failure, not as a
- * flush failure here. Therefore, we call checkOpen()
- * before flush().
- */
- checkOpen();
- flush();
-
- if (writer != null)
- {
- if (formatter != null)
- {
- /* Even if the StreamHandler has never published a record,
- * it emits head and tail upon closing. An earlier version
- * of the GNU Classpath implementation did not emitted
- * anything. However, this had caused XML log files to be
- * entirely empty instead of containing no log records.
- */
- if (streamState == STATE_FRESH)
- writer.write(formatter.getHead(this));
- if (streamState != STATE_CLOSED)
- writer.write(formatter.getTail(this));
- }
- streamState = STATE_CLOSED;
- writer.close();
- }
- }
- catch (Exception ex)
- {
- reportError(null, ex, ErrorManager.CLOSE_FAILURE);
- }
- }
-}
diff --git a/libjava/classpath/java/util/logging/XMLFormatter.java b/libjava/classpath/java/util/logging/XMLFormatter.java
deleted file mode 100644
index da7c6ef..0000000
--- a/libjava/classpath/java/util/logging/XMLFormatter.java
+++ /dev/null
@@ -1,389 +0,0 @@
-/* XMLFormatter.java --
- A class for formatting log messages into a standard XML format
- Copyright (C) 2002, 2004 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.java.lang.CPStringBuilder;
-
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.ResourceBundle;
-
-/**
- * An <code>XMLFormatter</code> formats LogRecords into
- * a standard XML format.
- *
- * @author Sascha Brawer (brawer@acm.org)
- */
-public class XMLFormatter
- extends Formatter
-{
- /**
- * Constructs a new XMLFormatter.
- */
- public XMLFormatter()
- {
- }
-
-
- /**
- * The character sequence that is used to separate lines in the
- * generated XML stream. Somewhat surprisingly, the Sun J2SE 1.4
- * reference implementation always uses UNIX line endings, even on
- * platforms that have different line ending conventions (i.e.,
- * DOS). The GNU Classpath implementation does not replicates this
- * bug.
- *
- * See also the Sun bug parade, bug #4462871,
- * "java.util.logging.SimpleFormatter uses hard-coded line separator".
- */
- private static final String lineSep = SimpleFormatter.lineSep;
-
-
- /**
- * A DateFormat for emitting time in the ISO 8601 format.
- * Since the API specification of SimpleDateFormat does not talk
- * about its thread-safety, we cannot share a singleton instance.
- */
- private final SimpleDateFormat iso8601
- = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
-
-
- /**
- * Appends a line consisting of indentation, opening element tag,
- * element content, closing element tag and line separator to
- * a CPStringBuilder, provided that the element content is
- * actually existing.
- *
- * @param buf the CPStringBuilder to which the line will be appended.
- *
- * @param indent the indentation level.
- *
- * @param tag the element tag name, for instance <code>method</code>.
- *
- * @param content the element content, or <code>null</code> to
- * have no output whatsoever appended to <code>buf</code>.
- */
- private static void appendTag(CPStringBuilder buf, int indent,
- String tag, String content)
- {
- int i;
-
- if (content == null)
- return;
-
- for (i = 0; i < indent * 2; i++)
- buf.append(' ');
-
- buf.append("<");
- buf.append(tag);
- buf.append('>');
-
- /* Append the content, but escape for XML by replacing
- * '&', '<', '>' and all non-ASCII characters with
- * appropriate escape sequences.
- * The Sun J2SE 1.4 reference implementation does not
- * escape non-ASCII characters. This is a bug in their
- * implementation which has been reported in the Java
- * bug parade as bug number (FIXME: Insert number here).
- */
- for (i = 0; i < content.length(); i++)
- {
- char c = content.charAt(i);
- switch (c)
- {
- case '&':
- buf.append("&");
- break;
-
- case '<':
- buf.append("<");
- break;
-
- case '>':
- buf.append(">");
- break;
-
- default:
- if (((c >= 0x20) && (c <= 0x7e))
- || (c == /* line feed */ 10)
- || (c == /* carriage return */ 13))
- buf.append(c);
- else
- {
- buf.append("&#");
- buf.append((int) c);
- buf.append(';');
- }
- break;
- } /* switch (c) */
- } /* for i */
-
- buf.append("</");
- buf.append(tag);
- buf.append(">");
- buf.append(lineSep);
- }
-
-
- /**
- * Appends a line consisting of indentation, opening element tag,
- * numeric element content, closing element tag and line separator
- * to a CPStringBuilder.
- *
- * @param buf the CPStringBuilder to which the line will be appended.
- *
- * @param indent the indentation level.
- *
- * @param tag the element tag name, for instance <code>method</code>.
- *
- * @param content the element content.
- */
- private static void appendTag(CPStringBuilder buf, int indent,
- String tag, long content)
- {
- appendTag(buf, indent, tag, Long.toString(content));
- }
-
-
- public String format(LogRecord record)
- {
- CPStringBuilder buf = new CPStringBuilder(400);
- Level level = record.getLevel();
- long millis = record.getMillis();
- Object[] params = record.getParameters();
- ResourceBundle bundle = record.getResourceBundle();
- String message;
-
- buf.append("<record>");
- buf.append(lineSep);
-
-
- appendTag(buf, 1, "date", iso8601.format(new Date(millis)));
- appendTag(buf, 1, "millis", millis);
- appendTag(buf, 1, "sequence", record.getSequenceNumber());
- appendTag(buf, 1, "logger", record.getLoggerName());
-
- if (level.isStandardLevel())
- appendTag(buf, 1, "level", level.toString());
- else
- appendTag(buf, 1, "level", level.intValue());
-
- appendTag(buf, 1, "class", record.getSourceClassName());
- appendTag(buf, 1, "method", record.getSourceMethodName());
- appendTag(buf, 1, "thread", record.getThreadID());
-
- /* The Sun J2SE 1.4 reference implementation does not emit the
- * message in localized form. This is in violation of the API
- * specification. The GNU Classpath implementation intentionally
- * replicates the buggy behavior of the Sun implementation, as
- * different log files might be a big nuisance to users.
- */
- try
- {
- record.setResourceBundle(null);
- message = formatMessage(record);
- }
- finally
- {
- record.setResourceBundle(bundle);
- }
- appendTag(buf, 1, "message", message);
-
- /* The Sun J2SE 1.4 reference implementation does not
- * emit key, catalog and param tags. This is in violation
- * of the API specification. The Classpath implementation
- * intentionally replicates the buggy behavior of the
- * Sun implementation, as different log files might be
- * a big nuisance to users.
- *
- * FIXME: File a bug report with Sun. Insert bug number here.
- *
- *
- * key = record.getMessage();
- * if (key == null)
- * key = "";
- *
- * if ((bundle != null) && !key.equals(message))
- * {
- * appendTag(buf, 1, "key", key);
- * appendTag(buf, 1, "catalog", record.getResourceBundleName());
- * }
- *
- * if (params != null)
- * {
- * for (int i = 0; i < params.length; i++)
- * appendTag(buf, 1, "param", params[i].toString());
- * }
- */
-
- /* FIXME: We have no way to obtain the stacktrace before free JVMs
- * support the corresponding method in java.lang.Throwable. Well,
- * it would be possible to parse the output of printStackTrace,
- * but this would be pretty kludgy. Instead, we postpose the
- * implementation until Throwable has made progress.
- */
- Throwable thrown = record.getThrown();
- if (thrown != null)
- {
- buf.append(" <exception>");
- buf.append(lineSep);
-
- /* The API specification is not clear about what exactly
- * goes into the XML record for a thrown exception: It
- * could be the result of getMessage(), getLocalizedMessage(),
- * or toString(). Therefore, it was necessary to write a
- * Mauve testlet and run it with the Sun J2SE 1.4 reference
- * implementation. It turned out that the we need to call
- * toString().
- *
- * FIXME: File a bug report with Sun, asking for clearer
- * specs.
- */
- appendTag(buf, 2, "message", thrown.toString());
-
- /* FIXME: The Logging DTD specifies:
- *
- * <!ELEMENT exception (message?, frame+)>
- *
- * However, java.lang.Throwable.getStackTrace() is
- * allowed to return an empty array. So, what frame should
- * be emitted for an empty stack trace? We probably
- * should file a bug report with Sun, asking for the DTD
- * to be changed.
- */
-
- buf.append(" </exception>");
- buf.append(lineSep);
- }
-
-
- buf.append("</record>");
- buf.append(lineSep);
-
- return buf.toString();
- }
-
-
- /**
- * Returns a string that handlers are supposed to emit before
- * the first log record. The base implementation returns an
- * empty string, but subclasses such as {@link XMLFormatter}
- * override this method in order to provide a suitable header.
- *
- * @return a string for the header.
- *
- * @param h the handler which will prepend the returned
- * string in front of the first log record. This method
- * will inspect certain properties of the handler, for
- * example its encoding, in order to construct the header.
- */
- public String getHead(Handler h)
- {
- CPStringBuilder buf;
- String encoding;
-
- buf = new CPStringBuilder(80);
- buf.append("<?xml version=\"1.0\" encoding=\"");
-
- encoding = h.getEncoding();
-
- /* file.encoding is a system property with the Sun JVM, indicating
- * the platform-default file encoding. Unfortunately, the API
- * specification for java.lang.System.getProperties() does not
- * list this property.
- */
- if (encoding == null)
- encoding = System.getProperty("file.encoding");
-
- /* Since file.encoding is not listed with the API specification of
- * java.lang.System.getProperties(), there might be some VMs that
- * do not define this system property. Therefore, we use UTF-8 as
- * a reasonable default. Please note that if the platform encoding
- * uses the same codepoints as US-ASCII for the US-ASCII character
- * set (e.g, 65 for A), it does not matter whether we emit the
- * wrong encoding into the XML header -- the GNU Classpath will
- * emit XML escape sequences like Ӓ for any non-ASCII
- * character. Virtually all character encodings use the same code
- * points as US-ASCII for ASCII characters. Probably, EBCDIC is
- * the only exception.
- */
- if (encoding == null)
- encoding = "UTF-8";
-
- /* On Windows XP localized for Swiss German (this is one of
- * my [Sascha Brawer's] test machines), the default encoding
- * has the canonical name "windows-1252". The "historical" name
- * of this encoding is "Cp1252" (see the Javadoc for the class
- * java.nio.charset.Charset for the distinction). Now, that class
- * does have a method for mapping historical to canonical encoding
- * names. However, if we used it here, we would be come dependent
- * on java.nio.*, which was only introduced with J2SE 1.4.
- * Thus, we do this little hack here. As soon as Classpath supports
- * java.nio.charset.CharSet, this hack should be replaced by
- * code that correctly canonicalizes the encoding name.
- */
- if ((encoding.length() > 2) && encoding.startsWith("Cp"))
- encoding = "windows-" + encoding.substring(2);
-
- buf.append(encoding);
-
- buf.append("\" standalone=\"no\"?>");
- buf.append(lineSep);
-
- /* SYSTEM is not a fully qualified URL so that validating
- * XML parsers do not need to connect to the Internet in
- * order to read in a log file. See also the Sun Bug Parade,
- * bug #4372790, "Logging APIs: need to use relative URL for XML
- * doctype".
- */
- buf.append("<!DOCTYPE log SYSTEM \"logger.dtd\">");
- buf.append(lineSep);
- buf.append("<log>");
- buf.append(lineSep);
-
- return buf.toString();
- }
-
-
- public String getTail(Handler h)
- {
- return "</log>" + lineSep;
- }
-}
diff --git a/libjava/classpath/java/util/logging/package.html b/libjava/classpath/java/util/logging/package.html
deleted file mode 100644
index 31f0494..0000000
--- a/libjava/classpath/java/util/logging/package.html
+++ /dev/null
@@ -1,46 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
-<!-- package.html - describes classes in java.util.logging package.
- Copyright (C) 2002 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. -->
-
-<html>
-<head><title>GNU Classpath - java.util.logging</title></head>
-
-<body>
-<p>Utility classes for logging events.</p>
-
-</body>
-</html>
--
cgit v1.1