diff options
Diffstat (limited to 'libjava/classpath/vm/reference/java/lang/VMSystem.java')
| -rw-r--r-- | libjava/classpath/vm/reference/java/lang/VMSystem.java | 220 |
1 files changed, 220 insertions, 0 deletions
diff --git a/libjava/classpath/vm/reference/java/lang/VMSystem.java b/libjava/classpath/vm/reference/java/lang/VMSystem.java new file mode 100644 index 000000000..52a3c1c9f --- /dev/null +++ b/libjava/classpath/vm/reference/java/lang/VMSystem.java @@ -0,0 +1,220 @@ +/* VMSystem.java -- helper for java.lang.system + Copyright (C) 1998, 2002, 2004 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 java.util.List; + +import java.io.BufferedInputStream; +import java.io.BufferedOutputStream; +import java.io.FileDescriptor; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.InputStream; +import java.io.PrintStream; + +/** + * VMSystem is a package-private helper class for System that the + * VM must implement. + * + * @author John Keiser + * @author Andrew John Hughes (gnu_andrew@member.fsf.org) + */ +final class VMSystem +{ + /** + * 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 + */ + static native void arraycopy(Object src, int srcStart, + Object dest, int destStart, int 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 + */ + static native int identityHashCode(Object o); + + /** + * Convert a library name to its platform-specific variant. + * + * @param libname the library name, as used in <code>loadLibrary</code> + * @return the platform-specific mangling of the name + * @XXX Add this method + static native String mapLibraryName(String libname); + */ + + /** + * Set {@link System#in} to a new InputStream. + * + * @param in the new InputStream + * @see #setIn(InputStream) + */ + static native void setIn(InputStream in); + + /** + * Set {@link System#out} to a new PrintStream. + * + * @param out the new PrintStream + * @see #setOut(PrintStream) + */ + static native void setOut(PrintStream out); + + /** + * Set {@link System#err} to a new PrintStream. + * + * @param err the new PrintStream + * @see #setErr(PrintStream) + */ + static native void setErr(PrintStream err); + + /** + * 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 nanoTime() / 1000000L; + } + + /** + * <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 native long nanoTime(); + + /** + * Returns a list of 'name=value' pairs representing the current environment + * variables. + * + * @return a list of 'name=value' pairs. + */ + static native List environ(); + + /** + * Helper method which creates the standard input stream. + * VM implementors may choose to construct these streams differently. + * This method can also return null if the stream is created somewhere + * else in the VM startup sequence. + */ + static InputStream makeStandardInputStream() + { + return new BufferedInputStream(new FileInputStream(FileDescriptor.in)); + } + + /** + * Helper method which creates the standard output stream. + * VM implementors may choose to construct these streams differently. + * This method can also return null if the stream is created somewhere + * else in the VM startup sequence. + */ + static PrintStream makeStandardOutputStream() + { + return new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)), true); + } + + /** + * Helper method which creates the standard error stream. + * VM implementors may choose to construct these streams differently. + * This method can also return null if the stream is created somewhere + * else in the VM startup sequence. + */ + static PrintStream makeStandardErrorStream() + { + return new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.err)), true); + } + + /** + * Gets the value of an environment variable. + * Always returning null is a valid (but not very useful) implementation. + * + * @param name The name of the environment variable (will not be null). + * @return The string value of the variable or null when the + * environment variable is not defined. + */ + static native String getenv(String name); +} |