2006-08-14 Mark Wielaard <mark@klomp.org>

       Imported GNU Classpath 0.92
       * HACKING: Add more importing hints. Update automake version
       requirement.

       * configure.ac (gconf-peer): New enable AC argument.
       Add --disable-gconf-peer and --enable-default-preferences-peer
       to classpath configure when gconf is disabled.
       * scripts/makemake.tcl: Set gnu/java/util/prefs/gconf and
       gnu/java/awt/dnd/peer/gtk to bc. Classify
       gnu/java/security/Configuration.java as generated source file.

       * gnu/java/lang/management/VMGarbageCollectorMXBeanImpl.java,
       gnu/java/lang/management/VMMemoryPoolMXBeanImpl.java,
       gnu/java/lang/management/VMClassLoadingMXBeanImpl.java,
       gnu/java/lang/management/VMRuntimeMXBeanImpl.java,
       gnu/java/lang/management/VMMemoryManagerMXBeanImpl.java,
       gnu/java/lang/management/VMThreadMXBeanImpl.java,
       gnu/java/lang/management/VMMemoryMXBeanImpl.java,
       gnu/java/lang/management/VMCompilationMXBeanImpl.java: New VM stub
       classes.
       * java/lang/management/VMManagementFactory.java: Likewise.
       * java/net/VMURLConnection.java: Likewise.
       * gnu/java/nio/VMChannel.java: Likewise.

       * java/lang/Thread.java (getState): Add stub implementation.
       * java/lang/Class.java (isEnum): Likewise.
       * java/lang/Class.h (isEnum): Likewise.

       * gnu/awt/xlib/XToolkit.java (getClasspathTextLayoutPeer): Removed.

       * javax/naming/spi/NamingManager.java: New override for StackWalker
       functionality.

       * configure, sources.am, Makefile.in, gcj/Makefile.in,
       include/Makefile.in, testsuite/Makefile.in: Regenerated.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@116139 138bc75d-0d04-0410-961f-82ee72b054a4

4 files changed, 211 insertions, 33 deletions

diff --git a/libjava/classpath/java/util/logging/FileHandler.java b/libjava/classpath/java/util/logging/FileHandler.java
index cde86191612..357d51e14fc 100644
--- a/libjava/classpath/java/util/logging/FileHandler.java
+++ b/libjava/classpath/java/util/logging/FileHandler.java
@@ -192,6 +192,42 @@ 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
@@ -252,16 +288,10 @@ public class FileHandler
   public FileHandler()
     throws IOException, SecurityException
   {
-    this(/* pattern: use configiguration */ null,
-
-	 LogManager.getIntProperty("java.util.logging.FileHandler.limit",
-				   /* default */ 0),
-
-	 LogManager.getIntProperty("java.util.logging.FileHandler.count",
-				   /* default */ 1),
-
-	 LogManager.getBooleanProperty("java.util.logging.FileHandler.append",
-				       /* default */ false));
+    this(LogManager.getLogManager().getProperty(PATTERN_KEY),
+	 LogManager.getIntProperty(LIMIT_KEY, DEFAULT_LIMIT),
+	 LogManager.getIntProperty(COUNT_KEY, DEFAULT_COUNT),
+	 LogManager.getBooleanProperty(APPEND_KEY, DEFAULT_APPEND));
   }
 
 
@@ -269,10 +299,7 @@ public class FileHandler
   public FileHandler(String pattern)
     throws IOException, SecurityException
   {
-    this(pattern,
-	 /* limit */ 0,
-	 /* count */ 1,
-	 /* append */ false);
+    this(pattern, DEFAULT_LIMIT, DEFAULT_COUNT, DEFAULT_APPEND);
   }
 
 
@@ -280,10 +307,7 @@ public class FileHandler
   public FileHandler(String pattern, boolean append)
     throws IOException, SecurityException
   {
-    this(pattern,
-	 /* limit */ 0,
-	 /* count */ 1,
-	 append);
+    this(pattern, DEFAULT_LIMIT, DEFAULT_COUNT, append);
   }
 
 
