FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Imported GNU Classpath 0.92

Browse source 
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.

From-SVN: r116139
This commit is contained in:
Mark Wielaard 2006-08-14 23:12:35 +00:00
parent abab460491
commit ac1ed908de
1294 changed files with 99479 additions and 35933 deletions
Download patch file Download diff file Expand all files Collapse all files

75
libjava/classpath/java/util/logging/FileHandler.java
View file

@ -191,6 +191,42 @@ import java.util.ListIterator;
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
@ -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";

82
libjava/classpath/java/util/logging/LogManager.java
View file

@ -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
@ -107,11 +108,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;
}
}

2
libjava/classpath/java/util/logging/Logger.java
View file

@ -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()
{

85
libjava/classpath/java/util/logging/LoggingMXBean.java Normal file
View file

@ -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);
}