path: root/java/jdk15/files/patch-javascript_ReflectUtil.java

$FreeBSD$

--- ../../deploy/src/plugin/src/share/classes/sun/plugin/javascript/ReflectUtil.java	1 Jan 1970 00:00:00 -0000
+++ ../../deploy/src/plugin/src/share/classes/sun/plugin/javascript/ReflectUtil.java	3 Dec 2004 03:56:58 -0000	1.1
@@ -0,0 +1,307 @@
+/*
+ * @(#)ReflectUtil.java	1.1 04/06/20
+ *
+ * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+package sun.plugin.javascript;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Iterator;
+import sun.plugin.javascript.JSClassLoader;
+
+public class ReflectUtil {
+    /*
+     * Discover the public methods on public classes
+     * and interfaces accessible to the calling
+     * JavaScript code. 
+     */
+     public static Method[] getJScriptMethods(Class cls) {
+	List m = new ArrayList(); /* the valid methods we find */
+
+	/*
+	 * Temporary map of method signatures when we decide
+	 * that a simple call to target.getMethods() returns
+	 * inaccessible methods and we must search for alternative
+	 * supermethods that might be accessible. We can toss
+	 * this when we're done searching.
+	 */
+	Map sigs = new HashMap();
+
+	while (cls != null) {
+	    boolean done = getPublicMethods(cls, m, sigs);
+	    if (done) {
+		break;
+	    }
+	    getJScriptInterfaceMethods(cls, m, sigs);
+	    cls = cls.getSuperclass();
+	}
+	return (Method[]) m.toArray(new Method[m.size()]);
+    }
+
+    /*
+     * Process the immediate interfaces of this class or interface.
+     */
+    private static void getJScriptInterfaceMethods(Class cls, List m, Map sigs) {
+	Class[] intfs = cls.getInterfaces();
+	for (int i=0; i < intfs.length; i++) {
+	    Class intf = intfs[i];
+	    boolean done = getPublicMethods(intf, m, sigs);
+	    if (!done) {
+	        getJScriptInterfaceMethods(intf, m, sigs);
+	    }
+	}
+    }
+
+    /*
+     *
+     * Process the methods in this class or interface
+     */
+    private static boolean getPublicMethods(Class cls, List m, 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 (!JSClassLoader.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;
+	    }
+	}
+
+	/*
+	 * Belatedly initialize the signature map if
+	 * this is not the first time here.
+	 */
+	if (sigs.isEmpty() && !m.isEmpty()) {
+	    initSignatureMap(m, sigs);
+	}
+
+	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(m, 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(m, sigs, methods[i]);
+		}
+	    }
+	}
+	return done;
+    }
+
+    private static void initSignatureMap(List m, Map sigs) {
+	Iterator i = m.iterator();
+	while (i.hasNext()) {
+	    Method entry = (Method) i.next();
+	    sigs.put(getSignature(entry), entry);
+	}
+    }
+
+    private static void addMethod(List m, Map sigs, Method method) {
+	/*
+	 * Avoid work. We ignore the signature matching
+	 * until the map is initialized in initSignatureMap.
+ 	 * This has the effect of avoiding the signature
+	 * work for the first call of getPublicMethods().
+	 */
+	if (sigs.isEmpty()) {
+	    m.add(method);
+	    return;
+	}
+
+	/*
+	 * Avoid adding duplicate accessible methods on
+	 * the list.
+	 */
+	String signature = getSignature(method);
+	if (!sigs.containsKey(signature)) {
+	    m.add(method);
+	    sigs.put(signature, method);
+	}
+    }
+
+    /*
+     * Return a canonical method signature for the method.
+     * We care only about the simple method name and the
+     * the number, type and order of the parameters.
+     * Exception declarations are not part of a method
+     * signature nor is the return type.
+     */
+    private static String getSignature(Method method) {
+	StringBuffer sb = new StringBuffer();
+
+	sb.append(method.getName());
+	Class[] params = method.getParameterTypes();
+	sb.append('(');
+	if (params.length > 0) {
+	    sb.append(params[0].getName());
+	}
+	for (int i=1; i < params.length; i++) {
+	    sb.append(',');
+	    sb.append(params[i].getName());
+	}
+        sb.append(')');
+	
+	return sb.toString();
+    }
+
+    /*
+     * Discover the public fields on public classes
+     * and interfaces accessible to the calling
+     * JavaScript code. 
+     */
+     public static Field[] getJScriptFields(Class cls) {
+	List m = new ArrayList(); /* the valid fields we find */
+
+	/*
+	 * Temporary map of field name when we decide
+	 * that a simple call to target.getFields() returns
+	 * inaccessible fields and we must search for alternative
+	 * supermethods that might be accessible. We can toss
+	 * this when we're done searching.
+	 */
+	Map names = new HashMap();
+
+	while (cls != null) {
+	    boolean done = getPublicFields(cls, m, names);
+	    if (done) {
+		break;
+	    }
+	    getJScriptInterfaceFields(cls, m, names);
+	    cls = cls.getSuperclass();
+	}
+	return (Field[]) m.toArray(new Field[m.size()]);
+    }
+
+    /*
+     * Process the immediate interfaces of this class or interface.
+     */
+    private static void getJScriptInterfaceFields(Class cls, List m, Map names) {
+	Class[] intfs = cls.getInterfaces();
+	for (int i=0; i < intfs.length; i++) {
+	    Class intf = intfs[i];
+	    boolean done = getPublicFields(intf, m, names);
+	    if (!done) {
+	        getJScriptInterfaceFields(intf, m, names);
+	    }
+	}
+    }
+
+    /*
+     *
+     * Process the fields in this class or interface
+     */
+    private static boolean getPublicFields(Class cls, List m, Map names) {
+	Field[] fields = null;
+	try {
+
+	    /*
+	     * This class or interface is non-public so we
+	     * can't use any of it's fields. Go back and
+	     * try again with a superclass or superinterface.
+	     */
+	    if (!Modifier.isPublic(cls.getModifiers())) {
+		return false;
+	    }
+
+	    if (!JSClassLoader.isPackageAccessible(cls)) {
+		return false;
+	    }
+	    fields = cls.getFields();
+	} catch (SecurityException se) {
+	    return false;
+        }
+
+	/*
+	 * Check for inherited fields with non-public
+	 * declaring classes. They might hide
+	 * fields from public classes or interfaces.
+	 */
+	boolean done = true;
+	for (int i=0; i < fields.length; i++) {
+	    Class dc = fields[i].getDeclaringClass();
+	    if (!Modifier.isPublic(dc.getModifiers())) {
+		done = false;
+		break;
+	    }
+	}
+	if (done) {
+	    /*
+	     * We're done. Spray all the fields into
+	     * the list and then we're out of here.
+	     */
+	    for (int i=0; i < fields.length; i++) {
+		addField(m, names, fields[i]);
+	    }
+	} else {
+	    /*
+	     * Simulate cls.getDeclaredFields() by
+	     * stripping away inherited fields.
+	     */
+	    for (int i=0; i < fields.length; i++) {
+		Class dc = fields[i].getDeclaringClass();
+		if (cls.equals(dc)) {
+		    addField(m, names, fields[i]);
+		}
+	    }
+	}
+	return done;
+    }
+
+    private static void addField(List m, Map names, Field field) {
+	/*
+	 * Avoid adding duplicate accessible fields on
+	 * the list.
+	 */
+	String name = field.getName();
+	if (!names.containsKey(name)) {
+	    m.add(field);
+	    names.put(name, field);
+	}
+    }
+}
+
+