@@ -292,9 +316,7 @@ public class FileHandler
     throws IOException, SecurityException
   {
     this(pattern, limit, count, 
-	 LogManager.getBooleanProperty(
-	   "java.util.logging.FileHandler.append",
-	   /* default */ false));
+	 LogManager.getBooleanProperty(APPEND_KEY, DEFAULT_APPEND));
   }
 
 
@@ -350,7 +372,7 @@ public class FileHandler
     throws IOException, SecurityException
   {
     super(/* output stream, created below */ null,
-	  "java.util.logging.FileHandler",
+	  PROPERTY_PREFIX,
 	  /* default level */ Level.ALL,
 	  /* formatter */ null,
 	  /* default formatter */ XMLFormatter.class);
@@ -358,14 +380,14 @@ public class FileHandler
     if ((limit <0) || (count < 1))
       throw new IllegalArgumentException();
 
-    this.pattern = pattern;
+    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 (pattern, limit, count, append,
+    setOutputStream (createFileStream (this.pattern, limit, count, append,
                                        /* generation */ 0));
   }
 
@@ -389,10 +411,9 @@ public class FileHandler
      * LogManager configuration property.
      */
     if (pattern == null)
-      pattern = LogManager.getLogManager().getProperty(
-                              "java.util.logging.FileHandler.pattern");
+      pattern = LogManager.getLogManager().getProperty(PATTERN_KEY);
     if (pattern == null)
-      pattern = "%h/java%u.log";
+      pattern = DEFAULT_PATTERN;
 
     if (count > 1 && !has (pattern, 'g'))
       pattern = pattern + ".%g";
diff --git a/libjava/classpath/java/util/logging/LogManager.java b/libjava/classpath/java/util/logging/LogManager.java
index e2604815b0c..e434651f87d 100644
--- a/libjava/classpath/java/util/logging/LogManager.java
+++ b/libjava/classpath/java/util/logging/LogManager.java
@@ -39,6 +39,8 @@ 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;
@@ -50,12 +52,11 @@ 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;
 
-import gnu.classpath.SystemProperties;
-
 /**
  * The <code>LogManager</code> maintains a hierarchical namespace
  * of Logger objects and manages properties for configuring the logging
@@ -108,11 +109,23 @@ import gnu.classpath.SystemProperties;
 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.
    */
@@ -836,11 +849,11 @@ public class LogManager
       }
     catch (ClassNotFoundException e)
       {
-        warn(property, className, "class not found");
+        warn(property, className, "class not found", e);
       }
     catch (IllegalAccessException e)
       {
-        warn(property, className, "illegal access");
+        warn(property, className, "illegal access", e);
       }
     catch (InstantiationException e)
       {
@@ -848,7 +861,7 @@ public class LogManager
       }
     catch (java.lang.LinkageError e)
       {
-        warn(property, className, "linkage error");
+        warn(property, className, "linkage error", e);
       }
 
     return null;
@@ -904,4 +917,63 @@ public class LogManager
       }
   }
 
+  /**
+   * 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/Logger.java b/libjava/classpath/java/util/logging/Logger.java
index 29f19e440ca..46588e542ee 100644
--- a/libjava/classpath/java/util/logging/Logger.java
+++ b/libjava/classpath/java/util/logging/Logger.java
@@ -1209,7 +1209,7 @@ public class Logger
   
   /**
    * Reset and close handlers attached to this logger. This function is package
-   * private because it must only be avaiable to the LogManager.
+   * private because it must only be available to the LogManager.
    */
   void resetLogger()
   {
diff --git a/libjava/classpath/java/util/logging/LoggingMXBean.java b/libjava/classpath/java/util/logging/LoggingMXBean.java
new file mode 100644
index 00000000000..5f866c980d7
--- /dev/null
+++ b/libjava/classpath/java/util/logging/LoggingMXBean.java
@@ -0,0 +1,85 @@
+/* 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);
+}