gt:         if (!name.startsWith(MISC_PKG)) {
context: /*
   * Copyright (c) 2005, 2011, Oracle and/or its affiliates. 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.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.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.lang.reflect.Method;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.AccessibleObject;
  import java.lang.reflect.Modifier;
  import java.util.HashMap;
  import java.util.Map;
  import sun.misc.IOUtils;
  
  
  class Trampoline {
      static {
          if (Trampoline.class.getClassLoader() == null) {
              throw new Error(
                  "Trampoline must not be defined by the bootstrap classloader");
          }
      }
  
      private static void ensureInvocableMethod(Method m)
          throws InvocationTargetException
      {
          Class<?> clazz = m.getDeclaringClass();
          if (clazz.equals(AccessController.class) ||
              clazz.equals(Method.class) ||
              clazz.getName().startsWith("java.lang.invoke."))
              throw new InvocationTargetException(
                  new UnsupportedOperationException("invocation not supported"));
      }
  
      private static Object invoke(Method m, Object obj, Object[] params)
          throws InvocationTargetException, IllegalAccessException
      {
          ensureInvocableMethod(m);
          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<Signature, Method> sigs = new HashMap<Signature, Method>();
          while (cls != null) {
              boolean done = getInternalPublicMethods(cls, sigs);
              if (done) {
                  break;
              }
              getInterfaceMethods(cls, sigs);
              cls = cls.getSuperclass();
          }
          return sigs.values().toArray(new Method[sigs.size()]);
      }
  
      /*
       * Process the immediate interfaces of this class or interface.
       */
      private static void getInterfaceMethods(Class<?> cls,
                                              Map<Signature, Method> 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<Signature, Method> 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<Signature, Method> 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 = 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 {
          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() {
          try {
              return AccessController.doPrivileged(
                  new PrivilegedExceptionAction<Method>() {
                      public Method run() throws Exception {
                          Class<?> t = getTrampolineClass();
                          Class[] types = {
                              Method.class, Object.class, Object[].class
                          };
                          Method b = t.getDeclaredMethod("invoke", types);
                          b.setAccessible(true);
                          return b;
                      }
                  });
          } catch (Exception e) {
              throw (InternalError) new InternalError("bouncer cannot be found").initCause(e);
          }
      }
  
  
      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
      {
  