Menu
▾
▴
[Jnode-svn-commits] SF.net SVN: jnode: [3276] trunk/core/src/openjdk/sun/sun/reflect
|
From: <ls...@us...> - 2007-06-17 10:56:14
|
Revision: 3276
http://jnode.svn.sourceforge.net/jnode/?rev=3276&view=rev
Author: lsantha
Date: 2007-06-17 03:56:12 -0700 (Sun, 17 Jun 2007)
Log Message:
-----------
Openjdk integration.
Added Paths:
-----------
trunk/core/src/openjdk/sun/sun/reflect/misc/
trunk/core/src/openjdk/sun/sun/reflect/misc/ConstructorUtil.java
trunk/core/src/openjdk/sun/sun/reflect/misc/FieldUtil.java
trunk/core/src/openjdk/sun/sun/reflect/misc/MethodUtil.java
trunk/core/src/openjdk/sun/sun/reflect/misc/ReflectUtil.java
Added: trunk/core/src/openjdk/sun/sun/reflect/misc/ConstructorUtil.java
===================================================================
--- trunk/core/src/openjdk/sun/sun/reflect/misc/ConstructorUtil.java (rev 0)
+++ trunk/core/src/openjdk/sun/sun/reflect/misc/ConstructorUtil.java 2007-06-17 10:56:12 UTC (rev 3276)
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package sun.reflect.misc;
+
+import java.lang.reflect.Constructor;
+
+public final class ConstructorUtil {
+
+ private ConstructorUtil() {
+ }
+
+ public static Constructor getConstructor(Class cls, Class[] params)
+ throws NoSuchMethodException {
+ ReflectUtil.checkPackageAccess(cls);
+ return cls.getConstructor(params);
+ }
+
+ public static Constructor[] getConstructors(Class cls) {
+ ReflectUtil.checkPackageAccess(cls);
+ return cls.getConstructors();
+ }
+}
Added: trunk/core/src/openjdk/sun/sun/reflect/misc/FieldUtil.java
===================================================================
--- trunk/core/src/openjdk/sun/sun/reflect/misc/FieldUtil.java (rev 0)
+++ trunk/core/src/openjdk/sun/sun/reflect/misc/FieldUtil.java 2007-06-17 10:56:12 UTC (rev 3276)
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package sun.reflect.misc;
+
+import java.lang.reflect.Field;
+
+/*
+ * Create a trampoline class.
+ */
+public final class FieldUtil {
+
+ private FieldUtil() {
+ }
+
+ public static Field getField(Class cls, String name)
+ throws NoSuchFieldException {
+ ReflectUtil.checkPackageAccess(cls);
+ return cls.getField(name);
+ }
+
+ public static Field[] getFields(Class cls) {
+ ReflectUtil.checkPackageAccess(cls);
+ return cls.getFields();
+ }
+
+ public static Field[] getDeclaredFields(Class cls) {
+ ReflectUtil.checkPackageAccess(cls);
+ return cls.getDeclaredFields();
+ }
+}
Added: trunk/core/src/openjdk/sun/sun/reflect/misc/MethodUtil.java
===================================================================
--- trunk/core/src/openjdk/sun/sun/reflect/misc/MethodUtil.java (rev 0)
+++ trunk/core/src/openjdk/sun/sun/reflect/misc/MethodUtil.java 2007-06-17 10:56:12 UTC (rev 3276)
@@ -0,0 +1,428 @@
+/*
+ * Copyright 2005-2006 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package sun.reflect.misc;
+
+import java.security.AllPermission;
+import java.security.AccessController;
+import java.security.PermissionCollection;
+import java.security.SecureClassLoader;
+import java.security.PrivilegedExceptionAction;
+import java.security.CodeSource;
+import java.io.InputStream;
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.HttpURLConnection;
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Modifier;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import sun.net.www.ParseUtil;
+import sun.security.util.SecurityConstants;
+
+
+class Trampoline {
+ private static Object invoke(Method m, Object obj, Object[] params)
+ throws InvocationTargetException, IllegalAccessException {
+ return m.invoke(obj, params);
+ }
+}
+
+/*
+ * Create a trampoline class.
+ */
+public final class MethodUtil extends SecureClassLoader {
+ private static String MISC_PKG = "sun.reflect.misc.";
+ private static String TRAMPOLINE = MISC_PKG + "Trampoline";
+ private static Method bounce = getTrampoline();
+
+ private MethodUtil() {
+ super();
+ }
+
+ public static Method getMethod(Class cls, String name, Class[] args)
+ throws NoSuchMethodException {
+ ReflectUtil.checkPackageAccess(cls);
+ return cls.getMethod(name, args);
+ }
+
+ public static Method[] getMethods(Class cls) {
+ ReflectUtil.checkPackageAccess(cls);
+ return cls.getMethods();
+ }
+
+ /*
+ * Discover the public methods on public classes
+ * and interfaces accessible to any caller by calling
+ * Class.getMethods() and walking towards Object until
+ * we're done.
+ */
+ public static Method[] getPublicMethods(Class cls) {
+ // compatibility for update release
+ if (System.getSecurityManager() == null) {
+ return cls.getMethods();
+ }
+ Map sigs = new HashMap();
+ while (cls != null) {
+ boolean done = getInternalPublicMethods(cls, sigs);
+ if (done) {
+ break;
+ }
+ getInterfaceMethods(cls, sigs);
+ cls = cls.getSuperclass();
+ }
+ Collection c = sigs.values();
+ return (Method[]) c.toArray(new Method[c.size()]);
+ }
+
+ /*
+ * Process the immediate interfaces of this class or interface.
+ */
+ private static void getInterfaceMethods(Class cls, Map sigs) {
+ Class[] intfs = cls.getInterfaces();
+ for (int i=0; i < intfs.length; i++) {
+ Class intf = intfs[i];
+ boolean done = getInternalPublicMethods(intf, sigs);
+ if (!done) {
+ getInterfaceMethods(intf, sigs);
+ }
+ }
+ }
+
+ /*
+ *
+ * Process the methods in this class or interface
+ */
+ private static boolean getInternalPublicMethods(Class cls, Map sigs) {
+ Method[] methods = null;
+ try {
+ /*
+ * This class or interface is non-public so we
+ * can't use any of it's methods. Go back and
+ * try again with a superclass or superinterface.
+ */
+ if (!Modifier.isPublic(cls.getModifiers())) {
+ return false;
+ }
+ if (!ReflectUtil.isPackageAccessible(cls)) {
+ return false;
+ }
+
+ methods = cls.getMethods();
+ } catch (SecurityException se) {
+ return false;
+ }
+
+ /*
+ * Check for inherited methods with non-public
+ * declaring classes. They might override and hide
+ * methods from their superclasses or
+ * superinterfaces.
+ */
+ boolean done = true;
+ for (int i=0; i < methods.length; i++) {
+ Class dc = methods[i].getDeclaringClass();
+ if (!Modifier.isPublic(dc.getModifiers())) {
+ done = false;
+ break;
+ }
+ }
+
+ if (done) {
+ /*
+ * We're done. Spray all the methods into
+ * the list and then we're out of here.
+ */
+ for (int i=0; i < methods.length; i++) {
+ addMethod(sigs, methods[i]);
+ }
+ } else {
+ /*
+ * Simulate cls.getDeclaredMethods() by
+ * stripping away inherited methods.
+ */
+ for (int i=0; i < methods.length; i++) {
+ Class dc = methods[i].getDeclaringClass();
+ if (cls.equals(dc)) {
+ addMethod(sigs, methods[i]);
+ }
+ }
+ }
+ return done;
+ }
+
+ private static void addMethod(Map sigs, Method method) {
+ Signature signature = new Signature(method);
+ if (!sigs.containsKey(signature)) {
+ sigs.put(signature, method);
+ } else if (!method.getDeclaringClass().isInterface()){
+ /*
+ * Superclasses beat interfaces.
+ */
+ Method old = (Method)sigs.get(signature);
+ if (old.getDeclaringClass().isInterface()) {
+ sigs.put(signature, method);
+ }
+ }
+ }
+
+ /**
+ * A class that represents the unique elements of a method that will be a
+ * key in the method cache.
+ */
+ private static class Signature {
+ private String methodName;
+ private Class[] argClasses;
+
+ private volatile int hashCode = 0;
+
+ Signature(Method m) {
+ this.methodName = m.getName();
+ this.argClasses = m.getParameterTypes();
+ }
+
+ public boolean equals(Object o2) {
+ if (this == o2) {
+ return true;
+ }
+ Signature that = (Signature)o2;
+ if (!(methodName.equals(that.methodName))) {
+ return false;
+ }
+ if (argClasses.length != that.argClasses.length) {
+ return false;
+ }
+ for (int i = 0; i < argClasses.length; i++) {
+ if (!(argClasses[i] == that.argClasses[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Hash code computed using algorithm suggested in
+ * Effective Java, Item 8.
+ */
+ public int hashCode() {
+ if (hashCode == 0) {
+ int result = 17;
+ result = 37 * result + methodName.hashCode();
+ if (argClasses != null) {
+ for (int i = 0; i < argClasses.length; i++) {
+ result = 37 * result + ((argClasses[i] == null) ? 0 :
+ argClasses[i].hashCode());
+ }
+ }
+ hashCode = result;
+ }
+ return hashCode;
+ }
+ }
+
+
+ /*
+ * Bounce through the trampoline.
+ */
+ public static Object invoke(Method m, Object obj, Object[] params)
+ throws InvocationTargetException, IllegalAccessException {
+ if (m.getDeclaringClass().equals(AccessController.class) ||
+ m.getDeclaringClass().equals(Method.class))
+ throw new InvocationTargetException(
+ new UnsupportedOperationException("invocation not supported"));
+ try {
+ return bounce.invoke(null, new Object[] {m, obj, params});
+ } catch (InvocationTargetException ie) {
+ Throwable t = ie.getCause();
+
+ if (t instanceof InvocationTargetException) {
+ throw (InvocationTargetException)t;
+ } else if (t instanceof IllegalAccessException) {
+ throw (IllegalAccessException)t;
+ } else if (t instanceof RuntimeException) {
+ throw (RuntimeException)t;
+ } else if (t instanceof Error) {
+ throw (Error)t;
+ } else {
+ throw new Error("Unexpected invocation error", t);
+ }
+ } catch (IllegalAccessException iae) {
+ // this can't happen
+ throw new Error("Unexpected invocation error", iae);
+ }
+ }
+
+ private static Method getTrampoline() {
+ Method tramp = null;
+
+ try {
+ tramp = (Method) AccessController.doPrivileged(new PrivilegedExceptionAction() {
+ public Object run() throws Exception {
+ Class[] types;
+ Class t = getTrampolineClass();
+ Method b;
+
+ types = new Class[] {Method.class, Object.class, Object[].class};
+ b = t.getDeclaredMethod("invoke", types);
+ ((AccessibleObject)b).setAccessible(true);
+ return b;
+ }
+ });
+ } catch (Exception e) {
+ throw new InternalError("bouncer cannot be found");
+ }
+ return tramp;
+ }
+
+
+ protected synchronized Class loadClass(String name, boolean resolve)
+ throws ClassNotFoundException
+ {
+ // First, check if the class has already been loaded
+ ReflectUtil.checkPackageAccess(name);
+ Class c = findLoadedClass(name);
+ if (c == null) {
+ try {
+ c = findClass(name);
+ } catch (ClassNotFoundException e) {
+ // Fall through ...
+ }
+ if (c == null) {
+ c = getParent().loadClass(name);
+ }
+ }
+ if (resolve) {
+ resolveClass(c);
+ }
+ return c;
+ }
+
+
+ protected Class findClass(final String name)
+ throws ClassNotFoundException
+ {
+ if (!name.startsWith(MISC_PKG)) {
+ throw new ClassNotFoundException(name);
+ }
+ String path = name.replace('.', '/').concat(".class");
+ URL res = getResource(path);
+ if (res != null) {
+ try {
+ return defineClass(name, res);
+ } catch (IOException e) {
+ throw new ClassNotFoundException(name, e);
+ }
+ } else {
+ throw new ClassNotFoundException(name);
+ }
+ }
+
+
+ /*
+ * Define the proxy classes
+ */
+ private Class defineClass(String name, URL url) throws IOException {
+ byte[] b = getBytes(url);
+ CodeSource cs = new CodeSource(null, (java.security.cert.Certificate[])null);
+ if (!name.equals(TRAMPOLINE)) {
+ throw new IOException("MethodUtil: bad name " + name);
+ }
+ return defineClass(name, b, 0, b.length, cs);
+ }
+
+
+ /*
+ * Returns the contents of the specified URL as an array of bytes.
+ */
+ private static byte[] getBytes(URL url) throws IOException {
+ URLConnection uc = url.openConnection();
+ if (uc instanceof java.net.HttpURLConnection) {
+ java.net.HttpURLConnection huc = (java.net.HttpURLConnection) uc;
+ int code = huc.getResponseCode();
+ if (code >= java.net.HttpURLConnection.HTTP_BAD_REQUEST) {
+ throw new IOException("open HTTP connection failed.");
+ }
+ }
+ int len = uc.getContentLength();
+ InputStream in = new BufferedInputStream(uc.getInputStream());
+
+ byte[] b;
+ try {
+ if (len != -1) {
+ // Read exactly len bytes from the input stream
+ b = new byte[len];
+ while (len > 0) {
+ int n = in.read(b, b.length - len, len);
+ if (n == -1) {
+ throw new IOException("unexpected EOF");
+ }
+ len -= n;
+ }
+ } else {
+ b = new byte[8192];
+ int total = 0;
+ while ((len = in.read(b, total, b.length - total)) != -1) {
+ total += len;
+ if (total >= b.length) {
+ byte[] tmp = new byte[total * 2];
+ System.arraycopy(b, 0, tmp, 0, total);
+ b = tmp;
+ }
+ }
+ // Trim array to correct size, if necessary
+ if (total != b.length) {
+ byte[] tmp = new byte[total];
+ System.arraycopy(b, 0, tmp, 0, total);
+ b = tmp;
+ }
+ }
+ } finally {
+ in.close();
+ }
+ return b;
+ }
+
+
+ protected PermissionCollection getPermissions(CodeSource codesource)
+ {
+ PermissionCollection perms = super.getPermissions(codesource);
+ perms.add(new AllPermission());
+ return perms;
+ }
+
+ private static Class getTrampolineClass() {
+ try {
+ return Class.forName(TRAMPOLINE, true, new MethodUtil());
+ } catch (ClassNotFoundException e) {
+ }
+ return null;
+ }
+
+}
Added: trunk/core/src/openjdk/sun/sun/reflect/misc/ReflectUtil.java
===================================================================
--- trunk/core/src/openjdk/sun/sun/reflect/misc/ReflectUtil.java (rev 0)
+++ trunk/core/src/openjdk/sun/sun/reflect/misc/ReflectUtil.java 2007-06-17 10:56:12 UTC (rev 3276)
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+
+package sun.reflect.misc;
+
+import java.lang.reflect.Modifier;
+import sun.reflect.Reflection;
+
+public final class ReflectUtil {
+
+ private ReflectUtil() {
+ }
+
+ public static Class forName(String name)
+ throws ClassNotFoundException {
+ checkPackageAccess(name);
+ return Class.forName(name);
+ }
+
+ public static Object newInstance(Class cls)
+ throws InstantiationException, IllegalAccessException {
+ checkPackageAccess(cls);
+ return cls.newInstance();
+ }
+
+ /*
+ * Reflection.ensureMemberAccess is overly-restrictive
+ * due to a bug. We awkwardly work around it for now.
+ */
+ public static void ensureMemberAccess(Class currentClass,
+ Class memberClass,
+ Object target,
+ int modifiers)
+ throws IllegalAccessException
+ {
+ if (target == null && Modifier.isProtected(modifiers)) {
+ int mods = modifiers;
+ mods = mods & (~Modifier.PROTECTED);
+ mods = mods | Modifier.PUBLIC;
+
+ /*
+ * See if we fail because of class modifiers
+ */
+ Reflection.ensureMemberAccess(currentClass,
+ memberClass,
+ target,
+ mods);
+ try {
+ /*
+ * We're still here so class access was ok.
+ * Now try with default field access.
+ */
+ mods = mods & (~Modifier.PUBLIC);
+ Reflection.ensureMemberAccess(currentClass,
+ memberClass,
+ target,
+ mods);
+ /*
+ * We're still here so access is ok without
+ * checking for protected.
+ */
+ return;
+ } catch (IllegalAccessException e) {
+ /*
+ * Access failed but we're 'protected' so
+ * if the test below succeeds then we're ok.
+ */
+ if (isSubclassOf(currentClass, memberClass)) {
+ return;
+ } else {
+ throw e;
+ }
+ }
+ } else {
+ Reflection.ensureMemberAccess(currentClass,
+ memberClass,
+ target,
+ modifiers);
+ }
+ }
+
+ private static boolean isSubclassOf(Class queryClass,
+ Class ofClass)
+ {
+ while (queryClass != null) {
+ if (queryClass == ofClass) {
+ return true;
+ }
+ queryClass = queryClass.getSuperclass();
+ }
+ return false;
+ }
+
+
+ public static void checkPackageAccess(Class clazz) {
+ checkPackageAccess(clazz.getName());
+ }
+
+ public static void checkPackageAccess(String name) {
+ SecurityManager s = System.getSecurityManager();
+ if (s != null) {
+ String cname = name.replace('/', '.');
+ if (cname.startsWith("[")) {
+ int b = cname.lastIndexOf('[') + 2;
+ if (b > 1 && b < cname.length()) {
+ cname = cname.substring(b);
+ }
+ }
+ int i = cname.lastIndexOf('.');
+ if (i != -1) {
+ s.checkPackageAccess(cname.substring(0, i));
+ }
+ }
+ }
+
+ public static boolean isPackageAccessible(Class clazz) {
+ try {
+ checkPackageAccess(clazz);
+ } catch (SecurityException e) {
+ return false;
+ }
+ return true;
+ }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
