Menu
▾
▴
[Jnode-svn-commits] SF.net SVN: jnode:[4822] trunk
|
From: <ls...@us...> - 2009-01-03 21:16:55
|
Revision: 4822
http://jnode.svn.sourceforge.net/jnode/?rev=4822&view=rev
Author: lsantha
Date: 2009-01-03 21:16:46 +0000 (Sat, 03 Jan 2009)
Log Message:
-----------
OpenJDK integration.
Modified Paths:
--------------
trunk/core/src/classpath/java/java/io/FileOutputStream.java
trunk/core/src/classpath/vm/java/lang/ClassLoader.java
trunk/core/src/classpath/vm/java/lang/Thread.java
trunk/core/src/core/org/jnode/log4j/config/UnsafeDebugAppender.java
trunk/core/src/core/org/jnode/vm/isolate/VmIsolate.java
trunk/core/src/openjdk/vm/java/lang/NativeShutdown.java
trunk/core/src/openjdk/vm/java/lang/NativeSystem.java
trunk/gui/src/awt/org/jnode/awt/swingpeers/SwingToolkit.java
Added Paths:
-----------
trunk/core/src/openjdk/java/java/lang/ProcessBuilder.java
trunk/core/src/openjdk/java/java/lang/Runtime.java
trunk/core/src/openjdk/java/java/lang/System.java
trunk/core/src/openjdk/vm/java/lang/NativeProcessEnvironment.java
trunk/core/src/openjdk/vm/java/lang/NativeUNIXProcess.java
trunk/core/src/openjdk/vm/java/lang/ProcessEnvironment.java
trunk/core/src/openjdk/vm/java/lang/ProcessImpl.java
trunk/core/src/openjdk/vm/java/lang/Terminator.java
trunk/core/src/openjdk/vm/java/lang/UNIXProcess.java
Removed Paths:
-------------
trunk/core/src/classpath/java/java/lang/ProcessBuilder.java
trunk/core/src/classpath/java/java/lang/Runtime.java
trunk/core/src/classpath/java/java/lang/System.java
Modified: trunk/core/src/classpath/java/java/io/FileOutputStream.java
===================================================================
--- trunk/core/src/classpath/java/java/io/FileOutputStream.java 2009-01-03 21:05:14 UTC (rev 4821)
+++ trunk/core/src/classpath/java/java/io/FileOutputStream.java 2009-01-03 21:16:46 UTC (rev 4822)
@@ -194,10 +194,9 @@
public FileOutputStream (FileDescriptor fdObj)
throws SecurityException
{
- // Hmm, no other exception but this one to throw, but if the descriptor
- // isn't valid, we surely don't have "permission" to write to it.
- if (!fdObj.valid())
- throw new SecurityException("Invalid FileDescriptor");
+ if (fdObj == null) {
+ throw new NullPointerException();
+ }
SecurityManager s = System.getSecurityManager();
if (s != null)
Deleted: trunk/core/src/classpath/java/java/lang/ProcessBuilder.java
===================================================================
--- trunk/core/src/classpath/java/java/lang/ProcessBuilder.java 2009-01-03 21:05:14 UTC (rev 4821)
+++ trunk/core/src/classpath/java/java/lang/ProcessBuilder.java 2009-01-03 21:16:46 UTC (rev 4822)
@@ -1,337 +0,0 @@
-/* ProcessBuilder.java - Represent spawned system process
- Copyright (C) 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.lang;
-
-import java.io.File;
-import java.io.IOException;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-
-/**
- * <p>
- * This class is used to construct new operating system processes.
- * A <code>ProcessBuilder</code> instance basically represent a
- * template for a new process. Actual processes are generated from
- * this template via use of the <code>start()</code> method, which
- * may be invoked multiple times, with each invocation spawning a
- * new process with the current attributes of the
- * <code>ProcessBuilder</code> object. Each spawned process is
- * independent of the <code>ProcessBuilder</code> object, and is
- * unaffected by changes in its attributes.
- * </p>
- * <p>
- * The following attributes define a process:
- * </p>
- * <ul>
- * <li>The <emphasis>working directory</emphasis>; the activities of a
- * process begin with the current directory set to this. By default,
- * this is the working directory of the current process, as defined
- * by the <code>user.dir</code> property.</li>
- * <li>The <emphasis>command</emphasis> which invokes the process. This
- * usually consists of the name of the program binary followed by an
- * arbitrary number of arguments. For example, <code>find -type f</code>
- * invokes the <code>find</code> binary with the arguments "-type" and "f".
- * The command is provided a list, the elements of which are defined in a
- * system dependent manner; the layout is affected by expected operating
- * system conventions. A common method is to split the command on each
- * space within the string. Thus, <code>find -type f</code> forms a
- * three element list. However, in some cases, the expectation is that
- * this split is performed by the program itself; thus, the list consists
- * of only two elements (the program name and its arguments).</li>
- * <li>The <emphasis>environment map</emphasis>, which links environment
- * variables to their corresponding values. The initial contents of the map
- * are the current environment values i.e. it contains the contents of the
- * map returned by <code>System.getenv()</code>.</li>
- * <li>The <emphasis>redirection flag</emphasis>, which specifies whether
- * or not the contents of the error stream should be redirected to standard
- * output. By default, this is false, and there are two output streams, one
- * for normal data ({@link Process#getOutputStream()}) and one for error data
- * ({@link Process#getErrorStream()}). When set to true, the two are merged,
- * which simplifies the interleaving of the two streams. Data is read using
- * the stream returned by {@link Process#getOutputStream()}, and the
- * stream returned by {@link Process#getErrorStream()} throws an immediate
- * end-of-file exception.</li>
- * </ul>
- * <p>
- * All checks on attribute validity are delayed until <code>start()</code>
- * is called. <code>ProcessBuilder</code> objects are <strong>not
- * synchronized</strong>; the user must provide external synchronization
- * where multiple threads may interact with the same
- * <code>ProcessBuilder</code> object.
- * </p>
- *
- * @author Tom Tromey (tr...@re...)
- * @author Andrew John Hughes (gnu...@me...)
- * @see Process
- * @see System#getenv()
- * @since 1.5
- */
-public final class ProcessBuilder
-{
-
- /**
- * The working directory of the process.
- */
- private File directory = new File(System.getProperty("user.dir"));
-
- /**
- * The command line syntax for invoking the process.
- */
- private List<String> command;
-
- /**
- * The mapping of environment variables to values.
- */
- private Map<String, String> environment =
- new System.EnvironmentMap(System.getenv());
-
- /**
- * A flag indicating whether to redirect the error stream to standard
- * output.
- */
- private boolean redirect = false;
-
- /**
- * Constructs a new <code>ProcessBuilder</code> with the specified
- * command being used to invoke the process. The list is used directly;
- * external changes are reflected in the <code>ProcessBuilder</code>.
- *
- * @param command the name of the program followed by its arguments.
- */
- public ProcessBuilder(List<String> command)
- {
- this.command = command;
- }
-
- /**
- * Constructs a new <code>ProcessBuilder</code> with the specified
- * command being used to invoke the process. This constructor
- * simplifies creating a new <code>ProcessBuilder</code> by
- * converting the provided series of constructor arguments into a
- * list of command-line arguments.
- *
- * @param command the name of the program followed by its arguments.
- */
- public ProcessBuilder(String... command)
- {
- this.command = Arrays.asList(command);
- }
-
- /**
- * Returns the current command line, used to invoke the process.
- * The return value is simply a reference to the list of command
- * line arguments used by the <code>ProcessBuilder</code> object;
- * any changes made to it will be reflected in the operation of
- * the <code>ProcessBuilder</code>.
- *
- * @return the list of command-line arguments.
- */
- public List<String> command()
- {
- return command;
- }
-
- /**
- * Sets the command-line arguments to those specified. The list is
- * used directly; external changes are reflected in the
- * <code>ProcessBuilder</code>.
- *
- * @param command the name of the program followed by its arguments.
- * @return a reference to this process builder.
- */
- public ProcessBuilder command(List<String> command)
- {
- this.command = command;
- return this;
- }
-
- /**
- * Sets the command-line arguments to those specified.
- * This simplifies modifying the arguments by converting
- * the provided series of constructor arguments into a
- * list of command-line arguments.
- *
- * @param command the name of the program followed by its arguments.
- * @return a reference to this process builder.
- */
- public ProcessBuilder command(String... command)
- {
- this.command = Arrays.asList(command);
- return this;
- }
-
- /**
- * Returns the working directory of the process. The
- * returned value may be <code>null</code>; this
- * indicates that the default behaviour of using the
- * working directory of the current process should
- * be adopted.
- *
- * @return the working directory.
- */
- public File directory()
- {
- return directory;
- }
-
- /**
- * Sets the working directory to that specified.
- * The supplied argument may be <code>null</code>,
- * which indicates the default value should be used.
- * The default is the working directory of the current
- * process.
- *
- * @param directory the new working directory.
- * @return a reference to this process builder.
- */
- public ProcessBuilder directory(File directory)
- {
- this.directory = directory;
- return this;
- }
-
- /**
- * <p>
- * Returns the system environment variables of the process.
- * If the underlying system does not support environment variables,
- * an empty map is returned.
- * </p>
- * <p>
- * The returned map does not accept queries using
- * null keys or values, or those of a type other than
- * <code>String</code>. Attempts to pass in a null value will
- * throw a <code>NullPointerException</code>. Types other than
- * <code>String</code> throw a <code>ClassCastException</code>.
- * </p>
- * <p>
- * As the returned map is generated using data from the underlying
- * platform, it may not comply with the <code>equals()</code>
- * and <code>hashCode()</code> contracts. It is also likely that
- * the keys of this map will be case-sensitive.
- * </p>
- * <p>
- * Modification of the map is reliant on the underlying platform;
- * some may not allow any changes to the environment variables or
- * may prevent certain values being used. Attempts to do so will
- * throw an <code>UnsupportedOperationException</code> or
- * <code>IllegalArgumentException</code>, respectively.
- * </p>
- * <p>
- * Use of this method may require a security check for the
- * RuntimePermission "getenv.*".
- * </p>
- *
- * @return a map of the system environment variables for the process.
- * @throws SecurityException if the checkPermission method of
- * an installed security manager prevents access to
- * the system environment variables.
- * @since 1.5
- */
- public Map<String, String> environment()
- {
- return environment;
- }
-
- /**
- * Returns true if the output stream and error stream of the
- * process will be merged to form one composite stream. The
- * default return value is <code>false</code>.
- *
- * @return true if the output stream and error stream are to
- * be merged.
- */
- public boolean redirectErrorStream()
- {
- return redirect;
- }
-
- /**
- * Sets the error stream redirection flag. If set, the output
- * and error streams are merged to form one composite stream.
- *
- * @param redirect the new value of the redirection flag.
- * @return a reference to this process builder.
- */
- public ProcessBuilder redirectErrorStream(boolean redirect)
- {
- this.redirect = redirect;
- return this;
- }
-
- /**
- * <p>
- * Starts execution of a new process, based on the attributes of
- * this <code>ProcessBuilder</code> object. This is the point
- * at which the command-line arguments are checked. The list
- * must be non-empty and contain only non-null string objects.
- * The other attributes have default values which are used in
- * cases where their values are not explicitly specified.
- * </p>
- * <p>
- * If a security manager is in place, then the
- * {@link SecurityManager#checkExec()} method is called to
- * ensure that permission is given to execute the process.
- * </p>
- * <p>
- * The execution of the process is system-dependent. Various
- * exceptions may result, due to problems at the operating system
- * level. These are all returned as a form of {@link IOException}.
- * </p>
- *
- * @return a <code>Process</code> object, representing the spawned
- * subprocess.
- * @throws IOException if a problem occurs with executing the process
- * at the operating system level.
- * @throws IndexOutOfBoundsException if the command to execute is
- * actually an empty list.
- * @throws NullPointerException if the command to execute is null
- * or the list contains null elements.
- * @throws SecurityException if a security manager exists and prevents
- * execution of the subprocess.
- */
- public Process start() throws IOException
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe!
- if (sm != null)
- sm.checkExec(command.get(0));
- return VMProcess.exec(command, environment, directory, redirect);
- }
-}
Deleted: trunk/core/src/classpath/java/java/lang/Runtime.java
===================================================================
--- trunk/core/src/classpath/java/java/lang/Runtime.java 2009-01-03 21:05:14 UTC (rev 4821)
+++ trunk/core/src/classpath/java/java/lang/Runtime.java 2009-01-03 21:16:46 UTC (rev 4822)
@@ -1,813 +0,0 @@
-/* Runtime.java -- access to the VM process
- Copyright (C) 1998, 2002, 2003, 2004, 2005 Free Software Foundation
-
-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.lang;
-
-import gnu.classpath.SystemProperties;
-import gnu.classpath.VMStackWalker;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-import java.util.StringTokenizer;
-
-/**
- * Runtime represents the Virtual Machine.
- *
- * @author John Keiser
- * @author Eric Blake (eb...@em...)
- * @author Jeroen Frijters
- */
-// No idea why this class isn't final, since you can't build a subclass!
-public class Runtime
-{
- /**
- * The library path, to search when loading libraries. We can also safely use
- * this as a lock for synchronization.
- */
- private final String[] libpath;
-
- /**
- * The thread that started the exit sequence. Access to this field must
- * be thread-safe; lock on libpath to avoid deadlock with user code.
- * <code>runFinalization()</code> may want to look at this to see if ALL
- * finalizers should be run, because the virtual machine is about to halt.
- */
- private Thread exitSequence;
-
- /**
- * All shutdown hooks. This is initialized lazily, and set to null once all
- * shutdown hooks have run. Access to this field must be thread-safe; lock
- * on libpath to avoid deadlock with user code.
- */
- private Set shutdownHooks;
-
- /**
- * The one and only runtime instance.
- */
- private static final Runtime current = new Runtime();
-
- /**
- * Not instantiable by a user, this should only create one instance.
- */
- private Runtime()
- {
- if (current != null)
- throw new InternalError("Attempt to recreate Runtime");
-
- // If used by underlying VM this contains the directories where Classpath's own
- // native libraries are located.
- String bootPath = SystemProperties.getProperty("gnu.classpath.boot.library.path", "");
-
- // If properly set by the user this contains the directories where the application's
- // native libraries are located. On operating systems where a LD_LIBRARY_PATH environment
- // variable is available a VM should preset java.library.path with value of this
- // variable.
- String path = SystemProperties.getProperty("java.library.path", ".");
- String pathSep = SystemProperties.getProperty("path.separator", ":");
- String fileSep = SystemProperties.getProperty("file.separator", "/");
-
- StringTokenizer t1 = new StringTokenizer(bootPath, pathSep);
- StringTokenizer t2 = new StringTokenizer(path, pathSep);
- libpath = new String[t1.countTokens() + t2.countTokens()];
-
- int i = 0;
- while(t1.hasMoreTokens()) {
- String prefix = t1.nextToken();
- if (! prefix.endsWith(fileSep))
- prefix += fileSep;
-
- libpath[i] = prefix;
- i++;
- }
-
- while(t2.hasMoreTokens()) {
- String prefix = t2.nextToken();
- if (! prefix.endsWith(fileSep))
- prefix += fileSep;
-
- libpath[i] = prefix;
- i++;
- }
- }
-
- /**
- * Get the current Runtime object for this JVM. This is necessary to access
- * the many instance methods of this class.
- *
- * @return the current Runtime object
- */
- public static Runtime getRuntime()
- {
- return current;
- }
-
- /**
- * Exit the Java runtime. This method will either throw a SecurityException
- * or it will never return. The status code is returned to the system; often
- * a non-zero status code indicates an abnormal exit. Of course, there is a
- * security check, <code>checkExit(status)</code>.
- *
- * <p>First, all shutdown hooks are run, in unspecified order, and
- * concurrently. Next, if finalization on exit has been enabled, all pending
- * finalizers are run. Finally, the system calls <code>halt</code>.</p>
- *
- * <p>If this is run a second time after shutdown has already started, there
- * are two actions. If shutdown hooks are still executing, it blocks
- * indefinitely. Otherwise, if the status is nonzero it halts immediately;
- * if it is zero, it blocks indefinitely. This is typically called by
- * <code>System.exit</code>.</p>
- *
- * @param status the status to exit with
- * @throws SecurityException if permission is denied
- * @see #addShutdownHook(Thread)
- * @see #runFinalizersOnExit(boolean)
- * @see #runFinalization()
- * @see #halt(int)
- */
- public void exit(int status)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe!
- if (sm != null)
- sm.checkExit(status);
-
- if (runShutdownHooks())
- VMRuntime.exit(status);
-
- // Someone else already called runShutdownHooks().
- // Make sure we are not/no longer in the shutdownHooks set.
- // And wait till the thread that is calling runShutdownHooks() finishes.
- synchronized (libpath)
- {
- if (shutdownHooks != null)
- {
- shutdownHooks.remove(Thread.currentThread());
- // Interrupt the exit sequence thread, in case it was waiting
- // inside a join on our thread.
- exitSequence.interrupt();
- // Shutdown hooks are still running, so we clear status to
- // make sure we don't halt.
- status = 0;
- }
- }
-
- // If exit() is called again after the shutdown hooks have run, but
- // while finalization for exit is going on and the status is non-zero
- // we halt immediately.
- if (status != 0)
- VMRuntime.exit(status);
-
-// @classpath-bugfix 27213 19/4/2006 Martin Husted Hartvig (ha...@jn...) :
- while (shutdownHooks != null)
- {
- try
- {
- exitSequence.join();
- }
- catch (InterruptedException e)
- {
- // Ignore, we've suspended indefinitely to let all shutdown
- // hooks complete, and to let any non-zero exits through, because
- // this is a duplicate call to exit(0).
- }
- }
-
- VMRuntime.exit(status);
-// @classpath-bugfix-end
- }
-
- /**
- * On first invocation, run all the shutdown hooks and return true.
- * Any subsequent invocations will simply return false.
- * Note that it is package accessible so that VMRuntime can call it
- * when VM exit is not triggered by a call to Runtime.exit().
- *
- * @return was the current thread the first one to call this method?
- */
- boolean runShutdownHooks()
- {
- boolean first = false;
- synchronized (libpath) // Synch on libpath, not this, to avoid deadlock.
- {
- if (exitSequence == null)
- {
- first = true;
- exitSequence = Thread.currentThread();
- if (shutdownHooks != null)
- {
- Iterator i = shutdownHooks.iterator();
- while (i.hasNext()) // Start all shutdown hooks.
- try
- {
- ((Thread) i.next()).start();
- }
- catch (IllegalThreadStateException e)
- {
- i.remove();
- }
- }
- }
- }
- if (first)
- {
- if (shutdownHooks != null)
- {
- // Check progress of all shutdown hooks. As a hook completes,
- // remove it from the set. If a hook calls exit, it removes
- // itself from the set, then waits indefinitely on the
- // exitSequence thread. Once the set is empty, set it to null to
- // signal all finalizer threads that halt may be called.
- while (true)
- {
- Thread[] hooks;
- synchronized (libpath)
- {
- hooks = new Thread[shutdownHooks.size()];
- shutdownHooks.toArray(hooks);
- }
- if (hooks.length == 0)
- break;
- for (int i = 0; i < hooks.length; i++)
- {
- try
- {
- synchronized (libpath)
- {
- if (!shutdownHooks.contains(hooks[i]))
- continue;
- }
- hooks[i].join();
- synchronized (libpath)
- {
- shutdownHooks.remove(hooks[i]);
- }
- }
- catch (InterruptedException x)
- {
- // continue waiting on the next thread
- }
- }
- }
- synchronized (libpath)
- {
- shutdownHooks = null;
- }
- }
- // Run finalization on all finalizable objects (even if they are
- // still reachable).
- VMRuntime.runFinalizationForExit();
-
-// @classpath-bugfix 27213 19/4/2006 Martin Husted Hartvig (ha...@jn...) :
- synchronized (libpath)
- {
- exitSequence = null;
- }
-// @classpath-bugfix-end
- }
- return first;
- }
-
- /**
- * Register a new shutdown hook. This is invoked when the program exits
- * normally (because all non-daemon threads ended, or because
- * <code>System.exit</code> was invoked), or when the user terminates
- * the virtual machine (such as by typing ^C, or logging off). There is
- * a security check to add hooks,
- * <code>RuntimePermission("shutdownHooks")</code>.
- *
- * <p>The hook must be an initialized, but unstarted Thread. The threads
- * are run concurrently, and started in an arbitrary order; and user
- * threads or daemons may still be running. Once shutdown hooks have
- * started, they must all complete, or else you must use <code>halt</code>,
- * to actually finish the shutdown sequence. Attempts to modify hooks
- * after shutdown has started result in IllegalStateExceptions.</p>
- *
- * <p>It is imperative that you code shutdown hooks defensively, as you
- * do not want to deadlock, and have no idea what other hooks will be
- * running concurrently. It is also a good idea to finish quickly, as the
- * virtual machine really wants to shut down!</p>
- *
- * <p>There are no guarantees that such hooks will run, as there are ways
- * to forcibly kill a process. But in such a drastic case, shutdown hooks
- * would do little for you in the first place.</p>
- *
- * @param hook an initialized, unstarted Thread
- * @throws IllegalArgumentException if the hook is already registered or run
- * @throws IllegalStateException if the virtual machine is already in
- * the shutdown sequence
- * @throws SecurityException if permission is denied
- * @since 1.3
- * @see #removeShutdownHook(Thread)
- * @see #exit(int)
- * @see #halt(int)
- */
- public void addShutdownHook(Thread hook)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe!
- if (sm != null)
- sm.checkPermission(new RuntimePermission("shutdownHooks"));
-
- //jnode
- //todo investigate the reson of this chek failing
- //if (hook.isAlive() || hook.getThreadGroup() == null)
- // throw new IllegalArgumentException("The hook thread " + hook + " must not have been already run or started");
-
- synchronized (libpath)
- {
- if (exitSequence != null)
- throw new IllegalStateException("The Virtual Machine is exiting. It is not possible anymore to add any hooks");
- if (shutdownHooks == null)
- {
- VMRuntime.enableShutdownHooks();
- shutdownHooks = new HashSet(); // Lazy initialization.
- }
- if (! shutdownHooks.add(hook))
- throw new IllegalArgumentException(hook.toString() + " had already been inserted");
- }
- }
-
- /**
- * De-register a shutdown hook. As when you registered it, there is a
- * security check to remove hooks,
- * <code>RuntimePermission("shutdownHooks")</code>.
- *
- * @param hook the hook to remove
- * @return true if the hook was successfully removed, false if it was not
- * registered in the first place
- * @throws IllegalStateException if the virtual machine is already in
- * the shutdown sequence
- * @throws SecurityException if permission is denied
- * @since 1.3
- * @see #addShutdownHook(Thread)
- * @see #exit(int)
- * @see #halt(int)
- */
- public boolean removeShutdownHook(Thread hook)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe!
- if (sm != null)
- sm.checkPermission(new RuntimePermission("shutdownHooks"));
- synchronized (libpath)
- {
- if (exitSequence != null)
- throw new IllegalStateException();
- if (shutdownHooks != null)
- return shutdownHooks.remove(hook);
- }
- return false;
- }
-
- /**
- * Forcibly terminate the virtual machine. This call never returns. It is
- * much more severe than <code>exit</code>, as it bypasses all shutdown
- * hooks and initializers. Use caution in calling this! Of course, there is
- * a security check, <code>checkExit(status)</code>.
- *
- * @param status the status to exit with
- * @throws SecurityException if permission is denied
- * @since 1.3
- * @see #exit(int)
- * @see #addShutdownHook(Thread)
- */
- public void halt(int status)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe!
- if (sm != null)
- sm.checkExit(status);
- VMRuntime.halt(status);
- }
-
- /**
- * Tell the VM to run the finalize() method on every single Object before
- * it exits. Note that the JVM may still exit abnormally and not perform
- * this, so you still don't have a guarantee. And besides that, this is
- * inherently unsafe in multi-threaded code, as it may result in deadlock
- * as multiple threads compete to manipulate objects. This value defaults to
- * <code>false</code>. There is a security check, <code>checkExit(0)</code>.
- *
- * @param finalizeOnExit whether to finalize all Objects on exit
- * @throws SecurityException if permission is denied
- * @see #exit(int)
- * @see #gc()
- * @since 1.1
- * @deprecated never rely on finalizers to do a clean, thread-safe,
- * mop-up from your code
- */
- public static void runFinalizersOnExit(boolean finalizeOnExit)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe!
- if (sm != null)
- sm.checkExit(0);
- VMRuntime.runFinalizersOnExit(finalizeOnExit);
- }
-
- /**
- * Create a new subprocess with the specified command line. Calls
- * <code>exec(cmdline, null, null)</code>. A security check is performed,
- * <code>checkExec</code>.
- *
- * @param cmdline the command to call
- * @return the Process object
- * @throws SecurityException if permission is denied
- * @throws IOException if an I/O error occurs
- * @throws NullPointerException if cmdline is null
- * @throws IndexOutOfBoundsException if cmdline is ""
- */
- public Process exec(String cmdline) throws IOException
- {
- return exec(cmdline, null, null);
- }
-
- /**
- * Create a new subprocess with the specified command line and environment.
- * If the environment is null, the process inherits the environment of
- * this process. Calls <code>exec(cmdline, env, null)</code>. A security
- * check is performed, <code>checkExec</code>.
- *
- * @param cmdline the command to call
- * @param env the environment to use, in the format name=value
- * @return the Process object
- * @throws SecurityException if permission is denied
- * @throws IOException if an I/O error occurs
- * @throws NullPointerException if cmdline is null, or env has null entries
- * @throws IndexOutOfBoundsException if cmdline is ""
- */
- public Process exec(String cmdline, String[] env) throws IOException
- {
- return exec(cmdline, env, null);
- }
-
- /**
- * Create a new subprocess with the specified command line, environment, and
- * working directory. If the environment is null, the process inherits the
- * environment of this process. If the directory is null, the process uses
- * the current working directory. This splits cmdline into an array, using
- * the default StringTokenizer, then calls
- * <code>exec(cmdArray, env, dir)</code>. A security check is performed,
- * <code>checkExec</code>.
- *
- * @param cmdline the command to call
- * @param env the environment to use, in the format name=value
- * @param dir the working directory to use
- * @return the Process object
- * @throws SecurityException if permission is denied
- * @throws IOException if an I/O error occurs
- * @throws NullPointerException if cmdline is null, or env has null entries
- * @throws IndexOutOfBoundsException if cmdline is ""
- * @since 1.3
- */
- public Process exec(String cmdline, String[] env, File dir)
- throws IOException
- {
- StringTokenizer t = new StringTokenizer(cmdline);
- String[] cmd = new String[t.countTokens()];
- for (int i = 0; i < cmd.length; i++)
- cmd[i] = t.nextToken();
- return exec(cmd, env, dir);
- }
-
- /**
- * Create a new subprocess with the specified command line, already
- * tokenized. Calls <code>exec(cmd, null, null)</code>. A security check
- * is performed, <code>checkExec</code>.
- *
- * @param cmd the command to call
- * @return the Process object
- * @throws SecurityException if permission is denied
- * @throws IOException if an I/O error occurs
- * @throws NullPointerException if cmd is null, or has null entries
- * @throws IndexOutOfBoundsException if cmd is length 0
- */
- public Process exec(String[] cmd) throws IOException
- {
- return exec(cmd, null, null);
- }
-
- /**
- * Create a new subprocess with the specified command line, already
- * tokenized, and specified environment. If the environment is null, the
- * process inherits the environment of this process. Calls
- * <code>exec(cmd, env, null)</code>. A security check is performed,
- * <code>checkExec</code>.
- *
- * @param cmd the command to call
- * @param env the environment to use, in the format name=value
- * @return the Process object
- * @throws SecurityException if permission is denied
- * @throws IOException if an I/O error occurs
- * @throws NullPointerException if cmd is null, or cmd or env has null
- * entries
- * @throws IndexOutOfBoundsException if cmd is length 0
- */
- public Process exec(String[] cmd, String[] env) throws IOException
- {
- return exec(cmd, env, null);
- }
-
- /**
- * Create a new subprocess with the specified command line, already
- * tokenized, and the specified environment and working directory. If the
- * environment is null, the process inherits the environment of this
- * process. If the directory is null, the process uses the current working
- * directory. A security check is performed, <code>checkExec</code>.
- *
- * @param cmd the command to call
- * @param env the environment to use, in the format name=value
- * @param dir the working directory to use
- * @return the Process object
- * @throws SecurityException if permission is denied
- * @throws IOException if an I/O error occurs
- * @throws NullPointerException if cmd is null, or cmd or env has null
- * entries
- * @throws IndexOutOfBoundsException if cmd is length 0
- * @since 1.3
- */
- public Process exec(String[] cmd, String[] env, File dir)
- throws IOException
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe!
- if (sm != null)
- sm.checkExec(cmd[0]);
- return VMRuntime.exec(cmd, env, dir);
- }
-
- /**
- * Returns the number of available processors currently available to the
- * virtual machine. This number may change over time; so a multi-processor
- * program want to poll this to determine maximal resource usage.
- *
- * @return the number of processors available, at least 1
- */
- public int availableProcessors()
- {
- return VMRuntime.availableProcessors();
- }
-
- /**
- * Find out how much memory is still free for allocating Objects on the heap.
- *
- * @return the number of bytes of free memory for more Objects
- */
- public long freeMemory()
- {
- return VMRuntime.freeMemory();
- }
-
- /**
- * Find out how much memory total is available on the heap for allocating
- * Objects.
- *
- * @return the total number of bytes of memory for Objects
- */
- public long totalMemory()
- {
- return VMRuntime.totalMemory();
- }
-
- /**
- * Returns the maximum amount of memory the virtual machine can attempt to
- * use. This may be <code>Long.MAX_VALUE</code> if there is no inherent
- * limit (or if you really do have a 8 exabyte memory!).
- *
- * @return the maximum number of bytes the virtual machine will attempt
- * to allocate
- */
- public long maxMemory()
- {
- return VMRuntime.maxMemory();
- }
-
- /**
- * Run the garbage collector. This method is more of a suggestion than
- * anything. All this method guarantees is that the garbage collector will
- * have "done its best" by the time it returns. Notice that garbage
- * collection takes place even without calling this method.
- */
- public void gc()
- {
- VMRuntime.gc();
- }
-
- /**
- * Run finalization on all Objects that are waiting to be finalized. Again,
- * a suggestion, though a stronger one than {@link #gc()}. This calls the
- * <code>finalize</code> method of all objects waiting to be collected.
- *
- * @see #finalize()
- */
- public void runFinalization()
- {
- VMRuntime.runFinalization();
- }
-
- /**
- * Tell the VM to trace every bytecode instruction that executes (print out
- * a trace of it). No guarantees are made as to where it will be printed,
- * and the VM is allowed to ignore this request.
- *
- * @param on whether to turn instruction tracing on
- */
- public void traceInstructions(boolean on)
- {
- VMRuntime.traceInstructions(on);
- }
-
- /**
- * Tell the VM to trace every method call that executes (print out a trace
- * of it). No guarantees are made as to where it will be printed, and the
- * VM is allowed to ignore this request.
- *
- * @param on whether to turn method tracing on
- */
- public void traceMethodCalls(boolean on)
- {
- VMRuntime.traceMethodCalls(on);
- }
-
- /**
- * Load a native library using the system-dependent filename. This is similar
- * to loadLibrary, except the only name mangling done is inserting "_g"
- * before the final ".so" if the VM was invoked by the name "java_g". There
- * may be a security check, of <code>checkLink</code>.
- *
- * <p>
- * The library is loaded using the class loader associated with the
- * class associated with the invoking method.
- *
- * @param filename the file to load
- * @throws SecurityException if permission is denied
- * @throws UnsatisfiedLinkError if the library is not found
- */
- public void load(String filename)
- {
- load(filename, VMStackWalker.getCallingClassLoader());
- }
-
- /**
- * Same as <code>load(String)</code> but using the given loader.
- *
- * @param filename the file to load
- * @param loader class loader, or <code>null</code> for the boot loader
- * @throws SecurityException if permission is denied
- * @throws UnsatisfiedLinkError if the library is not found
- */
- void load(String filename, ClassLoader loader)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe!
- if (sm != null)
- sm.checkLink(filename);
- if (loadLib(filename, loader) == 0)
- throw new UnsatisfiedLinkError("Could not load library " + filename);
- }
-
- /**
- * Do a security check on the filename and then load the native library.
- *
- * @param filename the file to load
- * @param loader class loader, or <code>null</code> for the boot loader
- * @return 0 on failure, nonzero on success
- * @throws SecurityException if file read permission is denied
- */
- private static int loadLib(String filename, ClassLoader loader)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe!
- if (sm != null)
- sm.checkRead(filename);
- return VMRuntime.nativeLoad(filename, loader);
- }
-
- /**
- * Load a native library using a system-independent "short name" for the
- * library. It will be transformed to a correct filename in a
- * system-dependent manner (for example, in Windows, "mylib" will be turned
- * into "mylib.dll"). This is done as follows: if the context that called
- * load has a ClassLoader cl, then <code>cl.findLibrary(libpath)</code> is
- * used to convert the name. If that result was null, or there was no class
- * loader, this searches each directory of the system property
- * <code>java.library.path</code> for a file named
- * <code>System.mapLibraryName(libname)</code>. There may be a security
- * check, of <code>checkLink</code>.
- *
- * <p>Note: Besides <code>java.library.path</code> a VM may chose to search
- * for native libraries in a path that is specified by the
- * <code>gnu.classpath.boot.library.path</code> system property. However
- * this is for internal usage or development of GNU Classpath only.
- * <b>A Java application must not load a non-system library by changing
- * this property otherwise it will break compatibility.</b></p>
- *
- * <p>
- * The library is loaded using the class loader associated with the
- * class associated with the invoking method.
- *
- * @param libname the library to load
- *
- * @throws SecurityException if permission is denied
- * @throws UnsatisfiedLinkError if the library is not found
- *
- * @see System#mapLibraryName(String)
- * @see ClassLoader#findLibrary(String)
- */
- public void loadLibrary(String libname)
- {
- loadLibrary(libname, VMStackWalker.getCallingClassLoader());
- }
-
- /**
- * Same as <code>loadLibrary(String)</code> but using the given loader.
- *
- * @param libname the library to load
- * @param loader class loader, or <code>null</code> for the boot loader
- * @throws SecurityException if permission is denied
- * @throws UnsatisfiedLinkError if the library is not found
- */
- void loadLibrary(String libname, ClassLoader loader)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe!
- if (sm != null)
- sm.checkLink(libname);
- String filename;
- if (loader != null && (filename = loader.findLibrary(libname)) != null)
- {
- if (loadLib(filename, loader) != 0)
- return;
- }
- else
- {
- filename = VMRuntime.mapLibraryName(libname);
- for (int i = 0; i < libpath.length; i++)
- if (loadLib(libpath[i] + filename, loader) != 0)
- return;
- }
- throw new UnsatisfiedLinkError("Native library `" + libname
- + "' not found (as file `" + filename + "') in gnu.classpath.boot.library.path and java.library.path");
- }
-
- /**
- * Return a localized version of this InputStream, meaning all characters
- * are localized before they come out the other end.
- *
- * @param in the stream to localize
- * @return the localized stream
- * @deprecated <code>InputStreamReader</code> is the preferred way to read
- * local encodings
- * @XXX This implementation does not localize, yet.
- */
- public InputStream getLocalizedInputStream(InputStream in)
- {
- return in;
- }
-
- /**
- * Return a localized version of this OutputStream, meaning all characters
- * are localized before they are sent to the other end.
- *
- * @param out the stream to localize
- * @return the localized stream
- * @deprecated <code>OutputStreamWriter</code> is the preferred way to write
- * local encodings
- * @XXX This implementation does not localize, yet.
- */
- public OutputStream getLocalizedOutputStream(OutputStream out)
- {
- return out;
- }
-} // class Runtime
Deleted: trunk/core/src/classpath/java/java/lang/System.java
===================================================================
--- trunk/core/src/classpath/java/java/lang/System.java 2009-01-03 21:05:14 UTC (rev 4821)
+++ trunk/core/src/classpath/java/java/lang/System.java 2009-01-03 21:16:46 UTC (rev 4822)
@@ -1,1141 +0,0 @@
-/* System.java -- useful methods to interface with the system
- Copyright (C) 1998, 1999, 2000, 2001, 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.lang;
-
-import gnu.classpath.SystemProperties;
-import gnu.classpath.VMStackWalker;
-
-import java.io.InputStream;
-import java.io.PrintStream;
-import java.io.Console;
-import java.io.IOException;
-import java.util.AbstractCollection;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.Properties;
-import java.util.PropertyPermission;
-import java.nio.channels.Channel;
-import java.nio.channels.spi.SelectorProvider;
-
-/**
- * System represents system-wide resources; things that represent the
- * general environment. As such, all methods are static.
- *
- * @author John Keiser
- * @author Eric Blake (eb...@em...)
- * @since 1.0
- * @status still missing 1.4 functionality
- */
-public final class System
-{
- // WARNING: System is a CORE class in the bootstrap cycle. See the comments
- // in vm/reference/java/lang/Runtime for implications of this fact.
-
- /**
- * The standard InputStream. This is assigned at startup and starts its
- * life perfectly valid. Although it is marked final, you can change it
- * using {@link #setIn(InputStream)} through some hefty VM magic.
- *
- * <p>This corresponds to the C stdin and C++ cin variables, which
- * typically input from the keyboard, but may be used to pipe input from
- * other processes or files. That should all be transparent to you,
- * however.
- */
- public static final InputStream in = VMSystem.makeStandardInputStream();
-
- /**
- * The standard output PrintStream. This is assigned at startup and
- * starts its life perfectly valid. Although it is marked final, you can
- * change it using {@link #setOut(PrintStream)} through some hefty VM magic.
- *
- * <p>This corresponds to the C stdout and C++ cout variables, which
- * typically output normal messages to the screen, but may be used to pipe
- * output to other processes or files. That should all be transparent to
- * you, however.
- */
- public static final PrintStream out = VMSystem.makeStandardOutputStream();
-
- /**
- * The standard output PrintStream. This is assigned at startup and
- * starts its life perfectly valid. Although it is marked final, you can
- * change it using {@link #setErr(PrintStream)} through some hefty VM magic.
- *
- * <p>This corresponds to the C stderr and C++ cerr variables, which
- * typically output error messages to the screen, but may be used to pipe
- * output to other processes or files. That should all be transparent to
- * you, however.
- */
- public static final PrintStream err = VMSystem.makeStandardErrorStream();
-
- /**
- * A cached copy of the environment variable map.
- */
- private static Map<String,String> environmentMap;
-
- /**
- * This class is uninstantiable.
- */
- private System()
- {
- }
-
- /**
- * Set {@link #in} to a new InputStream. This uses some VM magic to change
- * a "final" variable, so naturally there is a security check,
- * <code>RuntimePermission("setIO")</code>.
- *
- * @param in the new InputStream
- * @throws SecurityException if permission is denied
- * @since 1.1
- */
- public static void setIn(InputStream in)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe.
- if (sm != null)
- sm.checkPermission(new RuntimePermission("setIO"));
-
- VMSystem.setIn(in);
- }
-
- /**
- * Set {@link #out} to a new PrintStream. This uses some VM magic to change
- * a "final" variable, so naturally there is a security check,
- * <code>RuntimePermission("setIO")</code>.
- *
- * @param out the new PrintStream
- * @throws SecurityException if permission is denied
- * @since 1.1
- */
- public static void setOut(PrintStream out)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe.
- if (sm != null)
- sm.checkPermission(new RuntimePermission("setIO"));
- VMSystem.setOut(out);
- }
-
- /**
- * Set {@link #err} to a new PrintStream. This uses some VM magic to change
- * a "final" variable, so naturally there is a security check,
- * <code>RuntimePermission("setIO")</code>.
- *
- * @param err the new PrintStream
- * @throws SecurityException if permission is denied
- * @since 1.1
- */
- public static void setErr(PrintStream err)
- {
- SecurityManager sm = SecurityManager.current; // Be thread-safe.
- if (sm != null)
- sm.checkPermission(new RuntimePermission("setIO"));
- VMSystem.setErr(err);
- }
-
- /**
- * Set the current SecurityManager. If a security manager already exists,
- * then <code>RuntimePermission("setSecurityManager")</code> is checked
- * first. Since this permission is denied by the default security manager,
- * setting the security manager is often an irreversible action.
- *
- * <STRONG>Spec Note:</STRONG> Don't ask me, I didn't write it. It looks
- * pretty vulnerable; whoever gets to the gate first gets to set the policy.
- * There is probably some way to set the original security manager as a
- * command line argument to the VM, but I don't know it.
- *
- * @param sm the new SecurityManager
- * @throws SecurityException if permission is denied
- */
- public static synchronized void setSecurityManager(SecurityManager sm)
- {
- // Implementation note: the field lives in SecurityManager because of
- // bootstrap initialization issues. This method is synchronized so that
- // no other thread changes it to null before this thread makes the change.
- if (SecurityManager.current != null)
- SecurityManager.current.checkPermission
- (new RuntimePermission("setSecurityManager"));
-
- // java.security.Security's class initialiser loads and parses the
- // policy files. If it hasn't been run already it will be run
- // during the first permission check. That initialisation will
- // fail if a very restrictive security manager is in force, so we
- // preload it here.
- if (SecurityManager.current == null)
- {
- try
- {
- Class.forName("java.security.Security");
- }
- catch (ClassNotFoundException e)
- {
- }
- }
-
- SecurityManager.current = sm;
- }
-
- /**
- * Get the current SecurityManager. If the SecurityManager has not been
- * set yet, then this method returns null.
- *
- * @return the current SecurityManager, or null
- */
- public static SecurityManager getSecurityManager()
- {
- return SecurityManager.current;
- }
-
- /**
- * Get the current time, measured in the number of milliseconds from the
- * beginning of Jan. 1, 1970. This is gathered from the system clock, with
- * any attendant incorrectness (it may be timezone dependent).
- *
- * @return the current time
- * @see java.util.Date
- */
- public static long currentTimeMillis()
- {
- return VMSystem.currentTimeMillis();
- }
-
- /**
- * <p>
- * Returns the current value of a nanosecond-precise system timer.
- * The value of the timer is an offset relative to some arbitrary fixed
- * time, which may be in the future (making the value negative). This
- * method is useful for timing events where nanosecond precision is
- * required. This is achieved by calling this method before and after the
- * event, and taking the difference betweent the two times:
- * </p>
- * <p>
- * <code>long startTime = System.nanoTime();</code><br />
- * <code>... <emph>event code</emph> ...</code><br />
- * <code>long endTime = System.nanoTime();</code><br />
- * <code>long duration = endTime - startTime;</code><br />
- * </p>
- * <p>
- * Note that the value is only nanosecond-precise, and not accurate; there
- * is no guarantee that the difference between two values is really a
- * nanosecond. Also, the value is prone to overflow if the offset
- * exceeds 2^63.
- * </p>
- *
- * @return the time of a system timer in nanoseconds.
- * @since 1.5
- */
- public static long nanoTime()
- {
- return VMSystem.nanoTime();
- }
-
- /**
- * Copy one array onto another from <code>src[srcStart]</code> ...
- * <code>src[srcStart+len-1]</code> to <code>dest[destStart]</code> ...
- * <code>dest[destStart+len-1]</code>. First, the arguments are validated:
- * neither array may be null, they must be of compatible types, and the
- * start and length must fit within both arrays. Then the copying starts,
- * and proceeds through increasing slots. If src and dest are the same
- * array, this will appear to copy the data to a temporary location first.
- * An ArrayStoreException in the middle of copying will leave earlier
- * elements copied, but later elements unchanged.
- *
- * @param src the array to copy elements from
- * @param srcStart the starting position in src
- * @param dest the array to copy elements to
- * @param destStart the starting position in dest
- * @param len the number of elements to copy
- * @throws NullPointerException if src or dest is null
- * @throws ArrayStoreException if src or dest is not an array, if they are
- * not compatible array types, or if an incompatible runtime type
- * is stored in dest
- * @throws IndexOutOfBoundsException if len is negative, or if the start or
- * end copy position in either array is out of bounds
- */
- public static void arraycopy(Object src, int srcStart,
- Object dest, int destStart, int len)
- {
- VMSystem.arraycopy(src, srcStart, dest, destStart, len);
- }
-
- /**
- * Get a hash code computed by the VM for the Object. This hash code will
- * be the same as Object's hashCode() method. It is usually some
- * convolution of the pointer to the Object internal to the VM. It
- * follows standard hash code rules, in that it will remain the same for a
- * given Object for the lifetime of that Object.
- *
- * @param o the Object to get the hash code for
- * @return the VM-dependent hash code for this Object
- * @since 1.1
- */
- public static int identityHashCode(Object o)
- {
- return VMSystem.identityHashCode(o);
- }
-
- /**
- * Get all the system properties at once. A security check may be performed,
- * <code>checkPropertiesAccess</code>. Note that a security manager may
- * allow getting a single property, but not the entire group.
- *
- * <p>The required properties include:
- * <dl>
- * <dt>java.version</dt> <dd>Java version number</dd>
- * <dt>java.vendor</dt> <dd>Java vendor specific string</dd>
- * <dt>java.vendor.url</dt> <dd>Java vendor URL</dd>
- * <dt>java.home</dt> <dd>Java installation directory</dd>
- * <dt>java.vm.specification.version</dt> <dd>VM Spec version</dd>
- * <dt>java.vm.specification.vendor</dt> <dd>VM Spec vendor</dd>
- * <dt>java.vm.specification.name</dt> <dd>VM Spec name</dd>
- * <dt>java.vm.version</dt> <dd>VM implementation version</dd>
- * <dt>java.vm.vendor</dt> <dd>VM implementation vendor</dd>
- * <dt>java.vm.name</dt> <dd>VM implementation name</dd>
- * <dt>java.specification.version</dt> <dd>Java Runtime Environment version</dd>
- * <dt>java.specification.vendor</dt> <dd>Java Runtime Environment vendor</dd>
- * <dt>java.specification.name</dt> <dd>Java Runtime Environment name</dd>
- * <dt>java.class.version</dt> <dd>Java class version number</dd>
- * <dt>java.class.path</dt> <dd>Java classpath</dd>
- * <dt>java.library.path</dt> <dd>Path for finding Java libraries</dd>
- * <dt>java.io.tmpdir</dt> <dd>Default temp file path</dd>
- * <dt>java.compiler</dt> <dd>Name of JIT to use</dd>
- * <dt>java.ext.dirs</dt> <dd>Java extension path</dd>
- * <dt>os.name</dt> <dd>Operating System Name</dd>
- * <dt>os.arch</dt> <dd>Operating System Architecture</dd>
- * <dt>os.version</dt> <dd>Operating System Version</dd>
- * <dt>file.separator</dt> <dd>File separator ("/" on Unix)</dd>
- * <dt>path.separator</dt> <dd>Path separator (":" on Unix)</dd>
- * <dt>line.separator</dt> <dd>Line separator ("\n" on Unix)</dd>
- * <dt>user.name</dt> <dd>User account name</dd>
- * <dt>user.home</dt> <dd>User home directory</dd>
- * <dt>user.dir</dt> <dd>User's current working directory</dd>
- * </dl>
- * ...
[truncated message content] |
