From 8aa540d2f783474d1d2e06f16744bf67b9c1facc Mon Sep 17 00:00:00 2001 From: Mark Wielaard Date: Fri, 10 Mar 2006 21:46:48 +0000 Subject: Imported GNU Classpath 0.90 Imported GNU Classpath 0.90 * scripts/makemake.tcl: Set gnu/java/awt/peer/swing to ignore. * gnu/classpath/jdwp/VMFrame.java (SIZE): New constant. * java/lang/VMCompiler.java: Use gnu.java.security.hash.MD5. * java/lang/Math.java: New override file. * java/lang/Character.java: Merged from Classpath. (start, end): Now 'int's. (canonicalName): New field. (CANONICAL_NAME, NO_SPACES_NAME, CONSTANT_NAME): New constants. (UnicodeBlock): Added argument. (of): New overload. (forName): New method. Updated unicode blocks. (sets): Updated. * sources.am: Regenerated. * Makefile.in: Likewise. From-SVN: r111942 --- .../vm/reference/java/io/VMObjectInputStream.java | 39 +- .../classpath/vm/reference/java/lang/VMClass.java | 12 +- .../vm/reference/java/lang/VMClassLoader.java | 1 - .../classpath/vm/reference/java/lang/VMMath.java | 493 +++++++++++++++++++++ .../vm/reference/java/lang/VMProcess.java | 4 +- .../classpath/vm/reference/java/lang/VMSystem.java | 6 +- .../reference/java/lang/reflect/Constructor.java | 4 +- .../vm/reference/java/lang/reflect/Method.java | 4 +- .../vm/reference/java/lang/reflect/VMProxy.java | 9 +- .../vm/reference/java/net/VMInetAddress.java | 6 - .../vm/reference/java/net/VMNetworkInterface.java | 1 - 11 files changed, 538 insertions(+), 41 deletions(-) create mode 100644 libjava/classpath/vm/reference/java/lang/VMMath.java (limited to 'libjava/classpath/vm/reference/java') diff --git a/libjava/classpath/vm/reference/java/io/VMObjectInputStream.java b/libjava/classpath/vm/reference/java/io/VMObjectInputStream.java index 93a42b1c..5fb56fc 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 a48e299..1b4c13e 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 getDeclaredClasses() 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 getDeclaredFields() 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 getDeclaredMethods() 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 a777462..7412afe 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 0000000..4d37824 --- /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 sin. 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 cos. 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 tan. 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 arcsin. 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 arccos. 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 arcsin. 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 arctan, for + * converting rectangular coordinates (x, y) to polar + * (r, theta). This computes the arctangent of x/y in the range + * of -pi to pi radians (-180 to 180 degrees). Special cases:

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 theta in the conversion of (x, y) to (r, theta) + * @see #atan(double) + */ + public static native double atan2(double y, double x); + + /** + * Take ea. The opposite of log(). 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 e + * @see #log(double) + * @see #pow(double, double) + */ + public static native double exp(double a); + + /** + * Take ln(a) (the natural log). The opposite of exp(). 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. + * + *

Note that the way to get logb(a) is to do this: + * ln(a) / ln(b). + * + * @param a the number to take the natural log of + * @return the natural log of a + * @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. + * + *

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:

(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 ab + */ + public static native double pow(double a, double b); + + /** + * Get the IEEE 754 floating point remainder on two numbers. This is the + * value of x - y * n, where n is the closest + * double to x / y (ties go to the even n); for a zero + * remainder, the sign is that of x. 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 Math.ceil(x) == -Math.floor(-x). + * + * @param a the value to act upon + * @return the nearest integer >= a + */ + 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 Math.ceil(x) == -Math.floor(-x). + * + * @param a the value to act upon + * @return the nearest integer <= a + */ + 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 a + */ + public static native double rint(double a); + + /** + *

+ * 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, x, the cube root + * of -x is equal to the negation of the cube root + * of x. + *

+ *

+ * For a square root, use sqrt. For other roots, use + * pow(a, 1 / rootNumber). + *

+ * + * @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); + + /** + *

+ * Returns the hyperbolic cosine of the given value. For a value, + * x, the hyperbolic cosine is (ex + + * e-x)/2 + * with e being Euler's number. The returned + * result must be within 2.5 ulps of the exact result. + *

+ *

+ * If the supplied value is NaN, then the original value is + * returned. For either infinity, positive infinity is returned. + * The hyperbolic cosine of zero must be 1.0. + *

+ * + * @param a the numeric argument + * @return the hyperbolic cosine of a. + * @since 1.5 + */ + public static native double cosh(double a); + + /** + *

+ * Returns ea - 1. For values close to 0, the + * result of expm1(a) + 1 tend to be much closer to the + * exact result than simply exp(x). 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. + *

+ *

+ * For NaN, positive infinity and zero, the original value + * is returned. Negative infinity returns a result of -1.0 (the limit). + *

+ * + * @param a the numeric argument + * @return ea - 1 + * @since 1.5 + */ + public static native double expm1(double a); + + /** + *

+ * Returns the hypotenuse, a2 + b2, + * 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. + *

+ *

+ * If either of the arguments is an infinity, then the returned result + * is positive infinity. Otherwise, if either argument is NaN, + * then NaN is returned. + *

+ * + * @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); + + /** + *

+ * 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. + *

+ *

+ * Arguments of either NaN or less than zero return + * NaN. 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 + * 10n, then n is returned. + *

+ * + * @param a the numeric argument. + * @return the base 10 logarithm of a. + * @since 1.5 + */ + public static native double log10(double a); + + /** + *

+ * Returns the natural logarithm resulting from the sum of the argument, + * a and 1. For values close to 0, the + * result of log1p(a) tend to be much closer to the + * exact result than simply log(1.0+a). The returned + * result must be within 1 ulp of the exact result, and the results must be + * semi-monotonic. + *

+ *

+ * Arguments of either NaN or less than -1 return + * NaN. An argument of positive infinity or zero + * returns the original argument. Negative infinity is returned from an + * argument of -1. + *

+ * + * @param a the numeric argument. + * @return the natural logarithm of a + 1. + * @since 1.5 + */ + public static native double log1p(double a); + + /** + *

+ * Returns the hyperbolic sine of the given value. For a value, + * x, the hyperbolic sine is (ex - + * e-x)/2 + * with e being Euler's number. The returned + * result must be within 2.5 ulps of the exact result. + *

+ *

+ * If the supplied value is NaN, an infinity or a zero, then the + * original value is returned. + *

+ * + * @param a the numeric argument + * @return the hyperbolic sine of a. + * @since 1.5 + */ + public static native double sinh(double a); + + /** + *

+ * Returns the hyperbolic tangent of the given value. For a value, + * x, the hyperbolic tangent is (ex - + * e-x)/(ex + e-x) + * (i.e. sinh(a)/cosh(a)) + * with e being Euler's number. 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). + *

+ *

+ * If the supplied value is NaN or zero, then the original + * value is returned. Positive infinity returns +1.0 and negative infinity + * returns -1.0. + *

+ * + * @param a the numeric argument + * @return the hyperbolic tangent of a. + * @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 fa157d7..26cfcc9 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. * *

@@ -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 70f9dba..8a83cad 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 cddb9ad..cb633db 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 * @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 f289e77..2725677 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 * @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 d3a2f17..8c7b67a 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 1253ded..19f5d7d 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 d63de84..47f8032 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; /** -- cgit v1.1