diff options
Diffstat (limited to 'libjava/classpath/vm')
14 files changed, 551 insertions, 47 deletions
diff --git a/libjava/classpath/vm/reference/gnu/classpath/VMSystemProperties.java b/libjava/classpath/vm/reference/gnu/classpath/VMSystemProperties.java index e7cb91fde70..1e0dd4e2632 100644 --- a/libjava/classpath/vm/reference/gnu/classpath/VMSystemProperties.java +++ b/libjava/classpath/vm/reference/gnu/classpath/VMSystemProperties.java @@ -81,7 +81,7 @@ class VMSystemProperties * <dt>gnu.cpu.endian <dd>"big" or "little" * </dl> * - * @param p the Properties object to insert the system properties into + * @param properties the Properties object to insert the system properties into */ static native void preInit(Properties properties); diff --git a/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMFrame.java b/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMFrame.java index 4d3b01074e5..cd213025a72 100644 --- a/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMFrame.java +++ b/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMFrame.java @@ -1,5 +1,5 @@ /* VMFrame.java -- Reference implementation of VM hooks for JDWP Frame access. - Copyright (C) 2005 Free Software Foundation + Copyright (C) 2005, 2006 Free Software Foundation This file is part of GNU Classpath. @@ -49,6 +49,11 @@ import gnu.classpath.jdwp.util.Location; public class VMFrame { + /** + * Returns the size of a frame ID over JDWP + */ + public static final int SIZE = 8; + // The object this frame resides in private Object obj; diff --git a/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMIdManager.java b/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMIdManager.java index 23cbb7b8ee3..6a8be10145f 100644 --- a/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMIdManager.java +++ b/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMIdManager.java @@ -1,7 +1,7 @@ /* VMIdManager.java -- A reference/example implementation of a manager for JDWP object/reference type IDs - Copyright (C) 2005 Free Software Foundation + Copyright (C) 2005, 2006 Free Software Foundation This file is part of GNU Classpath. @@ -76,6 +76,10 @@ import java.util.Iterator; * <b>NOTE:</b> All IDs handled by the ID manager (all object and reference * type IDs) are assumed to be of type <code>long</code>. * + * <b>NOTE:</b> This class does not manage virtual machine-specific types, + * like methods, fields, and frames. These already have unique IDs within + * the virtual machine and do not need further abstraction here. + * * @author Keith Seitz (keiths@redhat.com) */ public class VMIdManager @@ -99,9 +103,6 @@ public class VMIdManager // ObjectId and ArrayId are special cases. See newObjectId. _idList.put (ClassLoaderId.typeClass, ClassLoaderId.class); _idList.put (ClassObjectId.typeClass, ClassObjectId.class); - //_idList.put (FieldId.typeClass, FieldId.class); - //_idList.put (FrameId.typeClass, FrameId.class); - //_idList.put (MethodId.typeClass, MethodId.class); _idList.put (StringId.typeClass, StringId.class); _idList.put (ThreadId.typeClass, ThreadId.class); _idList.put (ThreadGroupId.typeClass, ThreadGroupId.class); @@ -187,6 +188,7 @@ public class VMIdManager id = new InterfaceReferenceTypeId (); else id = new ClassReferenceTypeId (); + id.setReference (ref); synchronized (_ridLock) { id.setId (++_lastRid); diff --git a/libjava/classpath/vm/reference/java/io/VMObjectInputStream.java b/libjava/classpath/vm/reference/java/io/VMObjectInputStream.java index 93a42b1ca9a..5fb56fcd4c9 100644 --- a/libjava/classpath/vm/reference/java/io/VMObjectInputStream.java +++ b/libjava/classpath/vm/reference/java/io/VMObjectInputStream.java @@ -55,25 +55,36 @@ final class VMObjectInputStream } } - // PrivilegedAction needed for Class.getClassLoader() + /** + * PrivilegedAction needed for Class.getClassLoader() + */ private static PrivilegedAction loaderAction = new PrivilegedAction() + { + /** + * Returns the first user defined class loader on the call stack, or the + * context class loader of the current thread, when no non-null class loader + * was found. + */ + public Object run() { - public Object run() - { - Class[] ctx = VMStackWalker.getClassContext(); - for (int i = 0; i < ctx.length; i++) - { - ClassLoader cl = ctx[i].getClassLoader(); - if (cl != null) - return cl; - } - return null; - } + Class[] ctx = VMStackWalker.getClassContext(); + + for (int i = 0; i < ctx.length; i++) + { + ClassLoader cl = ctx[i].getClassLoader(); + if (cl != null) + return cl; + } + return Thread.currentThread().getContextClassLoader(); + } }; /** - * Returns the first user defined class loader on the call stack, or - * null when no non-null class loader was found. + * Returns the first user defined class loader on the call stack, or the + * context class loader of the current thread, when no non-null class loader + * was found. + * + * @return the class loader */ static ClassLoader currentClassLoader() { diff --git a/libjava/classpath/vm/reference/java/lang/VMClass.java b/libjava/classpath/vm/reference/java/lang/VMClass.java index a48e299ee6c..1b4c13e6b5a 100644 --- a/libjava/classpath/vm/reference/java/lang/VMClass.java +++ b/libjava/classpath/vm/reference/java/lang/VMClass.java @@ -37,9 +37,11 @@ exception statement from your version. */ package java.lang; +import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; +import java.lang.reflect.Modifier; /* * This class is a reference version, mainly for compiling a class library @@ -188,7 +190,7 @@ final class VMClass * @param ignoreInnerClassesAttrib if set, return the real modifiers, not * the ones specified in the InnerClasses attribute. * @return the modifiers of this class - * @see Modifer + * @see Modifier * @since 1.1 */ static native int getModifiers(Class klass, boolean ignoreInnerClassesAttrib); @@ -207,7 +209,7 @@ final class VMClass * Like <code>getDeclaredClasses()</code> but without the security checks. * * @param klass the Class object that's calling us - * @param pulicOnly Only public classes should be returned + * @param publicOnly Only public classes should be returned */ static native Class[] getDeclaredClasses(Class klass, boolean publicOnly); @@ -215,7 +217,7 @@ final class VMClass * Like <code>getDeclaredFields()</code> but without the security checks. * * @param klass the Class object that's calling us - * @param pulicOnly Only public fields should be returned + * @param publicOnly Only public fields should be returned */ static native Field[] getDeclaredFields(Class klass, boolean publicOnly); @@ -223,7 +225,7 @@ final class VMClass * Like <code>getDeclaredMethods()</code> but without the security checks. * * @param klass the Class object that's calling us - * @param pulicOnly Only public methods should be returned + * @param publicOnly Only public methods should be returned */ static native Method[] getDeclaredMethods(Class klass, boolean publicOnly); @@ -232,7 +234,7 @@ final class VMClass * the security checks. * * @param klass the Class object that's calling us - * @param pulicOnly Only public constructors should be returned + * @param publicOnly Only public constructors should be returned */ static native Constructor[] getDeclaredConstructors(Class klass, boolean publicOnly); diff --git a/libjava/classpath/vm/reference/java/lang/VMClassLoader.java b/libjava/classpath/vm/reference/java/lang/VMClassLoader.java index a777462aa36..7412afecc3a 100644 --- a/libjava/classpath/vm/reference/java/lang/VMClassLoader.java +++ b/libjava/classpath/vm/reference/java/lang/VMClassLoader.java @@ -170,7 +170,6 @@ final class VMClassLoader * * @param name the resource to find * @return an enumeration of resources - * @throws IOException if one occurs */ static Enumeration getResources(String name) { diff --git a/libjava/classpath/vm/reference/java/lang/VMMath.java b/libjava/classpath/vm/reference/java/lang/VMMath.java new file mode 100644 index 00000000000..4d378245465 --- /dev/null +++ b/libjava/classpath/vm/reference/java/lang/VMMath.java @@ -0,0 +1,493 @@ +/* VMMath.java -- Common mathematical functions. + 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.lang; + +import gnu.classpath.Configuration; + +class VMMath +{ + + static + { + if (Configuration.INIT_LOAD_LIBRARY) + { + System.loadLibrary("javalang"); + } + } + + /** + * The trigonometric function <em>sin</em>. The sine of NaN or infinity is + * NaN, and the sine of 0 retains its sign. This is accurate within 1 ulp, + * and is semi-monotonic. + * + * @param a the angle (in radians) + * @return sin(a) + */ + public static native double sin(double a); + + /** + * The trigonometric function <em>cos</em>. The cosine of NaN or infinity is + * NaN. This is accurate within 1 ulp, and is semi-monotonic. + * + * @param a the angle (in radians) + * @return cos(a) + */ + public static native double cos(double a); + + /** + * The trigonometric function <em>tan</em>. The tangent of NaN or infinity + * is NaN, and the tangent of 0 retains its sign. This is accurate within 1 + * ulp, and is semi-monotonic. + * + * @param a the angle (in radians) + * @return tan(a) + */ + public static native double tan(double a); + + /** + * The trigonometric function <em>arcsin</em>. The range of angles returned + * is -pi/2 to pi/2 radians (-90 to 90 degrees). If the argument is NaN or + * its absolute value is beyond 1, the result is NaN; and the arcsine of + * 0 retains its sign. This is accurate within 1 ulp, and is semi-monotonic. + * + * @param a the sin to turn back into an angle + * @return arcsin(a) + */ + public static native double asin(double a); + + /** + * The trigonometric function <em>arccos</em>. The range of angles returned + * is 0 to pi radians (0 to 180 degrees). If the argument is NaN or + * its absolute value is beyond 1, the result is NaN. This is accurate + * within 1 ulp, and is semi-monotonic. + * + * @param a the cos to turn back into an angle + * @return arccos(a) + */ + public static native double acos(double a); + + /** + * The trigonometric function <em>arcsin</em>. The range of angles returned + * is -pi/2 to pi/2 radians (-90 to 90 degrees). If the argument is NaN, the + * result is NaN; and the arctangent of 0 retains its sign. This is accurate + * within 1 ulp, and is semi-monotonic. + * + * @param a the tan to turn back into an angle + * @return arcsin(a) + * @see #atan2(double, double) + */ + public static native double atan(double a); + + /** + * A special version of the trigonometric function <em>arctan</em>, for + * converting rectangular coordinates <em>(x, y)</em> to polar + * <em>(r, theta)</em>. This computes the arctangent of x/y in the range + * of -pi to pi radians (-180 to 180 degrees). Special cases:<ul> + * <li>If either argument is NaN, the result is NaN.</li> + * <li>If the first argument is positive zero and the second argument is + * positive, or the first argument is positive and finite and the second + * argument is positive infinity, then the result is positive zero.</li> + * <li>If the first argument is negative zero and the second argument is + * positive, or the first argument is negative and finite and the second + * argument is positive infinity, then the result is negative zero.</li> + * <li>If the first argument is positive zero and the second argument is + * negative, or the first argument is positive and finite and the second + * argument is negative infinity, then the result is the double value + * closest to pi.</li> + * <li>If the first argument is negative zero and the second argument is + * negative, or the first argument is negative and finite and the second + * argument is negative infinity, then the result is the double value + * closest to -pi.</li> + * <li>If the first argument is positive and the second argument is + * positive zero or negative zero, or the first argument is positive + * infinity and the second argument is finite, then the result is the + * double value closest to pi/2.</li> + * <li>If the first argument is negative and the second argument is + * positive zero or negative zero, or the first argument is negative + * infinity and the second argument is finite, then the result is the + * double value closest to -pi/2.</li> + * <li>If both arguments are positive infinity, then the result is the + * double value closest to pi/4.</li> + * <li>If the first argument is positive infinity and the second argument + * is negative infinity, then the result is the double value closest to + * 3*pi/4.</li> + * <li>If the first argument is negative infinity and the second argument + * is positive infinity, then the result is the double value closest to + * -pi/4.</li> + * <li>If both arguments are negative infinity, then the result is the + * double value closest to -3*pi/4.</li> + * + * </ul><p>This is accurate within 2 ulps, and is semi-monotonic. To get r, + * use sqrt(x*x+y*y). + * + * @param y the y position + * @param x the x position + * @return <em>theta</em> in the conversion of (x, y) to (r, theta) + * @see #atan(double) + */ + public static native double atan2(double y, double x); + + /** + * Take <em>e</em><sup>a</sup>. The opposite of <code>log()</code>. If the + * argument is NaN, the result is NaN; if the argument is positive infinity, + * the result is positive infinity; and if the argument is negative + * infinity, the result is positive zero. This is accurate within 1 ulp, + * and is semi-monotonic. + * + * @param a the number to raise to the power + * @return the number raised to the power of <em>e</em> + * @see #log(double) + * @see #pow(double, double) + */ + public static native double exp(double a); + + /** + * Take ln(a) (the natural log). The opposite of <code>exp()</code>. If the + * argument is NaN or negative, the result is NaN; if the argument is + * positive infinity, the result is positive infinity; and if the argument + * is either zero, the result is negative infinity. This is accurate within + * 1 ulp, and is semi-monotonic. + * + * <p>Note that the way to get log<sub>b</sub>(a) is to do this: + * <code>ln(a) / ln(b)</code>. + * + * @param a the number to take the natural log of + * @return the natural log of <code>a</code> + * @see #exp(double) + */ + public static native double log(double a); + + /** + * Take a square root. If the argument is NaN or negative, the result is + * NaN; if the argument is positive infinity, the result is positive + * infinity; and if the result is either zero, the result is the same. + * This is accurate within the limits of doubles. + * + * <p>For other roots, use pow(a, 1 / rootNumber). + * + * @param a the numeric argument + * @return the square root of the argument + * @see #pow(double, double) + */ + public static native double sqrt(double a); + + /** + * Raise a number to a power. Special cases:<ul> + * <li>If the second argument is positive or negative zero, then the result + * is 1.0.</li> + * <li>If the second argument is 1.0, then the result is the same as the + * first argument.</li> + * <li>If the second argument is NaN, then the result is NaN.</li> + * <li>If the first argument is NaN and the second argument is nonzero, + * then the result is NaN.</li> + * <li>If the absolute value of the first argument is greater than 1 and + * the second argument is positive infinity, or the absolute value of the + * first argument is less than 1 and the second argument is negative + * infinity, then the result is positive infinity.</li> + * <li>If the absolute value of the first argument is greater than 1 and + * the second argument is negative infinity, or the absolute value of the + * first argument is less than 1 and the second argument is positive + * infinity, then the result is positive zero.</li> + * <li>If the absolute value of the first argument equals 1 and the second + * argument is infinite, then the result is NaN.</li> + * <li>If the first argument is positive zero and the second argument is + * greater than zero, or the first argument is positive infinity and the + * second argument is less than zero, then the result is positive zero.</li> + * <li>If the first argument is positive zero and the second argument is + * less than zero, or the first argument is positive infinity and the + * second argument is greater than zero, then the result is positive + * infinity.</li> + * <li>If the first argument is negative zero and the second argument is + * greater than zero but not a finite odd integer, or the first argument is + * negative infinity and the second argument is less than zero but not a + * finite odd integer, then the result is positive zero.</li> + * <li>If the first argument is negative zero and the second argument is a + * positive finite odd integer, or the first argument is negative infinity + * and the second argument is a negative finite odd integer, then the result + * is negative zero.</li> + * <li>If the first argument is negative zero and the second argument is + * less than zero but not a finite odd integer, or the first argument is + * negative infinity and the second argument is greater than zero but not a + * finite odd integer, then the result is positive infinity.</li> + * <li>If the first argument is negative zero and the second argument is a + * negative finite odd integer, or the first argument is negative infinity + * and the second argument is a positive finite odd integer, then the result + * is negative infinity.</li> + * <li>If the first argument is less than zero and the second argument is a + * finite even integer, then the result is equal to the result of raising + * the absolute value of the first argument to the power of the second + * argument.</li> + * <li>If the first argument is less than zero and the second argument is a + * finite odd integer, then the result is equal to the negative of the + * result of raising the absolute value of the first argument to the power + * of the second argument.</li> + * <li>If the first argument is finite and less than zero and the second + * argument is finite and not an integer, then the result is NaN.</li> + * <li>If both arguments are integers, then the result is exactly equal to + * the mathematical result of raising the first argument to the power of + * the second argument if that result can in fact be represented exactly as + * a double value.</li> + * + * </ul><p>(In the foregoing descriptions, a floating-point value is + * considered to be an integer if and only if it is a fixed point of the + * method {@link #ceil(double)} or, equivalently, a fixed point of the + * method {@link #floor(double)}. A value is a fixed point of a one-argument + * method if and only if the result of applying the method to the value is + * equal to the value.) This is accurate within 1 ulp, and is semi-monotonic. + * + * @param a the number to raise + * @param b the power to raise it to + * @return a<sup>b</sup> + */ + public static native double pow(double a, double b); + + /** + * Get the IEEE 754 floating point remainder on two numbers. This is the + * value of <code>x - y * <em>n</em></code>, where <em>n</em> is the closest + * double to <code>x / y</code> (ties go to the even n); for a zero + * remainder, the sign is that of <code>x</code>. If either argument is NaN, + * the first argument is infinite, or the second argument is zero, the result + * is NaN; if x is finite but y is infinite, the result is x. This is + * accurate within the limits of doubles. + * + * @param x the dividend (the top half) + * @param y the divisor (the bottom half) + * @return the IEEE 754-defined floating point remainder of x/y + * @see #rint(double) + */ + public static native double IEEEremainder(double x, double y); + + /** + * Take the nearest integer that is that is greater than or equal to the + * argument. If the argument is NaN, infinite, or zero, the result is the + * same; if the argument is between -1 and 0, the result is negative zero. + * Note that <code>Math.ceil(x) == -Math.floor(-x)</code>. + * + * @param a the value to act upon + * @return the nearest integer >= <code>a</code> + */ + public static native double ceil(double a); + + /** + * Take the nearest integer that is that is less than or equal to the + * argument. If the argument is NaN, infinite, or zero, the result is the + * same. Note that <code>Math.ceil(x) == -Math.floor(-x)</code>. + * + * @param a the value to act upon + * @return the nearest integer <= <code>a</code> + */ + public static native double floor(double a); + + /** + * Take the nearest integer to the argument. If it is exactly between + * two integers, the even integer is taken. If the argument is NaN, + * infinite, or zero, the result is the same. + * + * @param a the value to act upon + * @return the nearest integer to <code>a</code> + */ + public static native double rint(double a); + + /** + * <p> + * Take a cube root. If the argument is NaN, an infinity or zero, then + * the original value is returned. The returned result must be within 1 ulp + * of the exact result. For a finite value, <code>x</code>, the cube root + * of <code>-x</code> is equal to the negation of the cube root + * of <code>x</code>. + * </p> + * <p> + * For a square root, use <code>sqrt</code>. For other roots, use + * <code>pow(a, 1 / rootNumber)</code>. + * </p> + * + * @param a the numeric argument + * @return the cube root of the argument + * @see #sqrt(double) + * @see #pow(double, double) + */ + public static native double cbrt(double a); + + /** + * <p> + * Returns the hyperbolic cosine of the given value. For a value, + * <code>x</code>, the hyperbolic cosine is <code>(e<sup>x</sup> + + * e<sup>-x</sup>)/2</code> + * with <code>e</code> being <a href="#E">Euler's number</a>. The returned + * result must be within 2.5 ulps of the exact result. + * </p> + * <p> + * If the supplied value is <code>NaN</code>, then the original value is + * returned. For either infinity, positive infinity is returned. + * The hyperbolic cosine of zero must be 1.0. + * </p> + * + * @param a the numeric argument + * @return the hyperbolic cosine of <code>a</code>. + * @since 1.5 + */ + public static native double cosh(double a); + + /** + * <p> + * Returns <code>e<sup>a</sup> - 1. For values close to 0, the + * result of <code>expm1(a) + 1</code> tend to be much closer to the + * exact result than simply <code>exp(x)</code>. The result must be within + * 1 ulp of the exact result, and results must be semi-monotonic. For finite + * inputs, the returned value must be greater than or equal to -1.0. Once + * a result enters within half a ulp of this limit, the limit is returned. + * </p> + * <p> + * For <code>NaN</code>, positive infinity and zero, the original value + * is returned. Negative infinity returns a result of -1.0 (the limit). + * </p> + * + * @param a the numeric argument + * @return <code>e<sup>a</sup> - 1</code> + * @since 1.5 + */ + public static native double expm1(double a); + + /** + * <p> + * Returns the hypotenuse, <code>a<sup>2</sup> + b<sup>2</sup></code>, + * without intermediate overflow or underflow. The returned result must be + * within 1 ulp of the exact result. If one parameter is held constant, + * then the result in the other parameter must be semi-monotonic. + * </p> + * <p> + * If either of the arguments is an infinity, then the returned result + * is positive infinity. Otherwise, if either argument is <code>NaN</code>, + * then <code>NaN</code> is returned. + * </p> + * + * @param a the first parameter. + * @param b the second parameter. + * @return the hypotenuse matching the supplied parameters. + * @since 1.5 + */ + public static native double hypot(double a, double b); + + /** + * <p> + * Returns the base 10 logarithm of the supplied value. The returned + * result must within 1 ulp of the exact result, and the results must be + * semi-monotonic. + * </p> + * <p> + * Arguments of either <code>NaN</code> or less than zero return + * <code>NaN</code>. An argument of positive infinity returns positive + * infinity. Negative infinity is returned if either positive or negative + * zero is supplied. Where the argument is the result of + * <code>10<sup>n</sup</code>, then <code>n</code> is returned. + * </p> + * + * @param a the numeric argument. + * @return the base 10 logarithm of <code>a</code>. + * @since 1.5 + */ + public static native double log10(double a); + + /** + * <p> + * Returns the natural logarithm resulting from the sum of the argument, + * <code>a</code> and 1. For values close to 0, the + * result of <code>log1p(a)</code> tend to be much closer to the + * exact result than simply <code>log(1.0+a)</code>. The returned + * result must be within 1 ulp of the exact result, and the results must be + * semi-monotonic. + * </p> + * <p> + * Arguments of either <code>NaN</code> or less than -1 return + * <code>NaN</code>. An argument of positive infinity or zero + * returns the original argument. Negative infinity is returned from an + * argument of -1. + * </p> + * + * @param a the numeric argument. + * @return the natural logarithm of <code>a</code> + 1. + * @since 1.5 + */ + public static native double log1p(double a); + + /** + * <p> + * Returns the hyperbolic sine of the given value. For a value, + * <code>x</code>, the hyperbolic sine is <code>(e<sup>x</sup> - + * e<sup>-x</sup>)/2</code> + * with <code>e</code> being <a href="#E">Euler's number</a>. The returned + * result must be within 2.5 ulps of the exact result. + * </p> + * <p> + * If the supplied value is <code>NaN</code>, an infinity or a zero, then the + * original value is returned. + * </p> + * + * @param a the numeric argument + * @return the hyperbolic sine of <code>a</code>. + * @since 1.5 + */ + public static native double sinh(double a); + + /** + * <p> + * Returns the hyperbolic tangent of the given value. For a value, + * <code>x</code>, the hyperbolic tangent is <code>(e<sup>x</sup> - + * e<sup>-x</sup>)/(e<sup>x</sup> + e<sup>-x</sup>)</code> + * (i.e. <code>sinh(a)/cosh(a)</code>) + * with <code>e</code> being <a href="#E">Euler's number</a>. The returned + * result must be within 2.5 ulps of the exact result. The absolute value + * of the exact result is always less than 1. Computed results are thus + * less than or equal to 1 for finite arguments, with results within + * half a ulp of either positive or negative 1 returning the appropriate + * limit value (i.e. as if the argument was an infinity). + * </p> + * <p> + * If the supplied value is <code>NaN</code> or zero, then the original + * value is returned. Positive infinity returns +1.0 and negative infinity + * returns -1.0. + * </p> + * + * @param a the numeric argument + * @return the hyperbolic tangent of <code>a</code>. + * @since 1.5 + */ + public static native double tanh(double a); + +} diff --git a/libjava/classpath/vm/reference/java/lang/VMProcess.java b/libjava/classpath/vm/reference/java/lang/VMProcess.java index fa157d752e9..26cfcc9bc1b 100644 --- a/libjava/classpath/vm/reference/java/lang/VMProcess.java +++ b/libjava/classpath/vm/reference/java/lang/VMProcess.java @@ -50,7 +50,7 @@ import java.util.LinkedList; * is {@link Object#notifyAll notifyAll()}'d each time the state changes. * The state of all instances is managed by a single dedicated thread * which does the actual fork()/exec() and wait() system calls. User - * threads {@link Object#wait wait()} on the instance when creating the + * threads {@link Object#wait()} on the instance when creating the * process or waiting for it to terminate. * * <p> @@ -60,7 +60,7 @@ import java.util.LinkedList; * * @author Archie Cobbs * @see Process - * @see Runtime#exec + * @see Runtime#exec(String) */ final class VMProcess extends Process { diff --git a/libjava/classpath/vm/reference/java/lang/VMSystem.java b/libjava/classpath/vm/reference/java/lang/VMSystem.java index 70f9dbac267..8a83cad92ff 100644 --- a/libjava/classpath/vm/reference/java/lang/VMSystem.java +++ b/libjava/classpath/vm/reference/java/lang/VMSystem.java @@ -101,7 +101,7 @@ final class VMSystem */ /** - * Set {@link #in} to a new InputStream. + * Set {@link System#in} to a new InputStream. * * @param in the new InputStream * @see #setIn(InputStream) @@ -109,7 +109,7 @@ final class VMSystem static native void setIn(InputStream in); /** - * Set {@link #out} to a new PrintStream. + * Set {@link System#out} to a new PrintStream. * * @param out the new PrintStream * @see #setOut(PrintStream) @@ -117,7 +117,7 @@ final class VMSystem static native void setOut(PrintStream out); /** - * Set {@link #err} to a new PrintStream. + * Set {@link System#err} to a new PrintStream. * * @param err the new PrintStream * @see #setErr(PrintStream) diff --git a/libjava/classpath/vm/reference/java/lang/reflect/Constructor.java b/libjava/classpath/vm/reference/java/lang/reflect/Constructor.java index cddb9ad5e66..cb633db115c 100644 --- a/libjava/classpath/vm/reference/java/lang/reflect/Constructor.java +++ b/libjava/classpath/vm/reference/java/lang/reflect/Constructor.java @@ -66,8 +66,8 @@ import java.util.Arrays; * @author Eric Blake <ebb9@email.byu.edu> * @see Member * @see Class - * @see java.lang.Class#getConstructor(Object[]) - * @see java.lang.Class#getDeclaredConstructor(Object[]) + * @see java.lang.Class#getConstructor(Class[]) + * @see java.lang.Class#getDeclaredConstructor(Class[]) * @see java.lang.Class#getConstructors() * @see java.lang.Class#getDeclaredConstructors() * @since 1.1 diff --git a/libjava/classpath/vm/reference/java/lang/reflect/Method.java b/libjava/classpath/vm/reference/java/lang/reflect/Method.java index f289e776337..27256770e52 100644 --- a/libjava/classpath/vm/reference/java/lang/reflect/Method.java +++ b/libjava/classpath/vm/reference/java/lang/reflect/Method.java @@ -66,8 +66,8 @@ import java.util.Arrays; * @author Eric Blake <ebb9@email.byu.edu> * @see Member * @see Class - * @see java.lang.Class#getMethod(String,Object[]) - * @see java.lang.Class#getDeclaredMethod(String,Object[]) + * @see java.lang.Class#getMethod(String,Class[]) + * @see java.lang.Class#getDeclaredMethod(String,Class[]) * @see java.lang.Class#getMethods() * @see java.lang.Class#getDeclaredMethods() * @since 1.1 diff --git a/libjava/classpath/vm/reference/java/lang/reflect/VMProxy.java b/libjava/classpath/vm/reference/java/lang/reflect/VMProxy.java index d3a2f17b7fe..8c7b67a7202 100644 --- a/libjava/classpath/vm/reference/java/lang/reflect/VMProxy.java +++ b/libjava/classpath/vm/reference/java/lang/reflect/VMProxy.java @@ -83,10 +83,10 @@ final class VMProxy * were violated, except for problems with null * @throws NullPointerException if `interfaces' is null or contains * a null entry, or if handler is null - * @see Configuration#HAVE_NATIVE_GET_PROXY_CLASS + * @see #HAVE_NATIVE_GET_PROXY_CLASS * @see #getProxyClass(ClassLoader, Class[]) * @see #getProxyData(ClassLoader, Class[]) - * @see #generateProxyClass(ProxyData) + * @see #generateProxyClass(ClassLoader, Proxy.ProxyData) */ static native Class getProxyClass(ClassLoader loader, Class[] interfaces); @@ -105,10 +105,10 @@ final class VMProxy * were violated, except for problems with null * @throws NullPointerException if `interfaces' is null or contains * a null entry, or if handler is null - * @see Configuration.HAVE_NATIVE_GET_PROXY_DATA + * @see #HAVE_NATIVE_GET_PROXY_DATA * @see #getProxyClass(ClassLoader, Class[]) * @see #getProxyClass(ClassLoader, Class[]) - * @see ProxyType#getProxyData() + * @see Proxy.ProxyData#getProxyData(Proxy.ProxyType) */ static native Proxy.ProxyData getProxyData(ClassLoader loader, Class[] interfaces); @@ -129,7 +129,6 @@ final class VMProxy * @throws IllegalArgumentException if VM limitations are exceeded * @see #getProxyClass(ClassLoader, Class[]) * @see #getProxyClass(ClassLoader, Class[]) - * @see ProxyData#generateProxyClass(ClassLoader) */ static native Class generateProxyClass(ClassLoader loader, Proxy.ProxyData data); diff --git a/libjava/classpath/vm/reference/java/net/VMInetAddress.java b/libjava/classpath/vm/reference/java/net/VMInetAddress.java index 1253ded7327..19f5d7d341c 100644 --- a/libjava/classpath/vm/reference/java/net/VMInetAddress.java +++ b/libjava/classpath/vm/reference/java/net/VMInetAddress.java @@ -40,13 +40,7 @@ package java.net; import gnu.classpath.Configuration; -import java.io.IOException; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; -import java.io.ObjectStreamException; import java.io.Serializable; -import java.util.HashMap; -import java.util.StringTokenizer; class VMInetAddress implements Serializable { diff --git a/libjava/classpath/vm/reference/java/net/VMNetworkInterface.java b/libjava/classpath/vm/reference/java/net/VMNetworkInterface.java index d63de84529b..47f803246d5 100644 --- a/libjava/classpath/vm/reference/java/net/VMNetworkInterface.java +++ b/libjava/classpath/vm/reference/java/net/VMNetworkInterface.java @@ -40,7 +40,6 @@ package java.net; import gnu.classpath.Configuration; -import java.util.Enumeration; import java.util.Vector; /** |